當前位置：首頁 > 编程语言 > python >内容正文

python

Python基本语法(基于3.x)

發布時間：2025/4/9 python 35 豆豆

生活随笔收集整理的這篇文章主要介紹了 Python基本语法(基于3.x) 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

Python基本語法(基于3.x)

Python的兩種運行模式：

命令行模式，運行python,然后在命令行中輸入python命令
程序腳本, 在命令行中輸入 ./hello.py運行

Python是解釋形語言，但可以通過工具打包成二進制可執行文件

指定Python文件的編碼方式:#coding:utf-8

注釋符為#,多行注釋以'''開始，以'''結束

變量不需要聲明類型，可以自動推導，type()函數可以獲得變量類型

序列（sequence）是一組由順序的元素的集合，各元素類型可以不同，序列分三種

tuple(元組):tuple中的元素不可以變更，用()定義，也可以省略(),字符串是一種特殊元組
list:各個元素可以再變更,用[]定義
range:表示由數字組成的不可變序列，通常用于循環

一個序列可以作另一個序列的元素，用[]可以訪問序列元素，也可以使用范圍引用，表達式為[下限:上限:步長],獲取的數據索引到上限前一個元素

列表推導(list comprehension):快速生成表(list)的方法，示例:
L=[x**2 for x in range(10)],這與生成器表達式類似，只不過用的是中括號

詞典類型的定義dic={key1:value1,key2:value2},key可以使字符串，數字，bool型等，不可變對象都可以做鍵，創建字典的方法有: dict exampledict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) #{'sape': 4139, 'jack': 4098, 'guido': 4127}{x: x**2 for x in (2, 4, 6)} #{2: 4, 4: 16, 6: 36}dict(sape=4139, guido=4127, jack=4098) #{'sape': 4139, 'jack': 4098, 'guido': 4127}字典的循環如下，注意循環的key值
for key in dic:
??? print(dic[key])

字典的常用函數: keys(),values(),items(),clear()，還有一個常用用法是del dic['Tom'],刪除key為Tom的元素，del是Python中的關鍵字，不是函數，用于刪除對象

set:不重復元素的集合，可以用大括號或者set()函數創建set,set支持，支持交集,并集，差集等運算,并且也支持列表推導 set examplebasket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} print(basket)#返回{'orange', 'banana', 'pear', 'apple'}#定義空集 a=set()#注意{}定義的是空詞典b={}a = set('abracadabra') b = set('alacazam') print(a)#{'a', 'r', 'b', 'c', 'd'} print(a-b)#{'r', 'd', 'b'}#列表推導,注釋是大括號 a = {x for x in 'abracadabra' if x not in 'abc'} print(a)#{'r', 'd'}

函數定義的關鍵字：def, return可以返回多個值，如return a,b,c，相當于return(a,b,c)

函數參數的傳遞，可以使用關鍵字傳遞參數，這樣不用遵守位置的對應關系。定義函數時參數可以指定默認值
包裹參數傳遞：定義函數時在相應的元組或者字典前加*或者**,如
- func(*arr):arr是一個tuple,調用時，func(1,2,3,4)
- func(**dic):dic是一個字典，調用時,func(a=1,b=2,c=3)
解包裹:函數定義時未使用包裹參數，調用時傳入包裹參數，函數會自動進行拆解，注意調用時，參數值前要加*或者**,對應tuple和字典,如: def func(a,b,c): print(a,b,c) args = (1,3,4) func(*args)
函數也是對象,也可以作為參數傳給其他函數

python中一切都是對象,class是對象，實例也是對象，python中所有對象都允許動態添加屬性和方法,當類添加新屬性后，類的實例同樣能訪問該屬性。當訪問一個對象的屬性如obj.age時，查找該屬性的順序為:

對象自身的屬性(obj.__dict__中)
對象的類屬性(obj.__class__.__dict__中)
對象的類的基類，以及基類的基類(obj.__class__.__bases__中的每一個類的__dict__)，一直下去
最后未找到屬性，會拋出AttributeError異常

Python使用class定義類，類的實例方法第一個參數必須是self,用于引用對象本身，類似于this,類的成員以self.member形式在類中訪問，python中沒有public,private等關鍵字，類成員默認都為公開的,類的私有成員命名必須以__開始,在python內部使用name mangling技術將__membername重命名為_class__membername(classname是成員所在的類名),所以使用原有的私有成員名字會提示找不到，但使用_classname__membername仍然可以訪問該私有變量，所以python的私有成員不是絕對無法訪問的.注意以__開始__結尾的成員是系統保留名字，普通變量不能這樣命名

python的類方法包括三種:

實例方法，至少帶一個self(其他名也可以)參數，表示實例本身,由類的實例訪問，也可以由類直接訪問，但第一個參數的含義就變了實例方法class A:def test(self,age):print("hello")#self='b' A.test('b','c') a=A() #self=a，也可以寫為A.test(a,’c’) a.test('c')
帶@classmethod裝飾器的方法,至少帶一個參數cls,表示類本身可以通過類名訪問也可以通過實例訪問
帶@staticmethod裝飾器的方法，可以不帶參數，由類或者類的實例訪問

python class中的”靜態方法”和”靜態成員”:在python類作用域中，不帶self參數的方法和不使用self訪問的成員起到靜態成員的作用。對靜態成員要注意:

靜態成員使用class.member或者instance.member都可以訪問(如果沒有同名的實例成員，有則訪問實例成員). class是類名，instance是類的實例
如果靜態成員是值類型,為instance.member賦值相當于新建一個與該靜態成員同名的實例成員,不會影響class.Member的值，之后對class.member的改動不會反應到instance.member。如果未對instance.member進行賦值，對class.member的改動會反應到instance.member
如果靜態成員是引用類型，則對instance.member的改動會反應到class.member,也會反應到其他同類型實例的member

繼承的語法: class SubClass(ParentClass1,ParentClass2), ParentClass是父類，SubClass是子類

_特殊方法(special method):通過特殊的語法實現某些操作，是python實現操作符重載的方式,常用特殊方法有:

object.__new__(cls,…):是一個靜態方法(特殊方法，不用像聲明靜態函數那樣聲明)，用于創建一個類對象，創建出的對象會傳遞給__init__的self參數，函數的其余參數也傳遞給__init__。函數的參數由構造函數而來。如果子類中重寫了__new__函數，實例化對象時會調用子類的__new__,子類的__new__方法可以顯示調用基類的__new__,否則不會調用基類的__new__,子類如果沒重寫__new__則調用基類的__new__.
object._init__(self,…):相當于初始化過程。如:human = Human("male"); 參數male先傳給__new__再傳給__init__()方法,如果父類有__init__函數，子類重寫了__init__函數，應當在子類的__init__中調用父類的__init__函數以完成初始化,否則不會自動調用父類的__init__函數，如果子類沒有重寫__init__函數，實例化子類時則會調用父類的__init__函數
object.__del__():析構器,父類中如果有__del__函數，應該在子類的__del__函數中顯示調用此函數以確保資源被正常釋放
object.__call__():定義類型時，如果實現了實例方法__call__,那么實例就是可調用的，如x(5),相當于調用了x.__call__(5).如果是metaclass定義了__call__函數，那么其創建的類就是可調用的，與類實現__call__，則其實例是可調用的是一個道理
object__repr__():返回對象的offical representation string, 對于許多類型，將返回值傳給eval()函數可以得到一個具有相同值得對象
object.__str__():返回對象的informal representation string
object.__bytes__():返回對象的byte-string representation
class.__subclasses__():返回直接集成該類的子

特殊屬性(special attributes):只讀屬性,常用特殊屬性有:

object.__dict__:字典類型，存儲對象的屬性，不包括只讀屬性.要注意的是類實例的__dict__中不含其class.__dict__中的值,只包含實例本身的屬性和新加的屬性。
instance.__class__:對象的類型,準確說是創建該instance的類
class.__bases__:類的基類的元組,只有類類型才有該屬性，實例沒有 __class__ __bases__ example#返回<class 'type'>,因為int 類是由type類創建的對象 int.__class__ #返回<class 'object'>,int類的基類是object int.__bases__x="abc" #返回<class 'str'>x是由str類創建的對象 x.__class__
class.__name__:類名
class.__mro__:一個class的tuple，當解析方法時按照tuple中定義類的順序查找基類中的方法
class.__module__:class所屬的模塊名

python descriptor:如果定義的類(對象)具有__get__,__set__,__delete__方法中的任意一個，這個類(對象)就叫descriptor,作用是攔截屬性的訪問.descriptor屬性會改變普通屬性訪問時的查找 descriptor exampleclass Descriptor(object):def __init__(self, label):self.label = label#本例中，instance是f,owner是Foodef __get__(self, instance, owner):print( '__get__', instance, owner)return instance.__dict__.get(self.label)def __set__(self, instance, value):print ('__set__') #使用__dict__生成實例屬性，可以防止所有的實例都同樣的值，因為descriptor是類屬性instance.__dict__[self.label] = valueclass Foo(list): #decriptor只能應用與類屬性，不能用于實例屬性x = Descriptor('x')y = Descriptor('y')f = Foo() f.x = 5#會調用__set__ print(f.x)#會調用__get__

