摘要：類是一個(gè)在范圍內(nèi)的可變整數(shù)序列。因此，構(gòu)造函數(shù)參數(shù)解釋請(qǐng)參考。如果省略了，它將默認(rèn)為零，并且構(gòu)造函數(shù)用作像和這樣的數(shù)字轉(zhuǎn)換。該函數(shù)刪除指定的屬性只要該對(duì)象允許。返回表示當(dāng)前全局符號(hào)表的字典。將整數(shù)轉(zhuǎn)換為以為前綴的小寫十六進(jìn)制字符串。

微信公眾號(hào)： Python數(shù)據(jù)科學(xué)

來(lái)源：https://juejin.im/post/5ae3ee...
翻譯總結(jié)自官方文檔：https://docs.python.org/3.7/library/functions.html

Python 解釋器內(nèi)置了許多函數(shù)和類型，列表如下（按字母排序）（省略了幾個(gè)我沒用過(guò)或者不常用的）。

返回一個(gè)數(shù)字的絕對(duì)值。參數(shù)可以是整數(shù)或浮點(diǎn)數(shù)。如果參數(shù)是一個(gè)復(fù)數(shù)，則返回它的模。

如果 iterable 的所有元素均為 True（或 iterable 為空），則返回 True。相當(dāng)于：

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

如果 iterable 中有任何一個(gè)元素為 true，則返回 True。如果 iterable 為空，則返回 False。相當(dāng)于：

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

類似 repr()，返回一個(gè)包含對(duì)象的可打印表示的字符串，但使用 x，u 或 U 轉(zhuǎn)義符轉(zhuǎn)義由 repr() 返回的字符串中的非 ASCII 字符。這會(huì)生成一個(gè)類似于 Python 2 中 repr() 返回的字符串。

In [1]: s = "python 
 中文"

In [2]: ascii(s)
Out[2]: ""python 
 u4e2du6587""

In [3]: repr(s)
Out[3]: ""python 
 中文""

將整數(shù)轉(zhuǎn)換為以 “0b” 為前綴的二進(jìn)制字符串。結(jié)果是一個(gè)有效的 Python 表達(dá)式。如果 x 不是Python int 對(duì)象，則必須定義返回整數(shù)的 __index __() 方法。一些例子：

>>> bin(3)
"0b11"
>>> bin(-10)
"-0b1010"

可以使用以下任意方式，控制是否需要前綴 “0b”：

>>> format(14, "#b"), format(14, "b")
("0b1110", "1110")
>>> f"{14:#b}", f"{14:b}"
("0b1110", "1110")

有關(guān)更多信息，另請(qǐng)參閱 format()。

當(dāng) x 不是 int 類型時(shí)

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"

返回一個(gè)布爾值，即 True 或 False 中的一個(gè)。 x 使用標(biāo)準(zhǔn)真值測(cè)試方式進(jìn)行轉(zhuǎn)換。如果 x 為 false 或省略，則返回 False; 否則返回 True。 bool 類是 int 的子類。它不能進(jìn)一步子類化。它唯一的實(shí)例是 False 和 True。

返回一個(gè)新的字節(jié)數(shù)組。 bytearray 類是一個(gè)在 0 <= x < 256 范圍內(nèi)的可變整數(shù)序列。

可選的 source 參數(shù)可以用幾種不同的方式初始化數(shù)組：

如果它是一個(gè)字符串，則還必須給出 encoding（以及可選的 errors）參數(shù); 然后 bytearray() 使用 str.encode() 將字符串轉(zhuǎn)換為字節(jié)。

如果它是一個(gè)整數(shù)，則將其作為數(shù)組的長(zhǎng)度，并將用空字節(jié)進(jìn)行初始化。

如果它是符合緩沖區(qū)接口的對(duì)象，則將使用該對(duì)象的只讀緩沖區(qū)來(lái)初始化字節(jié)數(shù)組。

如果它是一個(gè) iterable，必須是 0 <= x <256 范圍內(nèi)的可迭代對(duì)象，它們將被用作數(shù)組的初始內(nèi)容。

沒有參數(shù)，就會(huì)創(chuàng)建一個(gè)大小為 0 的數(shù)組。

In [11]: bytearray(5)
Out[11]: bytearray(b"x00x00x00x00x00")

In [12]: bytearray([23, 32, 4, 67, 9, 96, 123])
Out[12]: bytearray(b"x17 x04C	`{")

In [13]: bytearray()
Out[13]: bytearray(b"")

返回一個(gè)新的 “bytes” 對(duì)象，它是一個(gè)在 0 <= x <256 范圍內(nèi)的不可變整數(shù)序列。bytes 是 bytearray 的不可變版本 - 它具有相同的非變異方法和相同的索引和切片行為。

因此，構(gòu)造函數(shù)參數(shù)解釋請(qǐng)參考 bytearray()。

