Python內建函數大全

微信公衆號： Python數據科學

來源： https://juejin.im/post/5ae3ee...

翻譯總結自官方文檔：https://docs.python.org/3.7/library/functions.html

Python 解釋器內置了許多函數和類型，列表以下（按字母排序）（省略了幾個我沒用過或者不經常使用的）。

abs(x)

返回一個數字的絕對值。參數能夠是整數或浮點數。若是參數是一個複數，則返回它的模。

all(iterable)

若是 iterable 的全部元素均爲 True（或 iterable 爲空），則返回 True。至關於：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any(iterable)

若是 iterable 中有任何一個元素爲 true，則返回 True。若是 iterable 爲空，則返回 False。至關於：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

相似 repr()，返回一個包含對象的可打印表示的字符串，但使用 \x，\u 或 \U 轉義符轉義由 repr() 返回的字符串中的非 ASCII 字符。這會生成一個相似於 Python 2 中 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 不是Python int 對象，則必須定義返回整數的 __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]: class Test:
   ...:     def __init__(self, n):
   ...:         self.n = n
   ...:
   ...:     def __index__(self):
   ...:         return self.n
   ...:

In [2]: t = Test(10)

In [3]: bin(t)
Out[3]: '0b1010'

class bool([x])

返回一個布爾值，即 True 或 False 中的一個。 x 使用標準真值測試方式進行轉換。若是 x 爲 false 或省略，則返回 False; 不然返回 True。 bool 類是 int 的子類。它不能進一步子類化。它惟一的實例是 False 和 True。