模塊(Module):一個.py文件就是一個模塊，模塊名必須是小寫字母和下劃線，使用import關鍵字引入其他模塊，使用模塊.對象的方式來訪問引入模塊中的對象.每個模塊中都有一個內置變量__name__,如果是模塊自己運行,__name__=’__main__’,如果被其他模塊import，則模塊的__name__就是等于模塊名(不包含擴展名),python中所有加載到內存的模塊都放在sys.modules中,import一個模塊時會首先查找這個列表。import的模塊會被加入當前模塊的名字空間，import模塊時會執行模塊中的代碼，import package時則會執行__init__.py中的代碼

import的一些用法：

import a as b :引入模塊a,并重命名為b
from a import func1: 從模塊a中引入func1對象，之后可以直接使用func1，而不用使用a.func1
from a import *:從模塊a中引入所有對象，這樣可以直接使用a中的對象，而不必用a.對象
module或package所在的目錄再sys.path中，那么就可以import模塊或package

Python會在以下路徑搜索它想要的模塊:

程序所在的文件夾
標準庫的安裝路徑
操作系統環境變量PYTHONPATH所包含的路徑

package：功能相似的模塊放在同一個文件夾中，就構成一個package，文件夾中必須包含一個__int__.py的文件(可以為空)以通知Python，該文件夾是一個package,通過：
import dir.module引用dir文件夾中的module

用于循環的函數：

range:
enumerate():可以在每次循環中同時得到下標和元素，for(index,value) in enumerate(arr)
zip():用于循環多個等長序列，每次循環從各個序列中分別取一個元素，for(a,b,c)in zip(arr1,arr2,arr3).zip的作用就是從各個序列中依次取出一個元素，合成一個tuple,返回值是一個zip類型對象，可以用list()函數轉換為list類型

生成器(Generator):構建一個用戶自定義的循環對象，編寫方法與函數類似，只是return改為yield，可以有多個yield，generator遇到yield時會暫停運行返回yield后面的值，再次調用生成器的時候，會從暫停的地方繼續運行，返回下一個yield值。生成器示例:
G=(x for x in range(4)),G就是一個生成器，用__next__()方法訪問其中的值

可迭代對象(iterable):python自帶的iterable包括,list,str,tuple,dict ,file,自定義了__iter__()或者__getitem__()類的實例也是,iterable.iter(iterable)就返回這個對象的迭代器

迭代器(iterator):__iter__方法就返回一個迭代器，迭代器可以使用next方法調用，也就是它實現了__next__方法,將一個class實現為迭代器它必須實現__iter__()和__next__()方法.迭代器只能向前迭代，不能回退，直到拋出StopIteration,不是線程安全的。for關鍵字是迭代器的語法糖，封裝了迭代器的循環操作。python自帶的類型tuple,list,set,dict,字符串都支持迭代器

lambda:示例 func=lambda x,y:x+y 調用跟普通函數一樣，func(3,5)

異常語法如下，自己拋出式樣使用raise關鍵字
try:...
except exception1:...
except exception2:...
except:...
else:...
finally:...如果沒有異常，則執行else語句,如果沒有對應的異常類型則會向上層拋出異常

上下文管理器：用于規定某個對象的使用范圍，語法：with ....as...，任何定義了__enter__()和__exit__()方法的對象都可用于上下文管理器 # with context manager with open("new.txt", "w") as f: print(f.closed)f.write("Hello World!") print(f.closed)

對象的Property(attribute的一種):使用內置函數property()來返回一個property，簽名如下: property(fget=None, fset=None, fdel=None, doc=None)

fget:獲取property value的函數,只傳遞此參數，省略其他參數，將會得到只讀property
fset:設置property value的函數
fdel:刪除property的函數
doc:property的注釋字符 property exampleclass C:def __init__(self):self._x = Nonedef getx(self):return self._xdef setx(self, value):self._x = valuedef delx(self):del self._xx = property(getx, setx, delx, "I'm the 'x' property.")c=C(); //調用getx a=c.x //調用setx c.x=9; //調用delx del c.x

可以把@property當做一個裝飾器，如下代碼效果同上: property exampleclass C:def __init__(self):self._x = None@propertydef x(self):"""I'm the 'x' property."""return self._x #函數名要與property name相同@x.setterdef x(self, value):self._x = value@x.deleterdef x(self):del self._x

通過自定義object.__getattr__函數，在對象引用的attribute不存在時自動調用該函數，此函數中返回attribute的值或者raise AttributeError exception.注意與obj.__getattribute__函數的區別，后者在每次屬性訪問時都會先調用，如果屬性不存在才會接著調用__getattr__ __getattr__ exampleclass Person():def __init__(self, age):self.age = agedef __getattr__(self, name):if name == 'adult':if self.age > 18: return Trueelse: return Falseelse: raise AttributeError(name)person = Person(20) #類中未定義adult attr print(person.adult)?