字節(jié)對(duì)象也可以使用文字創(chuàng)建。請(qǐng)參閱https://docs.python.org/3.7/reference/lexical_analysis.html#strings。

如果 object 參數(shù)可調(diào)用，則返回 True，否則返回 False。如果返回 true，調(diào)用失敗仍然是可能的，但如果是 false，調(diào)用 object 將永遠(yuǎn)不會(huì)成功。請(qǐng)注意，類是可調(diào)用的（調(diào)用一個(gè)類返回一個(gè)新的實(shí)例）; 如果類有一個(gè) __call __()方法，則實(shí)例可以被調(diào)用。

3.2版本中的新功能：此功能在 Python 3.0 中首先被刪除，然后在 Python 3.2 中恢復(fù)。

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

返回表示 Unicode 代碼點(diǎn)為整數(shù) i 的字符的字符串。例如，chr(97) 返回字符串 "a"，而 chr(8364) 返回字符串 "€"。這是 ord() 的逆過(guò)程。

參數(shù)的有效范圍是從 0 到 1,114,111（基于 16 的 0x10FFFF）。如果超出這個(gè)范圍，將會(huì)拋出 ValueError。

將方法轉(zhuǎn)換為類方法。

類方法將類作為第一個(gè)參數(shù)接收（隱式的），就像實(shí)例方法接收實(shí)例一樣。為了聲明一個(gè)類方法，習(xí)慣用法如下：

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

!> 注意：類方法和靜態(tài)方法不是一個(gè)概念

返回值為 real + imag*1j 的復(fù)數(shù)或者將字符串或數(shù)字轉(zhuǎn)換為復(fù)數(shù)。如果第一個(gè)參數(shù)是一個(gè)字符串，它將被解釋為一個(gè)復(fù)數(shù)，并且該函數(shù)必須在沒有第二個(gè)參數(shù)的情況下被調(diào)用。第二個(gè)參數(shù)不能是一個(gè)字符串。每個(gè)參數(shù)可以是任何數(shù)字類型（包括復(fù)數(shù)）。如果省略了 imag，它將默認(rèn)為零，并且構(gòu)造函數(shù)用作像 int 和 float 這樣的數(shù)字轉(zhuǎn)換。如果兩個(gè)參數(shù)均被省略，則返回 0j。

!> 從字符串轉(zhuǎn)換時(shí)，該字符串不得在 + 或 - 運(yùn)算符周圍包含空格。例如，complex("1+2j") 很好，但 complex("1 + 2j") 會(huì)引發(fā) ValueError。

參數(shù)是一個(gè)對(duì)象和一個(gè)字符串。該字符串必須是對(duì)象屬性之一的名稱。該函數(shù)刪除指定的屬性（只要該對(duì)象允許）。例如， delattr(x, "foobar") 等價(jià)于 del x.foobar。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

創(chuàng)建一個(gè)新的字典

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}

嘗試返回 object 的有效屬性列表。如果沒有參數(shù)，則返回當(dāng)前本地作用域中的名稱列表。

如果對(duì)象具有名為 __dir__() 的方法，則將調(diào)用此方法，并且必須返回屬性列表。這允許實(shí)現(xiàn)自定義 __getattr__()或 __getattribute__() 函數(shù)的對(duì)象自定義 dir() 報(bào)告其屬性。

默認(rèn)的 dir() 機(jī)制對(duì)不同類型的對(duì)象有不同的表現(xiàn)，因?yàn)樗噲D產(chǎn)生最相關(guān)的信息，而不是完整的信息：

如果對(duì)象是模塊對(duì)象，則列表包含模塊屬性的名稱。

如果對(duì)象是一個(gè)類型或類對(duì)象，則該列表包含其屬性的名稱，并遞歸地顯示其基礎(chǔ)的屬性。

否則，該列表包含對(duì)象的屬性名稱，其類屬性的名稱以及其類的基類的屬性的遞歸。

結(jié)果列表按字母順序排序。例如：

>>> 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"]

