Python內建函數大全 - 程式前沿
文章推薦指數： 80 %
翻譯總結自官方文檔：原文地址Python 解釋器內置了許多函數和類型，列表如下（按字母排序）（省略了幾個我沒用過或者不常用的）。
- - 內建函數表- ...
程式語言前端開發IOS開發Android開發雲端運算人工智慧伺服器搜尋資料庫軟體開發工具Python內建函數大全2020.09.29程式語言HOME程式語言Python內建函數大全Advertisement翻譯總結自官方文檔：原文地址Python解釋器內置了許多函數和類型，列表如下（按字母排序）（省略了幾個我沒用過或者不常用的）。
––內建函數表––abs()delattr()hash()memoryview()set()all()dict()help()min()setattr()any()dir()hex()next()slice()ascii()divmod()id()object()sorted()bin()enumerate()input()oct()staticmethod()bool()eval()int()open()str()breakpoint()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()目錄1.abs(x)2.all(iterable)3.any(iterable)4.ascii(object)5.bin(x)6.classbool([x])7.classbytearray([source[,encoding[,errors]]])8.classbytes([source[,encoding[,errors]]])9.callable(object)10.chr(i)[email protected]([real[,imag]])13.delattr(object,name)14.dict15.dir([object])16.divmod(a,b)17.enumerate(iterable,start=0)18.filter(function,iterable)19.classfloat([x])20.format(value[,format_spec])21.classfrozenset([iterable])22.getattr(object,name[,default])23.globals()24.hasattr(object,name)25.hash(object)26.help([object])27.hex(x)28.id(object)29.input([prompt])30.int31.isinstance(object,classinfo)32.issubclass(class,classinfo)33.iter(object[,sentinel])34.len(s)35.classlist([iterable])36.locals()37.map(function,iterable,…)38.max39.min40.next(iterator[,default])41.classobject42.oct(x)43.open44.ord(c)45.pow(x,y[,z])46.print47.property48.range49.repr(object)50.reversed(seq)51.round(number[,ndigits])52.classset([iterable])53.setattr(object,name,value)[email protected](iterable[,start])59.super([type[,object-or-type]])60.tuple([iterable])61.type62.vars([object])63.zip(*iterables)63.1.相關文章abs(x)返回一個數字的絕對值。
參數可以是整數或浮點數。
如果參數是一個複數，則返回它的模。
all(iterable)如果iterable的所有元素均為True（或iterable為空），則返回True。
相當於：defall(iterable):
forelementiniterable:
ifnotelement:
returnFalse
returnTrue
any(iterable)如果iterable中有任何一個元素為true，則返回True。
如果iterable為空，則返回False。
相當於：defany(iterable):
forelementiniterable:
ifelement:
returnTrue
returnFalse
ascii(object)類似repr()，返回一個包含對象的可打印表示的字符串，但使用\x，\u或\U轉義符轉義由repr()返回的字符串中的非ASCII字符。
這會生成一個類似於Python2中repr()返回的字符串。
In[1]:s='python\n中文'
In[2]:ascii(s)
Out[2]:"'python\\n\\u4e2d\\u6587'"
In[3]:repr(s)
Out[3]:"'python\\n中文'"
bin(x)將整數轉換為以“0b”為前綴的二進制字符串。
結果是一個有效的Python表達式。
如果x不是Pythonint對象，則必須定義返回整數的__index__()方法。
一些例子：>>>bin(3)
'0b11'
>>>bin(-10)
'-0b1010'
可以使用以下任意方式，控制是否需要前綴“0b”：>>>format(14,'#b'),format(14,'b')
('0b1110','1110')
>>>f'{14:#b}',f'{14:b}'
('0b1110','1110')
有關更多信息，另請參閱format()。
當x不是int類型時In[1]:classTest:
...:def__init__(self,n):
...:self.n=n
...:
...:def__index__(self):
...:returnself.n
...:
In[2]:t=Test(10)
In[3]:bin(t)
Out[3]:'0b1010'
classbool([x])返回一個布爾值，即True或False中的一個。
x使用標準真值測試方式進行轉換。
如果x為false或省略，則返回False;否則返回True。
bool類是int的子類。
它不能進一步子類化。
它唯一的實例是False和True。
classbytearray([source[,encoding[,errors]]])返回一個新的字節數組。
bytearray類是一個在0<=x<256範圍內的可變整數序列。
可選的source參數可以用幾種不同的方式初始化數組：如果它是一個字符串，則還必須給出encoding（以及可選的errors）參數;然後bytearray()使用str.encode()將字符串轉換為字節。
如果它是一個整數，則將其作為數組的長度，並將用空字節進行初始化。
如果它是符合緩衝區接口的對象，則將使用該對象的只讀緩衝區來初始化字節數組。
如果它是一個iterable，必須是0<=x<256範圍內的可迭代對象，它們將被用作數組的初始內容。
沒有參數，就會創建一個大小為0的數組。
In[11]:bytearray(5)
Out[11]:bytearray(b'\x00\x00\x00\x00\x00')
In[12]:bytearray([23,32,4,67,9,96,123])
Out[12]:bytearray(b'\x17\x04C\t`{')
In[13]:bytearray()
Out[13]:bytearray(b'')
classbytes([source[,encoding[,errors]]])返回一個新的“bytes”對象，它是一個在0<=x<256範圍內的不可變整數序列。
bytes是bytearray的不可變版本–它具有相同的非變異方法和相同的索引和切片行為。
因此，構造函數參數解釋請參考bytearray()。
字節對象也可以使用文字創建。
請參閱字符串和字節文字。
callable(object)如果object參數可調用，則返回True，否則返回False。
如果返回true，調用失敗仍然是可能的，但如果是false，調用object將永遠不會成功。
請注意，類是可調用的（調用一個類返回一個新的實例）;如果類有一個__call__()方法，則實例可以被調用。
3.2版本中的新功能：此功能在Python3.0中首先被刪除，然後在Python3.2中恢復。
In[19]:a=1
In[20]:callable(a)
Out[20]:False
In[21]:deffunc():
...:pass
...:
In[22]:callable(func)
Out[22]:True
In[23]:classA:
...:pass
...:
In[24]:a=A()
In[25]:callable(a)
Out[25]:False
In[26]:classA:
...:def__call__(self,*args,**kwargs):
...:pass
...:
In[27]:a=A()
In[28]:callable(a)
Out[28]:True
chr(i)返回表示Unicode代碼點為整數i的字符的字符串。
例如，chr(97)返回字符串'a'，而chr(8364)返回字符串'€'。
這是ord()的逆過程。
參數的有效範圍是從0到1,114,111（基於16的0x10FFFF）。
如果超出這個範圍，將會拋出ValueError。
@classmethod將方法轉換為類方法。
類方法將類作為第一個參數接收（隱式的），就像實例方法接收實例一樣。
為了聲明一個類方法，習慣用法如下：classC:
@classmethod
deff(cls,arg1,arg2,...):...
!>注意：類方法和靜態方法不是一個概念classcomplex([real[,imag]])返回值為real+imag*1j的複數或者將字符串或數字轉換為複數。
如果第一個參數是一個字符串，它將被解釋為一個複數，並且該函數必須在沒有第二個參數的情況下被調用。
第二個參數不能是一個字符串。
每個參數可以是任何數字類型（包括複數）。
如果省略了imag，它將默認為零，並且構造函數用作像int和float這樣的數字轉換。
如果兩個參數均被省略，則返回0j。
!>從字符串轉換時，該字符串不得在+或-運算符周圍包含空格。
例如，complex('1+2j')很好，但complex('1+2j')會引發ValueError。
delattr(object,name)參數是一個對象和一個字符串。
該字符串必須是對象屬性之一的名稱。
該函數刪除指定的屬性（只要該對象允許）。
例如，delattr(x,'foobar')等價於delx.foobar。
dictclassdict(**kwarg)classdict(mapping,**kwarg)classdict(iterable,**kwarg)創建一個新的字典In[38]:dict(name='jack',age=18)
Out[38]:{'name':'jack','age':18}
In[39]:dict({'name':'jack'},age=18)
Out[39]:{'name':'jack','age':18}
In[40]:dict([('name','jack'),('age',18)])
Out[40]:{'name':'jack','age':18}
dir([object])嘗試返回object的有效屬性列表。
如果沒有參數，則返回當前本地作用域中的名稱列表。
如果對象具有名為__dir__()的方法，則將調用此方法，並且必須返回屬性列表。
這允許實現自定義__getattr__()或__getattribute__()函數的對象自定義dir()報告其屬性。
默認的dir()機制對不同類型的對象有不同的表現，因為它試圖產生最相關的信息，而不是完整的信息：如果對象是模塊對象，則列表包含模塊屬性的名稱。
如果對象是一個類型或類對象，則該列表包含其屬性的名稱，並遞歸地顯示其基礎的屬性。
否則，該列表包含對象的屬性名稱，其類屬性的名稱以及其類的基類的屬性的遞歸。
結果列表按字母順序排序。
例如：>>>importstruct
>>>dir()#showthenamesinthemodulenamespace
['__builtins__','__name__','struct']
>>>dir(struct)#showthenamesinthestructmodule
['Struct','__all__','__builtins__','__cached__','__doc__','__file__',
'__initializing__','__loader__','__name__','__package__',
'_clearcache','calcsize','error','pack','pack_into',
'unpack','unpack_from']
>>>classShape:
...def__dir__(self):
...return['area','perimeter','location']
>>>s=Shape()
>>>dir(s)
['area','location','perimeter']
divmod(a,b)以兩個（非複數）數字作為參數，並在使用整數除法時返回由它們的商和餘數組成的一對數字。
使用混合操作數類型時，適用二元算術運算符的規則。
對於整數，結果與(a//b,a%b)相同。
對於浮點數，結果是(q,a%b)，其中q通常是math.floor(a/b)，但可能小於1。
在任何情況下，q*b+a%b都非常接近a，如果a%b不為零，則它具有與b相同的符號，並且0<=abs(a%b)
iterable可以是序列，支持迭代的容器或迭代器。
如果function為None，則假定標識函數為false，即為false的所有元素都被刪除。
!>請注意，如果function不是None，filter(function,iterable)等價於生成器表達式(itemforiteminiterableiffunction(item))。
如果function是None，等價於生成器表達式(itemforiteminiterableifitem)。
In[8]:list(filter(None,[False,True,0,'test']))
Out[8]:[True,'test']
classfloat([x])返回一個由數字或字符串x構造的浮點數。
在刪除前後空白字符後，輸入必須符合以下語法：sign::="+"|"-"
infinity::="Infinity"|"inf"
nan::="nan"
numeric_value::=floatnumber|infinity|nan
numeric_string::=[sign]numeric_value
對於一般的Python對象x，float(x)委託給x.__float__()。
如果沒有給出參數，則返回0.0。
例子：>>>float('+1.23')
1.23
>>>float('-12345\n')
-12345.0
>>>float('1e-003')
0.001
>>>float('+1E6')
1000000.0
>>>float('-Infinity')
-inf
format(value[,format_spec])將值轉換為“格式化”表示，由format_spec控制。
format_spec的解釋將取決於value參數的類型，不過，大多數內置類型都使用標準格式化語法：格式化規範迷你語言。
默認format_spec是一個空字符串，通常與調用str(value)的效果相同。
對format(value,format_spec)的調用被轉換為type(value).__format__(value,format_spec)，它在搜索value的__format__()方法時繞過實例字典。
如果方法搜索到達object並且format_spec非空，或者format_spec或返回值不是字符串，則會引發TypeError異常。
在version3.4中：如果format_spec不是空字符串，則object().__format__(format_spec)會引發TypeError。
classfrozenset([iterable])返回一個新的frozenset對象，可選地使用來自iterable的元素。
frozenset是一個內置的類。
frozenset是不可變的，存在哈希值，它可以作為字典的key，也可以作為其它集合的元素。
一旦創建便不能更改，沒有add，remove方法。
getattr(object,name[,default])返回object的指定屬性的值。
name必須是字符串。
如果字符串是object屬性之一的名稱，則結果是該屬性的值。
例如，getattr(x,'foobar')等同於x.foobar。
如果指定的屬性不存在，則返回默認值（如果提供），否則引發AttributeError。
globals()返回表示當前全局符號表的字典。
它總是當前模塊的字典（在函數或方法內部，它是定義它的模塊，而不是從中調用它的模塊）。
hasattr(object,name)參數是一個對象和一個字符串。
如果字符串是object屬性之一的名稱，則結果為True，否則為False。
（這是通過調用getattr(object,name)並查看它是否引發AttributeError實現的。
）hash(object)返回對象的散列值（如果有）。
哈希值是整數。
它們用於在字典查找期間快速比較字典鍵。
比較相等的數值具有相同的散列值（即使它們具有不同的類型，就像1和1.0一樣）。
!>對於具有自定義__hash__()方法的對象，請注意，hash()會根據主機的位寬截斷返回值。
In[1]:classA:
...:def__hash__(self):
...:return111111111111111111111111111111111111111
...:
In[2]:a=A()
In[3]:hash(a)
Out[3]:1552656422630569496
In[4]:classA:
...:def__hash__(self):
...:return11111111111
...:
...:
In[5]:a=A()
In[6]:hash(a)
Out[6]:11111111111
help([object])調用內置的幫助系統。
（此功能用於交互式使用。
）如果未提供參數，則交互式幫助系統將在解釋器控制檯上啟動。
如果參數是一個字符串，那麼該字符串將被查找為模塊，函數，類，方法，關鍵字或文檔主題的名稱，並在控制檯上打印幫助頁面。
如果參數是任何其他類型的對象，則會生成對象上的幫助頁面。
hex(x)將整數轉換為以“0x”為前綴的小寫十六進制字符串。
如果x不是Pythonint對象，則必須定義返回整數的__index__()方法。
一些例子：>>>hex(255)
'0xff'
>>>hex(-42)
'-0x2a'
如果要將整數轉換為帶有前綴或不帶前綴的大寫或小寫十六進制字符串，可以使用以下任一方式：>>>'%#x'%255,'%x'%255,'%X'%255
('0xff','ff','FF')
>>>format(255,'#x'),format(255,'x'),format(255,'X')
('0xff','ff','FF')
>>>f'{255:#x}',f'{255:x}',f'{255:X}'
('0xff','ff','FF')
!>要獲取浮點數的十六進制字符串表示形式，請使用float.hex()方法。
id(object)返回一個對象的“identity”。
它是一個整數，它在其生命週期中保證對這個對象唯一且恆定。
具有非重疊生命週期的兩個對象可能具有相同的id()值。
CPython實現細節：這是內存中對象的地址。
input([prompt])如果prompt參數存在，則將其寫入標準輸出而沒有尾隨換行符。
然後該函數從輸入中讀取一行，將其轉換為一個字符串（剝離尾隨的換行符），然後返回該行。
讀取EOF時，引發EOFError。
例：>>>s=input('-->')
-->MontyPython'sFlyingCircus
>>>s
"MontyPython'sFlyingCircus"
intclassint(x=0)classint(x,base=10)返回一個由數字或字符串x構造的整數對象，如果沒有給出參數，則返回0。
如果x不是數字，則返回x.__int__()。
In[22]:classA:
...:def__int__(self):
...:return10
...:
In[23]:a=A()
In[24]:int(a)
Out[24]:10
如果x不是數字或給定了base，那麼x必須是一個string，bytes或bytearray實例，它表示以base為基數的整數文字。
或者，文字可以在前面加上+或-（兩者之間沒有空格）。
In[25]:int('-10')
Out[25]:-10
In[26]:int('+10')
Out[26]:10
In[27]:int('-10')
---------------------------------------------------------------------------
ValueErrorTraceback(mostrecentcalllast)
如果object不是給定類型的對象，則該函數總是返回false。
如果classinfo是類型對象的元組，object是其中任何一個類型的實例，則返回true。
如果classinfo不是類型或一組類型的元組，則會引發TypeError異常。
In[30]:isinstance(10,int)
Out[30]:True
In[31]:isinstance("str",(int,str))
Out[31]:True
In[32]:isinstance(max,int)
Out[32]:False
issubclass(class,classinfo)如果class是classinfo的子類（直接，間接或虛擬），則返回true。
一個類被認為是它自己的一個子類。
classinfo可以是類對象的元組，在這種情況下，將檢查classinfo中的每個條目。
在任何其他情況下，都會引發TypeError異常。
In[34]:issubclass(int,int)
Out[34]:True
In[35]:issubclass(10,int)
---------------------------------------------------------------------------
TypeErrorTraceback(mostrecentcalllast)
根據第二個參數是否存在，第一個參數的解釋有所不同。
如果沒有第二個參數，object必須是支持迭代協議（__iter__()方法）的集合對象，或者它必須支持序列協議（整數參數從0開始的__getitem__()方法）。
如果它不支持這兩種協議，則會引發TypeError。
如果給出了第二個參數sentinel，那麼object必須是可調用的對象。
在這種情況下創建的迭代器將調用沒有參數的object，以便對其__next__()方法進行調用；如果返回的值等於sentinel，則會觸發StopIteration，否則將返回該值。
第二種形式的iter()的一個例子是按行讀取文件，直到到達某一行。
以下示例讀取文件，直到readline()方法返回空字符串：withopen('mydata.txt')asfp:
forlineiniter(fp.readline,''):
process_line(line)
len(s)返回對象的長度（條目數量）。
參數可以是一個序列（如string，bytes，tuple，list或range）或集合（如字典，set或frozenset）。
也可用於實現了__len__()方法的任意對象In[40]:classA:
...:def__len__(self):
...:return10
In[41]:a=A()
In[42]:len(a)
Out[42]:10
classlist([iterable])list不是一個函數，它實際上是一個可變的序列類型。
locals()更新並返回表示當前本地符號表的字典。
在函數塊中調用時，locals()返回自由變量，但不能在類塊中調用。
!>不應該修改其中的內容；更改可能不會影響解釋器使用的本地變量和自由變量的值。
map(function,iterable,…)返回一個將function應用於每個iterableitem的迭代器，從而產生結果。
如果傳遞額外的iterable參數，function必須採用多個參數並應用於並行所有迭代中的項目。
使用多個迭代器時，當最短迭代器耗盡時，迭代器停止。
In[54]:list1=[1,2,3,4,5,6]
...:list2=[4,3,7,1,9]
...:
In[55]:list(map(lambdax,y:x+y,list1,list2))
Out[55]:[5,5,10,5,14]
maxmax(iterable,*[,key,default])max(arg1,arg2,*args[,key])返回iterable中的最大項或兩個或更多個參數中最大的項。
如果提供了一個位置參數，它應該是一個iterable。
iterable中最大的item被返回。
如果提供了兩個或多個位置參數，則返回最大的位置參數。
有兩個可選的關鍵字參數。
key參數指定一個像list.sort()那樣的單參數排序函數。
如果提供的迭代器為空，則default參數指定要返回的對象。
如果迭代器為空且未提供缺省值，則會引發ValueError。
如果最大值包含多個item，則該函數返回遇到的第一個item。
這與sorted(iterable,key=keyfunc,reverse=True)[0]和heapq.nlargest(1,iterable,key=keyfunc)等其他排序工具穩定性保持一致。
In[60]:list1=[4,3,7,1,9]
In[61]:max(list1,key=lambdax:-x)
Out[61]:1
In[62]:max([])
---------------------------------------------------------------------------
ValueErrorTraceback(mostrecentcalllast)
如果提供了一個位置參數，它應該是一個iterable。
iterable中的最小項被返回。
如果提供兩個或多個位置參數，則返回最小的位置參數。
有兩個可選的關鍵字參數。
key參數指定一個像list.sort()那樣的單參數排序函數。
如果提供的迭代器為空，則default參數指定要返回的對象。
如果迭代器為空且未提供缺省值，則會引發ValueError。
如果最小值包含多個item，則該函數返回遇到的第一個item。
這與sorted(iterable,key=keyfunc,reverse=True)[0]和heapq.nlargest(1,iterable,key=keyfunc)等其他排序工具穩定性保持一致。
next(iterator[,default])通過調用__next__()方法從iterator中檢索下一個item。
如果給出了default，則在迭代器耗盡時返回它，否則引發StopIteration。
classobject返回一個新的無特徵的對象。
object是所有類的基類。
它具有所有Python類實例通用的方法。
這個函數不接受任何參數。
!>object沒有__dict__，所以不能為object類的實例指定任意屬性。
oct(x)將整數轉換為以“0o”為前綴的八進制字符串。
結果是一個有效的Python表達式。
如果x不是Pythonint對象，則必須定義返回整數的__index__()方法。
例如：>>>oct(8)
'0o10'
>>>oct(-56)
'-0o70'
如果要將整數轉換為八進制字符串，控制是否顯示前綴“0o”，則可以使用以下任一方式。
>>>'%#o'%10,'%o'%10
('0o12','12')
>>>format(10,'#o'),format(10,'o')
('0o12','12')
>>>f'{10:#o}',f'{10:o}'
('0o12','12')
openopen(file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)打開file並返回相應的文件對象。
如果文件無法打開，則會引發OSError。
file是一個類似路徑的對象，它提供要打開的文件的路徑名（絕對或相對於當前工作目錄）或要包裝的文件的整數文件描述符。
（如果給出文件描述符，則在返回的I/O對象關閉時關閉，除非closefd設置為False。
）mode是一個可選字符串，用於指定打開文件的模式。
它默認為'r'，表示使用文本的方式打開文件來讀取。
其他常見的值是'w'用於寫入（如果文件已經存在，則覆蓋該文件），'x'用於獨佔創建，'a'用於附加（在某些Unix系統上，這意味著無論當前的搜索位置如何，所有寫操作都會附加到文件末尾）。
在文本模式下，如果未指定編碼，則使用的編碼與平臺相關：調用locale.getpreferredencoding(False)以獲取當前語言環境編碼。
（為了讀取和寫入原始字節，使用二進制模式並且不用指定編碼）可用的模式有：字符含義'r'用於讀取（默認）'w'用於寫入，首先覆蓋文件'x'用於獨佔創建，如果文件已經存在則失敗'a'用於寫入，追加到文件末尾（如果存在）'b'二進制模式't'文本模式（默認）'+'打開磁盤文件進行更新（讀取和寫入）'U'通用換行符模式（已棄用）默認模式是'r'（用於讀取文本，'rt'的同義詞）。
對於二進制讀寫訪問，模式'w+b'打開並將文件刪減為0字節。
'r+b'打開文件而不刪減。
如概述中所述，Python區分二進制和文本I/O。
以二進制模式打開的文件（mode參數中包括'b'）將內容作為字節對象返回，而不進行任何解碼。
在文本模式下（默認情況下，或當't'包含在mode參數中時），文件內容以str形式返回，字節首先使用平臺相關編碼進行解碼，或者使用指定的編碼（如果給出）。
!>Python不依賴於底層操作系統的文本文件概念；所有的處理都由Python自己完成，因此是平臺無關的。
ord(c)給定一個代表一個Unicode字符的字符串，返回一個表示該字符的Unicodecode點的整數。
例如，ord('a')返回整數97，ord('€')（歐元符號）返回8364。
這是chr()的逆過程pow(x,y[,z])返回x的y次方；返回x的y次方再除以z的餘數（計算效率比pow(x,y)%z更高）。
雙參數形式pow(x,y)等價於使用冪運算符：x**y。
printprint(*objects,sep='',end='\n',file=sys.stdout,flush=False)將objects打印到文本流file中，以sep分隔，然後以end結尾。
必須將sep，end，file和flush（如果存在）作為關鍵字參數給出。
所有非關鍵字參數都會轉換為像str()那樣的字符串並寫入流中，由sep隔開，然後結束。
sep和end都必須是字符串；它們也可以是None，這意味著使用默認值。
如果沒有給出對象，print()將只寫入end。
文件參數必須是帶有write(string)方法的對象；如果它不存在或是None，則將使用sys.stdout。
由於打印的參數會轉換為文本字符串，print()不能用於二進制模式文件對象。
對於這些，請改用file.write(...)。
輸出是否緩衝通常由file決定，但如果flush關鍵字參數為true，則強制刷新流。
propertyclassproperty(fget=None,fset=None,fdel=None,doc=None)返回一個property屬性。
fget是獲取屬性值的函數。
fset是用於設置屬性值的函數。
fdel是刪除屬性值時會調用的函數。
doc為該屬性創建一個文檔字符串。
典型的用法是定義一個託管屬性x：classC:
def__init__(self):
self._x=None
defgetx(self):
returnself._x
defsetx(self,value):
self._x=value
defdelx(self):
delself._x
x=property(getx,setx,delx,"I'mthe'x'property.")
如果c是C的一個實例，c.x將調用getx，c.x=value將調用setx，delc.x將調用delx。
如果給定，doc將是property屬性的文檔字符串。
否則，該屬性將複製fget的文檔字符串（如果存在）。
這使得使用property()作為裝飾器可以輕鬆創建只讀屬性：classParrot:
def__init__(self):
self._voltage=100000
@property
defvoltage(self):
"""Getthecurrentvoltage."""
returnself._voltage
@property修飾器將voltage()方法轉換為具有相同名稱的只讀屬性的“getter”，並將voltage的文檔字符串設置為“Getthecurrentvoltage.”。
property對象具有可用作裝飾器的getter，setter和deleter方法，這些方法創建屬性的副本並將相應的存取器函數設置為裝飾函數。
這可以用一個例子來解釋：classC:
def__init__(self):
self._x=None
@property
defx(self):
"""I'mthe'x'property."""
returnself._x
@x.setter
defx(self,value):
self._x=value
@x.deleter
defx(self):
delself._x
此代碼與第一個示例完全等效。
請務必為附加函數提供與原始property相同的名稱（當前為x）。
返回的property對象也具有與構造函數參數相對應的屬性fget，fset和fdel。
rangerange(stop)range(start,stop[,step])range不是一個函數，它實際上是一個不可變的序列類型In[8]:list(range(10))
Out[8]:[0,1,2,3,4,5,6,7,8,9]
In[9]:list(range(0,10,2))
Out[9]:[0,2,4,6,8]
repr(object)返回一個包含對象可打印表示的字符串。
對於許多類型，此函數嘗試返回一個字符串，該字符串在傳遞給eval()時會產生一個具有相同值的對象，否則該表示是一個用尖括號括起來的字符串，其中包含對象類型的名稱以及其他信息包括對象的名稱和地址。
一個類可以通過定義__repr__()方法來控制此函數為其實例返回的內容。
reversed(seq)返回一個反向迭代器。
seq必須是具有__reversed__()方法或支持序列協議（__len__()方法和整數參數從0開始的__getitem__()方法）的對象。
round(number[,ndigits])返回在小數點後舍入到精度ndigits的number。
如果ndigits被省略或者是None，它將返回最接近的整數表示。
對於支持round()的內建類型，值舍入到10的最接近的負ndigits次冪的倍數；如果離兩個倍數的距離相等，則舍入選擇偶數（因此，round(0.5)和round(-0.5)都是0，而round(1.5)是2）。
ndigits可以是任何整數值（正數，零或負數）。
如果使用一個參數調用則返回值是一個integer，否則與number的類型相同。
In[10]:type(round(10.9))
Out[10]:int
In[11]:type(round(10.9,2))
Out[11]:float
對於一般的Python對象xxx，round(xxx,ndigits)委託給xxx.__round__(ndigits)。
!>round()對於浮點數的行為可能會令人驚訝：例如，round(2.675,2)給出2.67，而不是預期的2.68。
這不是一個bug：這是由於大多數小數不能完全表示為浮點數的結果。
classset([iterable])返回一個新的集合對象，可選地使用來自iterable的元素。
set是一個內置的類。
setattr(object,name,value)它和getattr()是一對。
參數是一個對象，一個字符串和一個任意值。
該字符串可以是現有的屬性名或新的屬性名。
如果該對象允許，該函數將value分配給該屬性。
例如，setattr(x,'foobar',123)等同於x.foobar=123。
sliceclassslice(stop)classslice(start,stop[,step])返回表示由range(start,stop,step)指定的一組索引的切片對象。
start和step參數默認為None。
切片對象具有隻讀數據屬性start、stop和step，它們只返回參數值（或它們的默認值）。
他們沒有其他明確的功能；然而，它們被NumericalPython和其他第三方擴展使用。
當使用擴展索引語法時，也會生成切片對象。
例如：a[start:stop:step]或a[start:stop,i]。
In[5]:a=[0,1,2,3,4,5,6,7,8,9]
In[6]:s=slice(1,8,2)
In[7]:a[s]
Out[7]:[1,3,5,7]
sortedsorted(iterable,*,key=None,reverse=False)從iterable中的item中返回一個新的排序列表。
有兩個可選參數，必須將其指定為關鍵字參數。
key指定一個帶有一個參數的函數，用於從每個列表元素中提取比較鍵：key=str.lower。
默認值是None（直接比較元素）。
reverse是一個布爾值。
如果設置為True，那麼列表元素按照每個比較被顛倒的順序進行排序。
內置的sorted()函數排序是穩定的。
如果確保不會更改比較相等的元素的相對順序，則排序是穩定的。
@staticmethod將方法轉換為靜態方法。
靜態方法不會收到隱式的第一個參數。
要聲明一個靜態方法，習慣用法如下：classC:
@staticmethod
deff(arg1,arg2,...):...
它可以在類（如C.f()）或實例（如C().f()）上調用。
Python中的靜態方法類似於Java或C++中的。
strclassstr(object='')classstr(object=b'',encoding='utf-8',errors='strict')返回一個字符串對象sum(iterable[,start])從start開始，從左到右對iterable中的元素求和。
start默認是0，迭代的item通常是數字，並且不允許start的值為字符串。
對於有些情況，有比sum()更好的選擇，比如：連接字符串應該用''.join(sequence)。
浮點數求和用math.fsum()。
要連接一系列iterable，請考慮使用itertools.chain()。
super([type[,object-or-type]])返回一個代理對象，它委託方法給父類或者type的同級類。
這對於訪問類中被覆蓋的繼承方法很有用。
搜索順序與getattr()使用的順序相同，只不過type本身被跳過。
type的__mro__屬性列出getattr()和super()使用的方法解析順序。
該屬性是動態的，並且可以在繼承層次結構更新時更改。
如果省略第二個參數，則返回的super對象是未綁定的。
如果第二個參數是一個對象，則isinstance(obj,type)必須為true。
如果第二個參數是類型，則issubclass(type2,type)必須為true（這對類方法很有用）。
super有兩種典型的使用情況。
在具有單繼承的類層次結構中，可以使用super來引用父類，而不必明確命名它們，從而使代碼更易於維護。
這種使用非常類似於在其他編程語言中super的使用。
第二種使用情況是在動態執行環境中支持協同多繼承。
這種使用情況是Python獨有的，在靜態編譯語言或僅支持單繼承的語言中找不到。
這使得可以實現“菱形圖”，其中多個基類實現相同的方法。
良好的設計指出此方法在每種情況下具有相同的調用順序（因為調用的順序在運行時確定，因為該順序適應類層次結構中的更改，並且因為該順序可以包括在運行時之前未知的兄弟類）。
對於這兩種用例，典型的超類調用如下所示：classC(B):
defmethod(self,arg):
super().method(arg)#Thisdoesthesamethingas:
#super(C,self).method(arg)
!>注意，super()只實現顯式點分屬性查找的綁定過程，例如super().__getitem__(name)。
它通過實現自己的__getattribute__()方法來實現這一點，以便以支持協同多繼承需要的以可預測的順序搜索類。
因此，super()沒有定義隱式的查找語句或操作，例如super()[name]。
!>另請注意，除了零參數形式外，super()不限於在方法內部使用。
如果兩個參數的形式指定了準確的參數，就能進行正確的引用。
零參數形式只能在類定義中使用，因為編譯器會填充必要的細節以正確檢索正在定義的類，以及訪問普通方法的當前實例。
tuple([iterable])tuple不是一個函數，它實際上是一個不可變的序列類型typeclasstype(object)classtype(name,bases,dict)有一個參數時，返回object的類型。
返回值是一個類型對象，通常與object.__class__返回的對象相同。
建議使用isinstance()內置函數來測試對象的類型，因為它會考慮子類。
有三個參數時，返回一個新的類型對象。
這實質上是類聲明的一種動態形式。
name字符串是類名，併成為__name__屬性；bases元組逐項列出基類，併成為__bases__屬性；dict是包含類體的定義的命名空間，並被複制到標準字典中以變為__dict__屬性。
例如，以下兩條語句會創建相同的類型對象：>>>classX:
...a=1
...
>>>X=type('X',(object,),dict(a=1))
vars([object])返回一個模塊、字典、類、實例或者其它任何一個具有__dict__屬性的對象的__dict__屬性。
模塊和實例這樣的對象的__dict__屬性可以更新；但是其它對象可能對它們的__dict__屬性的寫操作有限制（例如，類使用types.MappingProxyType來阻止對字典直接更新）。
如果不帶參數，vars()的行為就像locals()。
注意，locals字典只用於讀取，因為對locals字典的更新會被忽略。
zip(*iterables)製作一個迭代器，用於聚合來自每個迭代器的元素。
返回元組的迭代器，其中第i個元組包含來自每個參數序列或迭代的第i個元素。
當最短的輸入迭代耗盡時，迭代器停止。
使用單個迭代參數，它將返回1元組的迭代器。
沒有參數，它返回一個空的迭代器。
相當於：defzip(*iterables):
#zip('ABCD','xy')-->AxBy
sentinel=object()
iterators=[iter(it)foritiniterables]
whileiterators:
result=[]
foritiniterators:
elem=next(it,sentinel)
ifelemissentinel:
return
result.append(elem)
yieldtuple(result)
只有當您不關心後續的，來自較長迭代器的未尾匹配值時，才應該用zip()。
如果這些值很重要，請改用itertools.zip_longest()。
與*操作符一起使用zip()可用於解壓縮列表：>>>x=[1,2,3]
>>>y=[4,5,6]
>>>zipped=zip(x,y)
>>>list(zipped)
[(1,4),(2,5),(3,6)]
>>>x2,y2=zip(*zip(x,y))
>>>x==list(x2)andy==list(y2)
True
相關文章策略程序的一般架構[譯]如何通過7個簡單步驟保護您的Linux服務器Django2.0模型層中QuerySet查詢操作介紹Python之itertools詳解AdvertisementAdvertisement近期文章從Reactrender談談性能優化2020.09.29keepalive實現原理2020.09.29二月前端實戰面試2020.09.29LeetCode每日一題持續更新2020.09.29webpack構建流程及梳理2020.09.29Flutter系列（1）Dart語言介紹2020.09.29招聘[微軟內推]北京上海蘇州無錫大量職位招人，hc多多！！！2020.09.29SuperVuex狀態管理最佳實踐2020.09.29利用dubbo打造真正的nodejs端的微服務體系2020.09.29[譯]Node.jsCLI工具最佳實踐2020.09.29AdvertisementAdvertisement
延伸文章資訊
- 1Python 入門指南- 單元8 - 函數 - 程式語言教學誌
學習進度表～～. 函數(function) 是一種功能性的程式碼集合，可以將程式(program) 分割成小部分，藉由呼叫(call) 函數安排執行順序. def function_name():
- 2Python 内置函数 - 菜鸟教程
- 3在Python 中將函式應用到列表中 - Delft Stack
函式是可以在程式設計中呼叫以執行特定操作的程式碼塊。有許多內建函式以及使用者定義的函式。 列表是Python 中不同元素的集合，有一個共同的名稱。
- 4內建函式— Python 3.10.6 說明文件
在这种情况下，它纯粹是一个便利函数，因此您不必显式导入 pdb 且键入尽可能少的代码即可进入 ... 如果给出的源数据是个字符串，那么其前后的空格和制表符将被剔除。
- 5第3 章Python 的資料
建立python/ch3 目錄， 在其中建立datatype.py 程式檔，輸入以下內容並執行： ... Python 提供型態轉換(Type conversion) 函式：int(), flo...