閉包:Python中的閉包是一個包含有環境變量取值的函數對象，環境變量取值被保存在函數對象的__closure__屬性中

裝飾器：對一個函數，方法或者類進行加工，可以使用def定義裝飾器，被裝飾函數或類前要加@裝飾器函數,實際上將square_sum傳遞給decorator，并將decorator返回的新的可調用對象賦給原來的函數名,即square_sum=decor(square_sum) ,square_sum變成了new_F函數 def decor(F): def new_F(a,b):print('decor') return F(a,b)return new_F@decor def square_sum(a, b): return a**2 + b**2print(square_sum(2,3))#調用的是new_F函數 print(square_sum(4,3))

裝飾器即裝飾器類示例 decoratordef decorator(func): # 裝飾器函數print('in decorator')def wrapper(*args):print('in decorator wrapper')wrapper._calls += 1print("calls = %d" % (wrapper._calls))func(*args)wrapper._calls = 0return wrapper@decorator def foo(x, y):print("x = %d, y = %d" % (x, y))foo(1, 2) # foo對象就被賦成了wrapper對象 """ in decorator #定義foo時就會輸出 in decorator wrapper calls = 1 x = 1, y = 2 """foo(2, 3) """ in decorator wrapper calls = 2 x = 2, y = 3 """ #################下面是一個裝飾類################################################ class decorator: #裝飾器類def __init__(self, func):print('in decorator __init__')self.func = funcself.calls = 0def __call__(self, *args):print('in decorator __call__')self.calls += 1print("calls = %d" % (self.calls))self.func(*args)@decorator def foo(x, y):print("x = %d, y = %d" % (x, y))foo(1, 2) # foo對象被賦值成了decorator對象 #執行過程先以foo為參數初始化decorator對象，調用foo(1,2)時則會調用decorator的__call__ """ in decorator __init__ #定義foo時輸出 in decorator __call__ calls = 1 x = 1, y = 2 """foo(2, 3) # 實際是調用decorator對象 """ in decorator __call__ calls = 2 x = 2, y = 3 """?

格式化字符串:Python使用一個字符串作模板，模板中有格式符，如print("I am %s,i am %d years old" %('Tom',10)),模板與tuple之間有一個%號分隔，它代表了格式化操作，可以用如下方式對格式進一步的控制:
%[(name)][flags][width].[precision]typecode
print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99})(使用字典傳遞真實值)

常用內置函數:

dir()用于查詢一個類或者對象所有屬性,其結果包含類或者對象的__dict__中包含的結果
help()用于查詢說明文檔
isinstance(objec,classinfo):返回對象是否是類的實例
issubclass(class,classinfo):class類是否是classinfo類的子類
repr():調用對象的__repr__,返回offical representation string，與反引號操作符作用相同，輸出對python友好，可以作為解釋器的輸入
str():調用對象的__str__，類似于c#的toString()功能，對人友好
bytes():調用對象的__bytes_
getattr():返回對象的屬性值，如果該屬性不存在會拋出AttributeError
hasattr():判斷類或對象是否包含某屬性
setattr():設置對象的屬性值,如果不存在會為對象添加新屬性，但不影響類的屬性.setattr(x,’name’,’tom’)相當于x.name=’tom’
delattr():刪除屬性,delattr(x,’foobar’) 相當于del x.foobar,不影響類屬性
iter():返回一個迭代器
vars():返回module,class,instance,或者是其他對象(包含__dict__屬性)的__dict__屬性
zip():以多個支持迭代器的對象為參數，返回一個tuples的迭代器，然后可以使用__next__()方法訪問每個tuple
super():訪問基類函數 class C(B):def method(self, arg):# This does the same thing as:# super(C, self).method(arg),相當于B.method(self,arg),但在多繼承情況下super函數能避免相同基類被多次調用super().method(arg)
map(函數對象，list...):功能是將函數對象依次作用于list的每一個元素,每次作用的結果存儲在返回的循環對象中，如果函數對象有多個參數，則后面可以有多個list，map函數每次從所有的list中取出一個值，作為函數的參數
filter(函數對象，list...):功能是將函數對象作用于多個元素，如果函數對象返回的是True,則返回該次的元素存儲在循環對象中
reduce(函數對象，list):函數對象只能接受兩個參數，可以累進的從list中取值，每一次調用函數對象的返回值與list中后面一個元素作為下次函數對象調用的參數。3.x中需要引入functools包?

內置函數列表：

??Built-in Functions??

abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()	?
delattr()	hash()	memoryview()	set()	?

posted on 2014-09-11 20:30 哨兵閱讀(...) 評論(...) 編輯收藏

轉載于:https://www.cnblogs.com/phenixyu/p/3967197.html

總結

以上是生活随笔為你收集整理的Python基本语法(基于3.x)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。