以兩個(gè)（非復(fù)數(shù)）數(shù)字作為參數(shù)，并在使用整數(shù)除法時(shí)返回由它們的商和余數(shù)組成的一對(duì)數(shù)字。使用混合操作數(shù)類型時(shí)，適用二元算術(shù)運(yùn)算符的規(guī)則。對(duì)于整數(shù)，結(jié)果與 (a // b, a % b) 相同。對(duì)于浮點(diǎn)數(shù)，結(jié)果是 (q, a % b)，其中 q 通常是 math.floor(a / b)，但可能小于 1。在任何情況下， q * b + a % b 都非常接近 a，如果 a % b 不為零，則它具有與 b 相同的符號(hào)，并且 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)

返回一個(gè)枚舉對(duì)象。 iterable 必須是一個(gè)序列，一個(gè)迭代器或其他支持迭代的對(duì)象。由 enumerate() 返回的迭代器的 __next__() 方法返回一個(gè)元組，該元組包含一個(gè)計(jì)數(shù)（從 start 開始，默認(rèn)值為 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")]

相當(dāng)于：

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

用那些 function 返回 true 的 iterable 元素構(gòu)造一個(gè)迭代器。iterable 可以是序列，支持迭代的容器或迭代器。如果 function 為 None，則假定標(biāo)識(shí)函數(shù)為 false，即為 false 的所有元素都被刪除。

!> 請(qǐng)注意，如果 function 不是 None ，filter(function, iterable) 等價(jià)于生成器表達(dá)式 (item for item in iterable if function(item)) 。如果 function 是 None，等價(jià)于生成器表達(dá)式 (item for item in iterable if item) 。

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

返回一個(gè)由數(shù)字或字符串 x 構(gòu)造的浮點(diǎn)數(shù)。

在刪除前后空白字符后，輸入必須符合以下語(yǔ)法：

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

對(duì)于一般的 Python 對(duì)象 x，float(x) 委托給 x .__float__()。

如果沒有給出參數(shù)，則返回 0.0。

例子：

>>> float("+1.23")
1.23
>>> float("   -12345
")
-12345.0
>>> float("1e-003")
0.001
>>> float("+1E6")
1000000.0
>>> float("-Infinity")
-inf

將值轉(zhuǎn)換為 “格式化” 表示，由 format_spec 控制。 format_spec 的解釋將取決于 value 參數(shù)的類型，不過(guò)，大多數(shù)內(nèi)置類型都使用標(biāo)準(zhǔn)格式化語(yǔ)法：格式化規(guī)范迷你語(yǔ)言https://docs.python.org/3.7/library/string.html#formatspec。

默認(rèn) format_spec 是一個(gè)空字符串，通常與調(diào)用 str(value) 的效果相同。

對(duì) format(value, format_spec) 的調(diào)用被轉(zhuǎn)換為 type(value).__format__(value, format_spec)，它在搜索 value 的 __format__() 方法時(shí)繞過(guò)實(shí)例字典。如果方法搜索到達(dá) object 并且 format_spec 非空，或者 format_spec 或返回值不是字符串，則會(huì)引發(fā) TypeError 異常。

在 version 3.4 中：如果 format_spec 不是空字符串，則 object().__format__(format_spec) 會(huì)引發(fā) TypeError。

返回一個(gè)新的 frozenset 對(duì)象，可選地使用來(lái)自 iterable 的元素。 frozenset 是一個(gè)內(nèi)置的類。

frozenset 是不可變的，存在哈希值，它可以作為字典的 key，也可以作為其它集合的元素。一旦創(chuàng)建便不能更改，沒有 add，remove 方法。

返回 object 的指定屬性的值。name 必須是字符串。如果字符串是 object 屬性之一的名稱，則結(jié)果是該屬性的值。例如，getattr(x, "foobar") 等同于 x.foobar。如果指定的屬性不存在，則返回默認(rèn)值（如果提供），否則引發(fā) AttributeError。

返回表示當(dāng)前全局符號(hào)表的字典。它總是當(dāng)前模塊的字典（在函數(shù)或方法內(nèi)部，它是定義它的模塊，而不是從中調(diào)用它的模塊）。

參數(shù)是一個(gè)對(duì)象和一個(gè)字符串。如果字符串是 object 屬性之一的名稱，則結(jié)果為 True，否則為 False。（這是通過(guò)調(diào)用 getattr(object, name) 并查看它是否引發(fā) AttributeError 實(shí)現(xiàn)的。）

hash(object)
返回對(duì)象的散列值（如果有）。哈希值是整數(shù)。它們用于在字典查找期間快速比較字典鍵。比較相等的數(shù)值具有相同的散列值（即使它們具有不同的類型，就像 1 和 1.0 一樣）。

!> 對(duì)于具有自定義 __hash__() 方法的對(duì)象，請(qǐng)注意，hash() 會(huì)根據(jù)主機(jī)的位寬截?cái)喾祷刂怠?/p>

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

調(diào)用內(nèi)置的幫助系統(tǒng)。 （此功能用于交互式使用。）如果未提供參數(shù)，則交互式幫助系統(tǒng)將在解釋器控制臺(tái)上啟動(dòng)。如果參數(shù)是一個(gè)字符串，那么該字符串將被查找為模塊，函數(shù)，類，方法，關(guān)鍵字或文檔主題的名稱，并在控制臺(tái)上打印幫助頁(yè)面。如果參數(shù)是任何其他類型的對(duì)象，則會(huì)生成對(duì)象上的幫助頁(yè)面。

將整數(shù)轉(zhuǎn)換為以 “0x” 為前綴的小寫十六進(jìn)制字符串。如果 x 不是 Python int 對(duì)象，則必須定義返回整數(shù)的 __index __() 方法。一些例子：

>>> hex(255)
"0xff"
>>> hex(-42)
"-0x2a"

如果要將整數(shù)轉(zhuǎn)換為帶有前綴或不帶前綴的大寫或小寫十六進(jìn)制字符串，可以使用以下任一方式：

>>> "%#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")