class bytearray([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'')

class bytes([source[, encoding[, errors]]])

返回一個新的 「bytes」 對象，它是一個在 0 <= x <256 範圍內的不可變整數序列。bytes 是 bytearray 的不可變版本 - 它具備相同的非變異方法和相同的索引和切片行爲。

所以，構造函數參數解釋請參考 bytearray()。

字節對象也可使用文字建立。請參閱https://docs.python.org/3.7/reference/lexical_analysis.html#strings。

callable(object)

若是 object 參數可調用，則返回 True，不然返回 False。若是返回 true，調用失敗仍然是可能的，但若是是 false，調用 object 將永遠不會成功。請注意，類是可調用的（調用一個類返回一個新的實例）; 若是類有一個 __call __()方法，則實例能夠被調用。

3.2版本中的新功能：此功能在 Python 3.0 中首先被刪除，而後在 Python 3.2 中恢復。

In [19]: a = 1

In [20]: callable(a)
Out[20]: False

In [21]: def func():
    ...:     pass
    ...:

In [22]: callable(func)
Out[22]: True

In [23]: class A:
    ...:     pass
    ...:

In [24]: a = A()

In [25]: callable(a)
Out[25]: False

In [26]: class A:
    ...:     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

將方法轉換爲類方法。

類方法將類做爲第一個參數接收（隱式的），就像實例方法接收實例同樣。爲了聲明一個類方法，習慣用法以下：

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

!> 注意：類方法和靜態方法不是一個概念

class complex([real[, imag]])

返回值爲 real + imag*1j 的複數或者將字符串或數字轉換爲複數。若是第一個參數是一個字符串，它將被解釋爲一個複數，而且該函數必須在沒有第二個參數的狀況下被調用。第二個參數不能是一個字符串。每一個參數能夠是任何數字類型（包括複數）。若是省略了 imag，它將默認爲零，而且構造函數用做像 int 和 float 這樣的數字轉換。若是兩個參數均被省略，則返回 0j。

!> 從字符串轉換時，該字符串不得在 + 或 - 運算符周圍包含空格。例如，complex('1+2j') 很好，但 complex('1 + 2j') 會引起 ValueError。

delattr(object, name)

參數是一個對象和一個字符串。該字符串必須是對象屬性之一的名稱。該函數刪除指定的屬性（只要該對象容許）。例如， delattr(x, 'foobar') 等價於 del x.foobar。

dict

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(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() 機制對不一樣類型的對象有不一樣的表現，由於它試圖產生最相關的信息，而不是完整的信息：

• 若是對象是模塊對象，則列表包含模塊屬性的名稱。
• 若是對象是一個類型或類對象，則該列表包含其屬性的名稱，並遞歸地顯示其基礎的屬性。
• 不然，該列表包含對象的屬性名稱，其類屬性的名稱以及其類的基類的屬性的遞歸。

結果列表按字母順序排序。例如：

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     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) < abs(b)。

In [53]: divmod(10, 3)
Out[53]: (3, 1)

In [54]: divmod(10.1, 3)
Out[54]: (3.0, 1.0999999999999996)

enumerate( iterable, start=0)

返回一個枚舉對象。 iterable 必須是一個序列，一個迭代器或其餘支持迭代的對象。由 enumerate() 返回的迭代器的 __next__() 方法返回一個元組，該元組包含一個計數（從 start 開始，默認值爲 0）以及遍歷迭代得到的值。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

至關於：

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

filter(function, iterable)

用那些 function 返回 true 的 iterable 元素構造一個迭代器。iterable 能夠是序列，支持迭代的容器或迭代器。若是 function 爲 None，則假定標識函數爲 false，即爲 false 的全部元素都被刪除。

!> 請注意，若是 function 不是 None ，filter(function, iterable) 等價於生成器表達式 (item for item in iterable if function(item)) 。若是 function 是 None，等價於生成器表達式 (item for item in iterable if item) 。

In [8]: list(filter(None, [False, True, 0, 'test']))
Out[8]: [True, 'test']

class float([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 參數的類型，不過，大多數內置類型都使用標準格式化語法：格式化規範迷你語言https://docs.python.org/3.7/library/string.html#formatspec。

默認 format_spec 是一個空字符串，一般與調用 str(value) 的效果相同。

對 format(value, format_spec) 的調用被轉換爲 type(value).__format__(value, format_spec)，它在搜索 value 的 __format__() 方法時繞過實例字典。若是方法搜索到達 object 而且 format_spec 非空，或者 format_spec 或返回值不是字符串，則會引起 TypeError 異常。

在 version 3.4 中：若是 format_spec 不是空字符串，則 object().__format__(format_spec) 會引起 TypeError。

class frozenset([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]: class A:
   ...:     def __hash__(self):
   ...:         return 111111111111111111111111111111111111111
   ...:

In [2]: a = A()

In [3]: hash(a)
Out[3]: 1552656422630569496

In [4]: class A:
   ...:     def __hash__(self):
   ...:         return 11111111111
   ...:
   ...:

In [5]: a = A()

In [6]: hash(a)
Out[6]: 11111111111

help([object])

調用內置的幫助系統。 （此功能用於交互式使用。）若是未提供參數，則交互式幫助系統將在解釋器控制檯上啓動。若是參數是一個字符串，那麼該字符串將被查找爲模塊，函數，類，方法，關鍵字或文檔主題的名稱，並在控制檯上打印幫助頁面。若是參數是任何其餘類型的對象，則會生成對象上的幫助頁面。

hex(x)

將整數轉換爲以 「0x」 爲前綴的小寫十六進制字符串。若是 x 不是 Python int 對象，則必須定義返回整數的 __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('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

int

class int(x=0)
class int(x, base=10)

返回一個由數字或字符串 x 構造的整數對象，若是沒有給出參數，則返回 0。若是 x 不是數字，則返回 x.__int__()。

In [22]: class A:
    ...:     def __int__(self):
    ...:         return 10
    ...:

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')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-27-a62cc7794a18> in <module>()
----> 1 int('- 10')

ValueError: invalid literal for int() with base 10: '- 10'

In [28]: int('1000',2)
Out[28]: 8

In [29]: int('ff',16)
Out[29]: 255

isinstance(object, classinfo)

若是 object 參數是 classinfo 參數的實例或其（直接，間接或虛擬）子類的實例，則返回 true。若是 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)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-35-37910f193c07> in <module>()
----> 1 issubclass(10, int)

TypeError: issubclass() arg 1 must be a class

In [36]: issubclass(int, str)
Out[36]: False

iter(object[, sentinel])

返回一個迭代器對象。根據第二個參數是否存在，第一個參數的解釋有所不一樣。若是沒有第二個參數，object 必須是支持迭代協議（__iter__() 方法）的集合對象，或者它必須支持序列協議（整數參數從 0 開始的 __getitem__() 方法）。若是它不支持這兩種協議，則會引起 TypeError。若是給出了第二個參數 sentinel，那麼 object 必須是可調用的對象。在這種狀況下建立的迭代器將調用沒有參數的 object，以便對其 __next__() 方法進行調用；若是返回的值等於 sentinel，則會觸發StopIteration，不然將返回該值。

第二種形式的 iter() 的一個例子是按行讀取文件，直到到達某一行。如下示例讀取文件，直到 readline() 方法返回空字符串：

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

len(s)

返回對象的長度（條目數量）。參數能夠是一個序列（如 string，bytes，tuple，list 或 range）或集合（如字典，set 或 frozenset）。

也可用於實現了__len__() 方法的任意對象

In [40]: class A:
    ...:     def __len__(self):
    ...:         return 10
    
In [41]: a = A()

In [42]: len(a)
Out[42]: 10

class list([iterable])

list 不是一個函數，它其實是一個可變的序列類型。

locals()

更新並返回表示當前本地符號表的字典。在函數塊中調用時，locals() 返回自由變量，但不能在類塊中調用。

!> 不該該修改其中的內容；更改可能不會影響解釋器使用的本地變量和自由變量的值。

map(function, iterable, ...)

返回一個將 function 應用於每一個 iterable item 的迭代器，從而產生結果。若是傳遞額外的 iterable 參數，function 必須採用多個參數並應用於並行全部迭代中的項目。使用多個迭代器時，當最短迭代器耗盡時，迭代器中止。

In [54]: list1 = [1, 2, 3, 4, 5, 6]
    ...: list2 = [4, 3, 7, 1, 9]
    ...:

In [55]: list(map(lambda x, y: x+y, list1, list2))
Out[55]: [5, 5, 10, 5, 14]

max

max(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=lambda x: -x)
Out[61]: 1

In [62]: max([])
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-62-a48d8f8c12de> in <module>()
----> 1 max([])

ValueError: max() arg is an empty sequence

In [63]: max([], default=1)
Out[63]: 1

min

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

返回 iterable 中的最小項或兩個或更多個參數中的最小項。

若是提供了一個位置參數，它應該是一個 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。

class object

返回一個新的無特徵的對象。object 是全部類的基類。它具備全部 Python 類實例通用的方法。這個函數不接受任何參數。

!> object 沒有 __dict__，因此不能爲 object 類的實例指定任意屬性。

oct(x)

將整數轉換爲以 「0o」 爲前綴的八進制字符串。結果是一個有效的 Python 表達式。若是 x 不是 Python int 對象，則必須定義返回整數的 __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')

open

open(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'（用於讀取文本，'rt' 的同義詞）。對於二進制讀寫訪問，模式 'w+b' 打開並將文件刪減爲 0 字節。 'r+b' 打開文件而不刪減。

如概述中所述，Python 區分二進制和文本 I/O。以二進制模式打開的文件（mode參數中包括 'b'）將內容做爲字節對象返回，而不進行任何解碼。在文本模式下（默認狀況下，或當 't' 包含在 mode 參數中時），文件內容以 str 形式返回，字節首先使用平臺相關編碼進行解碼，或者使用指定的編碼（若是給出）。

!> Python 不依賴於底層操做系統的文本文件概念；全部的處理都由 Python 本身完成，所以是平臺無關的。

ord(c)

給定一個表明一個Unicode字符的字符串，返回一個表示該字符的 Unicode code 點的整數。例如，ord('a') 返回整數 97，ord('€')（歐元符號）返回 8364。這是 chr() 的逆過程

pow(x, y[, z])

返回 x 的 y 次方；返回 x 的 y 次方再除以 z 的餘數（計算效率比 pow(x, y) % z 更高）。雙參數形式 pow(x, y) 等價於使用冪運算符：x**y。

print

print(*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，則強制刷新流。

property

class property(fget=None, fset=None, fdel=None, doc=None)

返回一個 property 屬性。

fget 是獲取屬性值的函數。fset 是用於設置屬性值的函數。fdel 是刪除屬性值時會調用的函數。doc 爲該屬性建立一個文檔字符串。

典型的用法是定義一個託管屬性 x：

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

若是 c 是 C 的一個實例，c.x 將調用 getx，c.x = value 將調用 setx ，del c.x 將調用 delx。

若是給定，doc 將是 property 屬性的文檔字符串。不然，該屬性將複製 fget 的文檔字符串（若是存在）。這使得使用 property()做爲裝飾器能夠輕鬆建立只讀屬性：

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property 修飾器將 voltage() 方法轉換爲具備相同名稱的只讀屬性的 「getter」，並將 voltage 的文檔字符串設置爲 「Get the current voltage.」。

property 對象具備可用做裝飾器的 getter，setter 和 deleter 方法，這些方法建立屬性的副本並將相應的存取器函數設置爲裝飾函數。這能夠用一個例子來解釋：

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

此代碼與第一個示例徹底等效。請務必爲附加函數提供與原始 property 相同的名稱（當前爲 x）。

返回的 property 對象也具備與構造函數參數相對應的屬性 fget，fset 和 fdel。

range

range(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：這是因爲大多數小數不能徹底表示爲浮點數的結果。

class set([iterable])

返回一個新的集合對象，可選地使用來自 iterable 的元素。 set 是一個內置的類。

setattr(object, name, value)

它和 getattr() 是一對。參數是一個對象，一個字符串和一個任意值。該字符串能夠是現有的屬性名或新的屬性名。若是該對象容許，該函數將 value 分配給該屬性。例如，setattr(x, 'foobar', 123) 等同於 x.foobar = 123。

slice

class slice(stop)
class slice(start, stop[, step])

返回表示由 range(start, stop, step) 指定的一組索引的切片對象。start 和 step 參數默認爲 None。切片對象具備只讀數據屬性 start、stop 和 step，它們只返回參數值（或它們的默認值）。他們沒有其餘明確的功能；然而，它們被 Numerical Python 和其餘第三方擴展使用。當使用擴展索引語法時，也會生成切片對象。例如：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]

sorted

sorted(iterable, *, key=None, reverse=False)

從 iterable 中的 item 中返回一個新的排序列表。

有兩個可選參數，必須將其指定爲關鍵字參數。

key 指定一個帶有一個參數的函數，用於從每一個列表元素中提取比較鍵：key=str.lower。默認值是 None（直接比較元素）。

reverse 是一個布爾值。若是設置爲 True，那麼列表元素按照每一個比較被顛倒的順序進行排序。

內置的 sorted() 函數排序是穩定的。若是確保不會更改比較相等的元素的相對順序，則排序是穩定的 。

@staticmethod

將方法轉換爲靜態方法。

靜態方法不會收到隱式的第一個參數。要聲明一個靜態方法，習慣用法以下：

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

它能夠在類（如 C.f()）或實例（如 C().f()）上調用。

Python 中的靜態方法相似於 Java 或 C++ 中的。

str

class str(object='')
class str(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 獨有的，在靜態編譯語言或僅支持單繼承的語言中找不到。這使得能夠實現 「菱形圖」，其中多個基類實現相同的方法。良好的設計指出此方法在每種狀況下具備相同的調用順序（由於調用的順序在運行時肯定，由於該順序適應類層次結構中的更改，而且由於該順序能夠包括在運行時以前未知的兄弟類）。

對於這兩種用例，典型的超類調用以下所示：

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

!> 注意，super() 只實現顯式點分屬性查找的綁定過程，例如 super().__getitem__(name)。它經過實現本身的 __getattribute__() 方法來實現這一點，以便以支持協同多繼承須要的以可預測的順序搜索類。所以，super() 沒有定義隱式的查找語句或操做，例如 super()[name]。

!> 另請注意，除了零參數形式外，super() 不限於在方法內部使用。若是兩個參數的形式指定了準確的參數，就能進行正確的引用。零參數形式只能在類定義中使用，由於編譯器會填充必要的細節以正確檢索正在定義的類，以及訪問普通方法的當前實例。

tuple([iterable])

tuple 不是一個函數，它其實是一個不可變的序列類型

type

class type(object)
class type(name, bases, dict)

有一個參數時，返回 object 的類型。返回值是一個類型對象，一般與 object.__class__ 返回的對象相同。

建議使用 isinstance() 內置函數來測試對象的類型，由於它會考慮子類。

有三個參數時，返回一個新的類型對象。這實質上是類聲明的一種動態形式。name 字符串是類名，併成爲 __name__ 屬性；bases 元組逐項列出基類，併成爲 __bases__ 屬性；dict 是包含類體的定義的命名空間，並被複制到標準字典中以變爲 __dict__ 屬性。例如，如下兩條語句會建立相同的類型對象：

>>> class X:
...     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 元組的迭代器。沒有參數，它返回一個空的迭代器。至關於：

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(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) and y == list(y2)
True

關注微信公衆號 Python數據科學，帶你走進數據的世界。