!> 要獲取浮點(diǎn)數(shù)的十六進(jìn)制字符串表示形式，請(qǐng)使用 float.hex() 方法。

返回一個(gè)對(duì)象的 “identity”。它是一個(gè)整數(shù)，它在其生命周期中保證對(duì)這個(gè)對(duì)象唯一且恒定。具有非重疊生命周期的兩個(gè)對(duì)象可能具有相同的 id() 值。

CPython 實(shí)現(xiàn)細(xì)節(jié)：這是內(nèi)存中對(duì)象的地址。

如果 prompt 參數(shù)存在，則將其寫入標(biāo)準(zhǔn)輸出而沒有尾隨換行符。然后該函數(shù)從輸入中讀取一行，將其轉(zhuǎn)換為一個(gè)字符串（剝離尾隨的換行符），然后返回該行。讀取 EOF 時(shí)，引發(fā) EOFError。例：

>>> s = input("--> ")  
--> Monty Python"s Flying Circus
>>> s  
"Monty Python"s Flying Circus"

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

返回一個(gè)由數(shù)字或字符串 x 構(gòu)造的整數(shù)對(duì)象，如果沒有給出參數(shù)，則返回 0。如果 x 不是數(shù)字，則返回 x.__int__()。

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

In [23]: a = A()

In [24]: int(a)
Out[24]: 10

如果 x 不是數(shù)字或給定了 base，那么 x 必須是一個(gè) string， bytes 或 bytearray 實(shí)例，它表示以 base 為基數(shù)的整數(shù)文字。或者，文字可以在前面加上 +或 - （兩者之間沒有空格）。

In [25]: int("-10")
Out[25]: -10

In [26]: int("+10")
Out[26]: 10

In [27]: int("- 10")
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 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

如果 object 參數(shù)是 classinfo 參數(shù)的實(shí)例或其（直接，間接或虛擬）子類的實(shí)例，則返回 true。如果 object 不是給定類型的對(duì)象，則該函數(shù)總是返回 false。如果 classinfo 是類型對(duì)象的元組， object 是其中任何一個(gè)類型的實(shí)例，則返回 true。如果 classinfo 不是類型或一組類型的元組，則會(huì)引發(fā) 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

如果 class 是 classinfo 的子類（直接，間接或虛擬），則返回 true。一個(gè)類被認(rèn)為是它自己的一個(gè)子類。 classinfo 可以是類對(duì)象的元組，在這種情況下，將檢查 classinfo 中的每個(gè)條目。在任何其他情況下，都會(huì)引發(fā) TypeError 異常。

In [34]: issubclass(int, int)
Out[34]: True

In [35]: issubclass(10, int)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 issubclass(10, int)

TypeError: issubclass() arg 1 must be a class

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

返回一個(gè)迭代器對(duì)象。根據(jù)第二個(gè)參數(shù)是否存在，第一個(gè)參數(shù)的解釋有所不同。如果沒有第二個(gè)參數(shù)，object 必須是支持迭代協(xié)議（__iter__() 方法）的集合對(duì)象，或者它必須支持序列協(xié)議（整數(shù)參數(shù)從 0 開始的 __getitem__() 方法）。如果它不支持這兩種協(xié)議，則會(huì)引發(fā) TypeError。如果給出了第二個(gè)參數(shù) sentinel，那么 object 必須是可調(diào)用的對(duì)象。在這種情況下創(chuàng)建的迭代器將調(diào)用沒有參數(shù)的 object，以便對(duì)其 __next__() 方法進(jìn)行調(diào)用；如果返回的值等于 sentinel，則會(huì)觸發(fā)StopIteration，否則將返回該值。

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

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

返回對(duì)象的長(zhǎng)度（條目數(shù)量）。參數(shù)可以是一個(gè)序列（如 string，bytes，tuple，list 或 range）或集合（如字典，set 或 frozenset）。

也可用于實(shí)現(xiàn)了__len__() 方法的任意對(duì)象

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

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

list 不是一個(gè)函數(shù)，它實(shí)際上是一個(gè)可變的序列類型。

更新并返回表示當(dāng)前本地符號(hào)表的字典。在函數(shù)塊中調(diào)用時(shí)，locals() 返回自由變量，但不能在類塊中調(diào)用。

!> 不應(yīng)該修改其中的內(nèi)容；更改可能不會(huì)影響解釋器使用的本地變量和自由變量的值。

返回一個(gè)將 function 應(yīng)用于每個(gè) iterable item 的迭代器，從而產(chǎn)生結(jié)果。如果傳遞額外的 iterable 參數(shù)，function 必須采用多個(gè)參數(shù)并應(yīng)用于并行所有迭代中的項(xiàng)目。使用多個(gè)迭代器時(shí)，當(dāng)最短迭代器耗盡時(shí)，迭代器停止。

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(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

返回 iterable 中的最大項(xiàng)或兩個(gè)或更多個(gè)參數(shù)中最大的項(xiàng)。

如果提供了一個(gè)位置參數(shù)，它應(yīng)該是一個(gè) iterable。iterable 中最大的 item 被返回。如果提供了兩個(gè)或多個(gè)位置參數(shù)，則返回最大的位置參數(shù)。

有兩個(gè)可選的關(guān)鍵字參數(shù)。 key 參數(shù)指定一個(gè)像 list.sort() 那樣的單參數(shù)排序函數(shù)。如果提供的迭代器為空，則 default 參數(shù)指定要返回的對(duì)象。如果迭代器為空且未提供缺省值，則會(huì)引發(fā) ValueError。

如果最大值包含多個(gè) item，則該函數(shù)返回遇到的第一個(gè) item。這與 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 等其他排序工具穩(wěn)定性保持一致。

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)
 in ()
----> 1 max([])

ValueError: max() arg is an empty sequence

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

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

返回 iterable 中的最小項(xiàng)或兩個(gè)或更多個(gè)參數(shù)中的最小項(xiàng)。

如果提供了一個(gè)位置參數(shù)，它應(yīng)該是一個(gè) iterable。iterable 中的最小項(xiàng)被返回。如果提供兩個(gè)或多個(gè)位置參數(shù)，則返回最小的位置參數(shù)。

有兩個(gè)可選的關(guān)鍵字參數(shù)。 key 參數(shù)指定一個(gè)像 list.sort() 那樣的單參數(shù)排序函數(shù)。如果提供的迭代器為空，則 default 參數(shù)指定要返回的對(duì)象。如果迭代器為空且未提供缺省值，則會(huì)引發(fā) ValueError。

如果最小值包含多個(gè) item，則該函數(shù)返回遇到的第一個(gè) item。這與 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 等其他排序工具穩(wěn)定性保持一致。

通過(guò)調(diào)用 __next__() 方法從 iterator 中檢索下一個(gè) item。如果給出了 default，則在迭代器耗盡時(shí)返回它，否則引發(fā) StopIteration。

返回一個(gè)新的無(wú)特征的對(duì)象。object 是所有類的基類。它具有所有 Python 類實(shí)例通用的方法。這個(gè)函數(shù)不接受任何參數(shù)。

!> object 沒有 __dict__，所以不能為 object 類的實(shí)例指定任意屬性。

將整數(shù)轉(zhuǎn)換為以 “0o” 為前綴的八進(jìn)制字符串。結(jié)果是一個(gè)有效的 Python 表達(dá)式。如果 x 不是 Python int 對(duì)象，則必須定義返回整數(shù)的 __index__() 方法。例如：

>>> oct(8)
"0o10"
>>> oct(-56)
"-0o70"

如果要將整數(shù)轉(zhuǎn)換為八進(jìn)制字符串，控制是否顯示前綴 “0o”，則可以使用以下任一方式。

>>> "%#o" % 10, "%o" % 10
("0o12", "12")
>>> format(10, "#o"), format(10, "o")
("0o12", "12")
>>> f"{10:#o}", f"{10:o}"
("0o12", "12")

open(file, mode="r", buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打開 file 并返回相應(yīng)的文件對(duì)象。如果文件無(wú)法打開，則會(huì)引發(fā) OSError。

file 是一個(gè)類似路徑的對(duì)象，它提供要打開的文件的路徑名（絕對(duì)或相對(duì)于當(dāng)前工作目錄）或要包裝的文件的整數(shù)文件描述符。 （如果給出文件描述符，則在返回的 I/O 對(duì)象關(guān)閉時(shí)關(guān)閉，除非 closefd 設(shè)置為 False。）

mode 是一個(gè)可選字符串，用于指定打開文件的模式。它默認(rèn)為 "r"，表示使用文本的方式打開文件來(lái)讀取。其他常見的值是 "w" 用于寫入（如果文件已經(jīng)存在，則覆蓋該文件），"x" 用于獨(dú)占創(chuàng)建，"a" 用于附加（在某些 Unix 系統(tǒng)上，這意味著無(wú)論當(dāng)前的搜索位置如何，所有寫操作都會(huì)附加到文件末尾）。在文本模式下，如果未指定編碼，則使用的編碼與平臺(tái)相關(guān)：調(diào)用 locale.getpreferredencoding(False) 以獲取當(dāng)前語(yǔ)言環(huán)境編碼。（為了讀取和寫入原始字節(jié)，使用二進(jìn)制模式并且不用指定編碼）可用的模式有：

默認(rèn)模式是 "r"（用于讀取文本，"rt" 的同義詞）。對(duì)于二進(jìn)制讀寫訪問(wèn)，模式 "w+b" 打開并將文件刪減為 0 字節(jié)。 "r+b" 打開文件而不刪減。

如概述中所述，Python 區(qū)分二進(jìn)制和文本 I/O。以二進(jìn)制模式打開的文件（mode參數(shù)中包括 "b"）將內(nèi)容作為字節(jié)對(duì)象返回，而不進(jìn)行任何解碼。在文本模式下（默認(rèn)情況下，或當(dāng) "t" 包含在 mode 參數(shù)中時(shí)），文件內(nèi)容以 str 形式返回，字節(jié)首先使用平臺(tái)相關(guān)編碼進(jìn)行解碼，或者使用指定的編碼（如果給出）。

!> Python 不依賴于底層操作系統(tǒng)的文本文件概念；所有的處理都由 Python 自己完成，因此是平臺(tái)無(wú)關(guān)的。

給定一個(gè)代表一個(gè)Unicode字符的字符串，返回一個(gè)表示該字符的 Unicode code 點(diǎn)的整數(shù)。例如，ord("a") 返回整數(shù) 97，ord("€")（歐元符號(hào)）返回 8364。這是 chr() 的逆過(guò)程

返回 x 的 y 次方；返回 x 的 y 次方再除以 z 的余數(shù)（計(jì)算效率比 pow(x, y) % z 更高）。雙參數(shù)形式 pow(x, y) 等價(jià)于使用冪運(yùn)算符：x**y。

print(*objects, sep=" ", end=" ", file=sys.stdout, flush=False)

將 objects 打印到文本流 file 中，以 sep 分隔，然后以 end 結(jié)尾。必須將 sep，end，file 和 flush（如果存在）作為關(guān)鍵字參數(shù)給出。

所有非關(guān)鍵字參數(shù)都會(huì)轉(zhuǎn)換為像 str() 那樣的字符串并寫入流中，由 sep 隔開，然后結(jié)束。sep 和 end 都必須是字符串；它們也可以是 None，這意味著使用默認(rèn)值。如果沒有給出對(duì)象，print() 將只寫入 end。

文件參數(shù)必須是帶有 write(string) 方法的對(duì)象；如果它不存在或是 None，則將使用 sys.stdout。由于打印的參數(shù)會(huì)轉(zhuǎn)換為文本字符串，print() 不能用于二進(jìn)制模式文件對(duì)象。對(duì)于這些，請(qǐng)改用 file.write(...)。

輸出是否緩沖通常由 file 決定，但如果 flush 關(guān)鍵字參數(shù)為 true，則強(qiáng)制刷新流。

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

返回一個(gè) property 屬性。

fget 是獲取屬性值的函數(shù)。fset 是用于設(shè)置屬性值的函數(shù)。fdel 是刪除屬性值時(shí)會(huì)調(diào)用的函數(shù)。doc 為該屬性創(chuàng)建一個(gè)文檔字符串。

典型的用法是定義一個(gè)托管屬性 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 的一個(gè)實(shí)例，c.x 將調(diào)用 getx，c.x = value 將調(diào)用 setx ，del c.x 將調(diào)用 delx。

如果給定，doc 將是 property 屬性的文檔字符串。否則，該屬性將復(fù)制 fget 的文檔字符串（如果存在）。這使得使用 property()作為裝飾器可以輕松創(chuàng)建只讀屬性：

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

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

@property 修飾器將 voltage() 方法轉(zhuǎn)換為具有相同名稱的只讀屬性的 “getter”，并將 voltage 的文檔字符串設(shè)置為 “Get the current voltage.”。

property 對(duì)象具有可用作裝飾器的 getter，setter 和 deleter 方法，這些方法創(chuàng)建屬性的副本并將相應(yīng)的存取器函數(shù)設(shè)置為裝飾函數(shù)。這可以用一個(gè)例子來(lái)解釋：

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

此代碼與第一個(gè)示例完全等效。請(qǐng)務(wù)必為附加函數(shù)提供與原始 property 相同的名稱（當(dāng)前為 x）。

返回的 property 對(duì)象也具有與構(gòu)造函數(shù)參數(shù)相對(duì)應(yīng)的屬性 fget，fset 和 fdel。

range(stop)
range(start, stop[, step])

range 不是一個(gè)函數(shù)，它實(shí)際上是一個(gè)不可變的序列類型

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]

返回一個(gè)包含對(duì)象可打印表示的字符串。對(duì)于許多類型，此函數(shù)嘗試返回一個(gè)字符串，該字符串在傳遞給 eval() 時(shí)會(huì)產(chǎn)生一個(gè)具有相同值的對(duì)象，否則該表示是一個(gè)用尖括號(hào)括起來(lái)的字符串，其中包含對(duì)象類型的名稱以及其他信息包括對(duì)象的名稱和地址。一個(gè)類可以通過(guò)定義 __repr__() 方法來(lái)控制此函數(shù)為其實(shí)例返回的內(nèi)容。

返回一個(gè)反向迭代器。seq 必須是具有 __reversed__() 方法或支持序列協(xié)議（ __len__() 方法和整數(shù)參數(shù)從 0 開始的 __getitem__() 方法）的對(duì)象。

返回在小數(shù)點(diǎn)后舍入到精度 ndigits 的 number 。如果 ndigits 被省略或者是 None，它將返回最接近的整數(shù)表示。

對(duì)于支持 round() 的內(nèi)建類型，值舍入到 10 的最接近的負(fù) ndigits 次冪的倍數(shù)；如果離兩個(gè)倍數(shù)的距離相等，則舍入選擇偶數(shù)（因此，round(0.5) 和 round(-0.5) 都是 0，而 round(1.5) 是 2 ）。ndigits 可以是任何整數(shù)值（正數(shù)，零或負(fù)數(shù)）。如果使用一個(gè)參數(shù)調(diào)用則返回值是一個(gè) integer，否則與 number 的類型相同。

In [10]: type(round(10.9))
Out[10]: int

In [11]: type(round(10.9, 2))
Out[11]: float

對(duì)于一般的 Python 對(duì)象 xxx，round(xxx, ndigits) 委托給 xxx.__round__(ndigits)。

!> round() 對(duì)于浮點(diǎn)數(shù)的行為可能會(huì)令人驚訝：例如，round(2.675, 2) 給出 2.67，而不是預(yù)期的 2.68。這不是一個(gè) bug：這是由于大多數(shù)小數(shù)不能完全表示為浮點(diǎn)數(shù)的結(jié)果。

返回一個(gè)新的集合對(duì)象，可選地使用來(lái)自 iterable 的元素。 set 是一個(gè)內(nèi)置的類。

它和 getattr() 是一對(duì)。參數(shù)是一個(gè)對(duì)象，一個(gè)字符串和一個(gè)任意值。該字符串可以是現(xiàn)有的屬性名或新的屬性名。如果該對(duì)象允許，該函數(shù)將 value 分配給該屬性。例如，setattr(x, "foobar", 123) 等同于 x.foobar = 123。

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

返回表示由 range(start, stop, step) 指定的一組索引的切片對(duì)象。start 和 step 參數(shù)默認(rèn)為 None。切片對(duì)象具有只讀數(shù)據(jù)屬性 start、stop 和 step，它們只返回參數(shù)值（或它們的默認(rèn)值）。他們沒有其他明確的功能；然而，它們被 Numerical Python 和其他第三方擴(kuò)展使用。當(dāng)使用擴(kuò)展索引語(yǔ)法時(shí)，也會(huì)生成切片對(duì)象。例如：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(iterable, *, key=None, reverse=False)

從 iterable 中的 item 中返回一個(gè)新的排序列表。

有兩個(gè)可選參數(shù)，必須將其指定為關(guān)鍵字參數(shù)。

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

reverse 是一個(gè)布爾值。如果設(shè)置為 True，那么列表元素按照每個(gè)比較被顛倒的順序進(jìn)行排序。

內(nèi)置的 sorted() 函數(shù)排序是穩(wěn)定的。如果確保不會(huì)更改比較相等的元素的相對(duì)順序，則排序是穩(wěn)定的 。

將方法轉(zhuǎn)換為靜態(tài)方法。

靜態(tài)方法不會(huì)收到隱式的第一個(gè)參數(shù)。要聲明一個(gè)靜態(tài)方法，習(xí)慣用法如下：

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

它可以在類（如 C.f()）或?qū)嵗ㄈ?C().f()）上調(diào)用。

Python 中的靜態(tài)方法類似于 Java 或 C++ 中的。

class str(object="")
class str(object=b"", encoding="utf-8", errors="strict")

返回一個(gè)字符串對(duì)象

從 start 開始，從左到右對(duì) iterable 中的元素求和。 start 默認(rèn)是 0，迭代的 item 通常是數(shù)字，并且不允許 start 的值為字符串。

對(duì)于有些情況，有比 sum() 更好的選擇， 比如：連接字符串應(yīng)該用 "".join(sequence)。浮點(diǎn)數(shù)求和用 math.fsum() 。要連接一系列 iterable，請(qǐng)考慮使用 itertools.chain()。

返回一個(gè)代理對(duì)象，它委托方法給父類或者 type 的同級(jí)類。這對(duì)于訪問(wèn)類中被覆蓋的繼承方法很有用。搜索順序與 getattr() 使用的順序相同，只不過(guò) type 本身被跳過(guò)。

type 的 __mro__ 屬性列出 getattr() 和 super() 使用的方法解析順序。該屬性是動(dòng)態(tài)的，并且可以在繼承層次結(jié)構(gòu)更新時(shí)更改。

如果省略第二個(gè)參數(shù)，則返回的 super 對(duì)象是未綁定的。如果第二個(gè)參數(shù)是一個(gè)對(duì)象，則 isinstance(obj, type) 必須為 true。如果第二個(gè)參數(shù)是類型，則 issubclass(type2, type) 必須為 true（這對(duì)類方法很有用）。

super 有兩種典型的使用情況。在具有單繼承的類層次結(jié)構(gòu)中，可以使用 super 來(lái)引用父類，而不必明確命名它們，從而使代碼更易于維護(hù)。這種使用非常類似于在其他編程語(yǔ)言中 super 的使用。

第二種使用情況是在動(dòng)態(tài)執(zhí)行環(huán)境中支持協(xié)同多繼承。這種使用情況是 Python 獨(dú)有的，在靜態(tài)編譯語(yǔ)言或僅支持單繼承的語(yǔ)言中找不到。這使得可以實(shí)現(xiàn) “菱形圖”，其中多個(gè)基類實(shí)現(xiàn)相同的方法。良好的設(shè)計(jì)指出此方法在每種情況下具有相同的調(diào)用順序（因?yàn)檎{(diào)用的順序在運(yùn)行時(shí)確定，因?yàn)樵擁樞蜻m應(yīng)類層次結(jié)構(gòu)中的更改，并且因?yàn)樵擁樞蚩梢园ㄔ谶\(yùn)行時(shí)之前未知的兄弟類）。

對(duì)于這兩種用例，典型的超類調(diào)用如下所示：

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

!> 注意，super() 只實(shí)現(xiàn)顯式點(diǎn)分屬性查找的綁定過(guò)程，例如 super().__getitem__(name)。它通過(guò)實(shí)現(xiàn)自己的 __getattribute__() 方法來(lái)實(shí)現(xiàn)這一點(diǎn)，以便以支持協(xié)同多繼承需要的以可預(yù)測(cè)的順序搜索類。因此，super() 沒有定義隱式的查找語(yǔ)句或操作，例如 super()[name]。

!> 另請(qǐng)注意，除了零參數(shù)形式外，super() 不限于在方法內(nèi)部使用。如果兩個(gè)參數(shù)的形式指定了準(zhǔn)確的參數(shù)，就能進(jìn)行正確的引用。零參數(shù)形式只能在類定義中使用，因?yàn)榫幾g器會(huì)填充必要的細(xì)節(jié)以正確檢索正在定義的類，以及訪問(wèn)普通方法的當(dāng)前實(shí)例。

tuple 不是一個(gè)函數(shù)，它實(shí)際上是一個(gè)不可變的序列類型

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

有一個(gè)參數(shù)時(shí)，返回 object 的類型。返回值是一個(gè)類型對(duì)象，通常與 object.__class__ 返回的對(duì)象相同。

建議使用 isinstance() 內(nèi)置函數(shù)來(lái)測(cè)試對(duì)象的類型，因?yàn)樗鼤?huì)考慮子類。

有三個(gè)參數(shù)時(shí)，返回一個(gè)新的類型對(duì)象。這實(shí)質(zhì)上是類聲明的一種動(dòng)態(tài)形式。name 字符串是類名，并成為 __name__ 屬性；bases 元組逐項(xiàng)列出基類，并成為 __bases__ 屬性；dict 是包含類體的定義的命名空間，并被復(fù)制到標(biāo)準(zhǔn)字典中以變?yōu)?__dict__ 屬性。例如，以下兩條語(yǔ)句會(huì)創(chuàng)建相同的類型對(duì)象：

>>> class X:
...     a = 1
...
>>> X = type("X", (object,), dict(a=1))

返回一個(gè)模塊、字典、類、實(shí)例或者其它任何一個(gè)具有 __dict__ 屬性的對(duì)象的 __dict__ 屬性。

模塊和實(shí)例這樣的對(duì)象的 __dict__ 屬性可以更新；但是其它對(duì)象可能對(duì)它們的 __dict__ 屬性的寫操作有限制（例如，類使用 types.MappingProxyType 來(lái)阻止對(duì)字典直接更新）。

如果不帶參數(shù)，vars() 的行為就像 locals()。注意，locals 字典只用于讀取，因?yàn)閷?duì) locals 字典的更新會(huì)被忽略。

制作一個(gè)迭代器，用于聚合來(lái)自每個(gè)迭代器的元素。

返回元組的迭代器，其中第 i 個(gè)元組包含來(lái)自每個(gè)參數(shù)序列或迭代的第 i 個(gè)元素。當(dāng)最短的輸入迭代耗盡時(shí)，迭代器停止。使用單個(gè)迭代參數(shù)，它將返回 1 元組的迭代器。沒有參數(shù)，它返回一個(gè)空的迭代器。相當(dāng)于：

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)

只有當(dāng)您不關(guān)心后續(xù)的，來(lái)自較長(zhǎng)迭代器的未尾匹配值時(shí)，才應(yīng)該用 zip() 。如果這些值很重要，請(qǐng)改用 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

關(guān)注微信公眾號(hào) Python數(shù)據(jù)科學(xué)，帶你走進(jìn)數(shù)據(jù)的世界。