內置函數?

Python 解釋器內置了很多函數和類(lèi)型，任何時(shí)候都能使用。以下按字母順序給出列表。

abs(x)?

返回一個(gè)數的絕對值。 參數可以是整數、浮點(diǎn)數或任何實(shí)現了 __abs__() 的對象。 如果參數是一個(gè)復數，則返回它的模。

aiter(async_iterable)?

返回 asynchronous iterable 的 asynchronous iterator 。相當于調用 x.__aiter__()。

注意：與 iter() 不同，aiter() 沒(méi)有兩個(gè)參數的版本。

3.10 新版功能.

all(iterable)?

如果 iterable 的所有元素均為真值（或可迭代對象為空）則返回 True 。 等價(jià)于：

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

awaitable anext(async_iterator[, default])?

當進(jìn)入 await 狀態(tài)時(shí)，從給定 asynchronous iterator 返回下一數據項，迭代完畢則返回 default。

這是內置函數 next() 的異步版本，類(lèi)似于：

調用 async_iterator 的 __anext__() 方法，返回一個(gè) awaitable。等待返回迭代器的下一個(gè)值。若有給出 default，則在迭代完畢后會(huì )返回給出的值，否則會(huì )觸發(fā) StopAsyncIteration。

3.10 新版功能.

any(iterable)?

如果 iterable 的任一元素為真值則返回 True。 如果可迭代對象為空，返回 False。 等價(jià)于:

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

ascii(object)?

與 repr() 類(lèi)似，返回一個(gè)字符串，表示對象的可打印形式，但在 repr() 返回的字符串中，非 ASCII 字符會(huì )用 \x、\u 和 \U 進(jìn)行轉義。生成的字符串類(lèi)似于 Python 2 中 repr() 的返回結果。

bin(x)?

將整數轉變?yōu)橐浴?b”前綴的二進(jìn)制字符串。結果是一個(gè)合法的 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')

另見(jiàn) format() 獲取更多信息。

class bool([x])?

返回布爾值，True 或 False。x 用標準的 真值測試過(guò)程 進(jìn)行轉換。如果 x 為 False 或省略，則返回 False；否則返回 True。 bool 類(lèi)是 int 的子類(lèi)（見(jiàn) 數字類(lèi)型 --- int, float, complex ）。它不能再被繼承。它唯一的實(shí)例就是 False 和 True （參閱 布爾值 ）。

在 3.7 版更改: x 現在只能作為位置參數。

breakpoint(*args, **kws)?

此函數會(huì )在調用時(shí)將你陷入調試器中。具體來(lái)說(shuō)，它調用 sys.breakpointhook() ，直接傳遞 args 和 kws 。默認情況下， sys.breakpointhook() 調用 pdb.set_trace() 且沒(méi)有參數。在這種情況下，它純粹是一個(gè)便利函數，因此您不必顯式導入 pdb 且鍵入盡可能少的代碼即可進(jìn)入調試器。但是， sys.breakpointhook() 可以設置為其他一些函數并被 breakpoint() 自動(dòng)調用，以允許進(jìn)入你想用的調試器。

引發(fā)一個(gè) 審計事件 builtins.breakpoint 并附帶參數 breakpointhook。

3.7 新版功能.

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

返回一個(gè)新的 bytes 數組。 bytearray 類(lèi)是一個(gè)可變序列，包含范圍為 0 <= x < 256 的整數。它有可變序列大部分常見(jiàn)的方法，見(jiàn) 可變序列類(lèi)型 的描述；同時(shí)有 bytes 類(lèi)型的大部分方法，參見(jiàn) bytes 和 bytearray 操作。

可選形參 source 可以用不同的方式來(lái)初始化數組：

• 如果是一個(gè) string，您必須提供 encoding 參數（errors 參數仍是可選的）；bytearray() 會(huì )使用 str.encode() 方法來(lái)將 string 轉變成 bytes。

• 如果是一個(gè) integer，會(huì )初始化大小為該數字的數組，并使用 null 字節填充。

• 如果是一個(gè)遵循 緩沖區接口 的對象，該對象的只讀緩沖區將被用來(lái)初始化字節數組。

• 如果是一個(gè) iterable 可迭代對象，它的元素的范圍必須是 0 <= x < 256 的整數，它會(huì )被用作數組的初始內容。

如果沒(méi)有實(shí)參，則創(chuàng )建大小為 0 的數組。

另見(jiàn) 二進(jìn)制序列類(lèi)型 --- bytes, bytearray, memoryview 和 bytearray 對象。

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

返回一個(gè)新的“bytes”對象，這是一個(gè)不可變序列，包含范圍為 0 <= x < 256 的整數。bytes 是 bytearray 的不可變版本——帶有同樣不改變序列的方法，支持同樣的索引、切片操作。

因此，構造函數的實(shí)參和 bytearray() 相同。

字節對象還可以用字面值創(chuàng )建，參見(jiàn) 字符串與字節串字面值。

另見(jiàn) 二進(jìn)制序列類(lèi)型 --- bytes, bytearray, memoryview，bytes 對象 和 bytes 和 bytearray 操作。

callable(object)?

如果參數 object 是可調用的就返回 True，否則返回 False。 如果返回 True，調用仍可能失敗，但如果返回 False，則調用 object 將肯定不會(huì )成功。 請注意類(lèi)是可調用的（調用類(lèi)將返回一個(gè)新的實(shí)例）；如果實(shí)例所屬的類(lèi)有 __call__() 則它就是可調用的。

3.2 新版功能: 這個(gè)函數一開(kāi)始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

chr(i)?

返回 Unicode 碼位為整數 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。這是 ord() 的逆函數。

實(shí)參的合法范圍是 0 到 1,114,111（16 進(jìn)制表示是 0x10FFFF）。如果 i 超過(guò)這個(gè)范圍，會(huì )觸發(fā) ValueError 異常。

@classmethod?

把一個(gè)方法封裝成類(lèi)方法。

類(lèi)方法隱含的第一個(gè)參數就是類(lèi)，就像實(shí)例方法接收實(shí)例作為參數一樣。要聲明一個(gè)類(lèi)方法，按慣例請使用以下方案：

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

@classmethod 這樣的形式稱(chēng)為函數的 decorator -- 詳情參閱 函數定義。

類(lèi)方法的調用可以在類(lèi)上進(jìn)行 (例如 C.f()) 也可以在實(shí)例上進(jìn)行 (例如 C().f())。 其所屬類(lèi)以外的類(lèi)實(shí)例會(huì )被忽略。 如果類(lèi)方法在其所屬類(lèi)的派生類(lèi)上調用，則該派生類(lèi)對象會(huì )被作為隱含的第一個(gè)參數被傳入。

類(lèi)方法與 C++ 或 Java 中的靜態(tài)方法不同。 如果你需要后者，請參閱本節中的 staticmethod()。 有關(guān)類(lèi)方法的更多信息，請參閱 標準類(lèi)型層級結構。

在 3.9 版更改: 類(lèi)方法現在可以包裝其他 描述器 例如 property()。

在 3.10 版更改: 類(lèi)方法現在繼承了方法的屬性（__module__、__name__、__qualname__、__doc__ 和 __annotations__），并擁有一個(gè)新的``__wrapped__`` 屬性。

在 3.11 版更改: Class methods can no longer wrap other descriptors such as property().

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)?

將 source 編譯成代碼或 AST 對象。代碼對象可以被 exec() 或 eval() 執行。source 可以是常規的字符串、字節字符串，或者 AST 對象。參見(jiàn) ast 模塊的文檔了解如何使用 AST 對象。

filename 實(shí)參需要是代碼讀取的文件名；如果代碼不需要從文件中讀取，可以傳入一些可辨識的值（經(jīng)常會(huì )使用 '<string>'）。

mode 實(shí)參指定了編譯代碼必須用的模式。如果 source 是語(yǔ)句序列，可以是 'exec'；如果是單一表達式，可以是 'eval'；如果是單個(gè)交互式語(yǔ)句，可以是 'single'。（在最后一種情況下，如果表達式執行結果不是 None 將會(huì )被打印出來(lái)。）

可選參數 flags 和 dont_inherit 控制應當激活哪個(gè) 編譯器選項 以及應當允許哪個(gè) future 特性。 如果兩者都未提供 (或都為零) 則代碼會(huì )應用與調用 compile() 的代碼相同的旗標來(lái)編譯。 如果給出了 flags 參數而未給出 dont_inherit (或者為零) 則會(huì )在無(wú)論如何都將被使用的旗標之外還會(huì )額外使用 flags 參數所指定的編譯器選項和 future 語(yǔ)句。 如果 dont_inherit 為非零整數，則只使用 flags 參數 -- 外圍代碼中的旗標 (future 特性和編譯器選項) 會(huì )被忽略。

編譯器選項和 future 語(yǔ)句是由比特位來(lái)指明的。 比特位可以通過(guò)一起按位 OR 來(lái)指明多個(gè)選項。 指明特定 future 特性所需的比特位可以在 __future__ 模塊的 _Feature 實(shí)例的 compiler_flag 屬性中找到。 編譯器旗標 可以在 ast 模塊中查找帶有 PyCF_ 前綴的名稱(chēng)。

optimize 實(shí)參指定編譯器的優(yōu)化級別；默認值 -1 選擇與解釋器的 -O 選項相同的優(yōu)化級別。顯式級別為 0 （沒(méi)有優(yōu)化；__debug__ 為真）、1 （斷言被刪除， __debug__ 為假）或 2 （文檔字符串也被刪除）。

如果編譯的源碼不合法，此函數會(huì )觸發(fā) SyntaxError 異常；如果源碼包含 null 字節，則會(huì )觸發(fā) ValueError 異常。

如果您想分析 Python 代碼的 AST 表示，請參閱 ast.parse()。

引發(fā)一個(gè) 審計事件 compile 附帶參數 source, filename。

備注

在 'single' 或 'eval' 模式編譯多行代碼字符串時(shí)，輸入必須以至少一個(gè)換行符結尾。 這使 code 模塊更容易檢測語(yǔ)句的完整性。

警告

在將足夠大或者足夠復雜的字符串編譯成 AST 對象時(shí)，Python 解釋器有可能因為 Python AST 編譯器的棧深度限制而崩潰。

在 3.2 版更改: Windows 和 Mac 的換行符均可使用。而且在 'exec' 模式下的輸入不必再以換行符結尾了。另增加了 optimize 參數。

在 3.5 版更改: 之前 source 中包含 null 字節的話(huà)會(huì )觸發(fā) TypeError 異常。

3.8 新版功能: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT 現在可在旗標中傳入以啟用對最高層級 await, async for 和 async with 的支持。

class complex([real[, imag]])?

返回值為 real + imag*1j 的復數，或將字符串或數字轉換為復數。如果第一個(gè)形參是字符串，則它被解釋為一個(gè)復數，并且函數調用時(shí)必須沒(méi)有第二個(gè)形參。第二個(gè)形參不能是字符串。每個(gè)實(shí)參都可以是任意的數值類(lèi)型（包括復數）。如果省略了 imag，則默認值為零，構造函數會(huì )像 int 和 float 一樣進(jìn)行數值轉換。如果兩個(gè)實(shí)參都省略，則返回 0j。

對于一個(gè)普通 Python 對象 x，complex(x) 會(huì )委托給 x.__complex__()。 如果 __complex__() 未定義則將回退至 __float__()。 如果 __float__() 未定義則將回退至 __index__()。

備注

當從字符串轉換時(shí)，字符串在 + 或 - 的周?chē)仨毑荒苡锌崭?。例?complex('1+2j') 是合法的，但 complex('1 + 2j') 會(huì )觸發(fā) ValueError 異常。

數字類(lèi)型 --- int, float, complex 描述了復數類(lèi)型。

在 3.6 版更改: 您可以使用下劃線(xiàn)將代碼文字中的數字進(jìn)行分組。

在 3.8 版更改: 如果 __complex__() 和 __float__() 未定義則回退至 __index__()。

delattr(object, name)?

setattr() 相關(guān)的函數。實(shí)參是一個(gè)對象和一個(gè)字符串。該字符串必須是對象的某個(gè)屬性。如果對象允許，該函數將刪除指定的屬性。例如 delattr(x, 'foobar') 等價(jià)于 del x.foobar 。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

創(chuàng )建一個(gè)新的字典。dict 對象是一個(gè)字典類(lèi)。參見(jiàn) dict 和 映射類(lèi)型 --- dict 了解這個(gè)類(lèi)。

其他容器類(lèi)型，請參見(jiàn)內置的 list、set 和 tuple 類(lèi)，以及 collections 模塊。

dir([object])?

如果沒(méi)有實(shí)參，則返回當前本地作用域中的名稱(chēng)列表。如果有實(shí)參，它會(huì )嘗試返回該對象的有效屬性列表。

如果對象有一個(gè)名為 __dir__() 的方法，那么該方法將被調用，并且必須返回一個(gè)屬性列表。這允許實(shí)現自定義 __getattr__() 或 __getattribute__() 函數的對象能夠自定義 dir() 來(lái)報告它們的屬性。

如果對象未提供 __dir__() 方法，該函數會(huì )盡量從對象的 __dict__ 屬性和其類(lèi)型對象中收集信息。得到的列表不一定是完整，如果對象帶有自定義 __getattr__() 方法時(shí)，結果可能不準確。

默認的 dir() 機制對不同類(lèi)型的對象行為不同，它會(huì )試圖返回最相關(guān)而不是最全的信息：

• 如果對象是模塊對象，則列表包含模塊的屬性名稱(chēng)。

• 如果對象是類(lèi)型或類(lèi)對象，則列表包含它們的屬性名稱(chēng)，并且遞歸查找所有基類(lèi)的屬性。

• 否則，列表包含對象的屬性名稱(chēng)，它的類(lèi)屬性名稱(chēng)，并且遞歸查找它的類(lèi)的所有基類(lèi)的屬性。

返回的列表按字母表排序。例如：

>>>

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

備注

因為 dir() 主要是為了便于在交互式時(shí)使用，所以它會(huì )試圖返回人們感興趣的名字集合，而不是試圖保證結果的嚴格性或一致性，它具體的行為也可能在不同版本之間改變。例如，當實(shí)參是一個(gè)類(lèi)時(shí)，metaclass 的屬性不包含在結果列表中。

divmod(a, b)?

以?xún)蓚€(gè)（非復數）數字為參數，在作整數除法時(shí)，返回商和余數。若操作數為混合類(lèi)型，則適用二進(jìn)制算術(shù)運算符的規則。對于整數而言，結果與 (a // b, a % b) 相同。對于浮點(diǎn)數則結果為``(q, a % b)``，其中 q 通常為 math.floor(a / b)，但可能比它小 1。在任何情況下，q * b + a % b 都非常接近 a，如果 a % b 非零，則結果符號與 b 相同，并且 0 <= abs(a % b) < abs(b)。

enumerate(iterable, start=0)?

返回一個(gè)枚舉對象。iterable 必須是一個(gè)序列，或 iterator，或其他支持迭代的對象。 enumerate() 返回的迭代器的 __next__() 方法返回一個(gè)元組，里面包含一個(gè)計數值（從 start 開(kāi)始，默認為 0）和通過(guò)迭代 iterable 獲得的值。

>>>

>>> 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')]

等價(jià)于:

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

eval(expression[, globals[, locals]])?

實(shí)參是一個(gè)字符串，以及可選的 globals 和 locals。globals 實(shí)參必須是一個(gè)字典。locals 可以是任何映射對象。

表達式解析參數 expression 并作為 Python 表達式進(jìn)行求值（從技術(shù)上說(shuō)是一個(gè)條件列表），采用 globals 和 locals 字典作為全局和局部命名空間。 如果存在 globals 字典，并且不包含 __builtins__ 鍵的值，則在解析 expression 之前會(huì )插入以該字符串為鍵以對內置模塊 builtins 的字典的引用為值的項。 這樣就可以在將 globals 傳給 eval() 之前通過(guò)向其傳入你自己的 __builtins__ 字典來(lái)控制可供被執行代碼可以使用哪些內置模塊。 如果 locals 字典被省略則它默認為 globals 字典。 如果兩個(gè)字典都被省略，則將使用調用 eval() 的環(huán)境中的 globals 和 locals 來(lái)執行該表達式。 注意，eval() 無(wú)法訪(fǎng)問(wèn)閉包環(huán)境中的 嵌套作用域 (非局部變量)。

返回值就是表達式的求值結果。 語(yǔ)法錯誤將作為異常被報告。 例如：

>>>

>>> x = 1
>>> eval('x+1')
2

該函數還可用于執行任意代碼對象（比如由 compile() 創(chuàng )建的對象）。 這時(shí)傳入的是代碼對象，而非一個(gè)字符串了。如果代碼對象已用參數為 mode 的 'exec' 進(jìn)行了編譯，那么 eval() 的返回值將為 None。

提示： exec() 函數支持語(yǔ)句的動(dòng)態(tài)執行。 globals() 和 locals() 函數分別返回當前的全局和本地字典，可供傳給 eval() 或 exec() 使用。

如果給出的源數據是個(gè)字符串，那么其前后的空格和制表符將被剔除。

另外可以參閱 ast.literal_eval()，該函數可以安全執行僅包含文字的表達式字符串。

引發(fā)一個(gè) 審計事件 exec 附帶參數 code_object。

exec(object, [globals, [locals, ]]*, closure=None)?

This function supports dynamic execution of Python code. object must be either a string or a code object. If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs). 1 If it is a code object, it is simply executed. In all cases, the code that's executed is expected to be valid as file input (see the section 文件輸入 in the Reference Manual). Be aware that the nonlocal, yield, and return statements may not be used outside of function definitions even within the context of code passed to the exec() function. The return value is None.

無(wú)論在什么情況下，如果省略了可選部分，代碼將運行于當前作用域中。如果只提供了 globals，則必須為字典對象（而不能是字典的子類(lèi)），同時(shí)用于存放全局變量和局部變量。如果提供了 globals 和 locals，則將分別用于全局變量和局部變量。locals 可以是任意字典映射對象。請記住，在模塊級別，globals 和 locals 是同一個(gè)字典。如果 exec 獲得兩個(gè)獨立的對象作為 globals 和 locals，代碼執行起來(lái)就像嵌入到某個(gè)類(lèi)定義中一樣。

如果 globals 字典不包含 __builtins__ 鍵值，則將為該鍵插入對內建 builtins 模塊字典的引用。因此，在將執行的代碼傳遞給 exec() 之前，可以通過(guò)將自己的 __builtins__ 字典插入到 globals 中來(lái)控制可以使用哪些內置代碼。

The closure argument specifies a closure--a tuple of cellvars. It's only valid when the object is a code object containing free variables. The length of the tuple must exactly match the number of free variables referenced by the code object.

引發(fā)一個(gè) 審計事件 exec 附帶參數 code_object。

備注

內置 globals() 和 locals() 函數各自返回當前的全局和本地字典，因此可以將它們傳遞給 exec() 的第二個(gè)和第三個(gè)實(shí)參。

備注

默認情況下，locals 的行為如下面 locals() 函數描述的一樣：不要試圖改變默認的 locals 字典。 如果您需要在 exec() 函數返回時(shí)查看代碼對 locals 的影響，請明確地傳遞 locals 字典。

在 3.11 版更改: Added the closure parameter.

filter(function, iterable)?

用 iterable 中函數 function 返回真的那些元素，構建一個(gè)新的迭代器。iterable 可以是一個(gè)序列，一個(gè)支持迭代的容器，或一個(gè)迭代器。如果 function 是 None ，則會(huì )假設它是一個(gè)身份函數，即 iterable 中所有返回假的元素會(huì )被移除。

請注意， filter(function, iterable) 相當于一個(gè)生成器表達式，當 function 不是 None 的時(shí)候為 (item for item in iterable if function(item))；function 是 None 的時(shí)候為 (item for item in iterable if item) 。

請參閱 itertools.filterfalse() 了解，只有 function 返回 false 時(shí)才選取 iterable 中元素的補充函數。

class float([x])?

返回從數字或字符串 x 生成的浮點(diǎn)數。

如果參數是個(gè)字符串，則應包含一個(gè)十進(jìn)制數字，前面可選帶上符號，也可選前后帶有空白符。符號可以是``'+'`` 或 '-'；'+' 符號對值沒(méi)有影響。參數也可以是一個(gè)代表 NaN（非數字）或正負無(wú)窮大的字符串。更確切地說(shuō)，在去除前導和尾部的空白符后，輸入參數必須符合以下語(yǔ)法：

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

這里的 floatnumber 是指 Python 的浮點(diǎn)數格式，在 浮點(diǎn)數字面值 中有介紹。大小寫(xiě)沒(méi)有關(guān)系，所以“inf”、“Inf”、“INFINITY”、“iNfINity”都可接受為正無(wú)窮的拼寫(xiě)形式。

另一方面，如果實(shí)參是整數或浮點(diǎn)數，則返回具有相同值（在 Python 浮點(diǎn)精度范圍內）的浮點(diǎn)數。如果實(shí)參在 Python 浮點(diǎn)精度范圍外，則會(huì )觸發(fā) OverflowError。

對于一個(gè)普通 Python 對象 x，float(x) 會(huì )委托給 x.__float__()。 如果 __float__() 未定義則將回退至 __index__()。

如果沒(méi)有實(shí)參，則返回 0.0 。

示例:

>>>

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

數字類(lèi)型 --- int, float, complex 描述了浮點(diǎn)類(lèi)型。

在 3.6 版更改: 您可以使用下劃線(xiàn)將代碼文字中的數字進(jìn)行分組。

在 3.7 版更改: x 現在只能作為位置參數。

在 3.8 版更改: 如果 __float__() 未定義則回退至 __index__()。

format(value[, format_spec])?

將 value 轉換為“格式化后”的形式，格式由 format_spec 進(jìn)行控制。format_spec 的解釋方式取決于 value 參數的類(lèi)型；但大多數內置類(lèi)型使用一種標準的格式化語(yǔ)法： 格式規格迷你語(yǔ)言。

默認的 format_spec 是一個(gè)空字符串，它通常給出與調用 str(value) 相同的結果。

調用 format(value, format_spec) 會(huì )轉換成 type(value).__format__(value, format_spec) ，所以實(shí)例字典中的 __format__() 方法將不會(huì )調用。如果方法搜索回退到 object 類(lèi)但 format_spec 不為空，或者如果 format_spec 或返回值不是字符串，則會(huì )觸發(fā) TypeError 異常。

在 3.4 版更改: 當 format_spec 不是空字符串時(shí)， object().__format__(format_spec) 會(huì )觸發(fā) TypeError。

class frozenset([iterable])

返回一個(gè)新的 frozenset 對象，它包含可選參數 iterable 中的元素。 frozenset 是一個(gè)內置的類(lèi)。有關(guān)此類(lèi)的文檔，請參閱 frozenset 和 集合類(lèi)型 --- set, frozenset。

請參閱內建的 set、list、tuple 和 dict 類(lèi)，以及 collections 模塊來(lái)了解其它的容器。

getattr(object, name[, default])?

返回對象命名屬性的值。name 必須是字符串。如果該字符串是對象的屬性之一，則返回該屬性的值。例如， getattr(x, 'foobar') 等同于 x.foobar。如果指定的屬性不存在，且提供了 default 值，則返回它，否則觸發(fā) AttributeError。

備注

由于 私有名稱(chēng)混合 發(fā)生在編譯時(shí)，因此必須 手動(dòng)混合私有屬性（以?xún)蓚€(gè)下劃線(xiàn)打頭的屬性）名稱(chēng)以使使用 getattr() 來(lái)提取它。

globals()?

Return the dictionary implementing the current module namespace. For code within functions, this is set when the function is defined and remains the same regardless of where the function is called.

hasattr(object, name)?

該實(shí)參是一個(gè)對象和一個(gè)字符串。如果字符串是對象的屬性之一的名稱(chēng)，則返回 True，否則返回 False。（此功能是通過(guò)調用 getattr(object, name) 看是否有 AttributeError 異常來(lái)實(shí)現的。）

hash(object)?

返回該對象的哈希值（如果它有的話(huà)）。哈希值是整數。它們在字典查找元素時(shí)用來(lái)快速比較字典的鍵。相同大小的數字變量有相同的哈希值（即使它們類(lèi)型不同，如 1 和 1.0）。

備注

如果對象實(shí)現了自己的 __hash__() 方法，請注意，hash() 根據機器的字長(cháng)來(lái)截斷返回值。另請參閱 __hash__()。

help([object])?

啟動(dòng)內置的幫助系統（此函數主要在交互式中使用）。如果沒(méi)有實(shí)參，解釋器控制臺里會(huì )啟動(dòng)交互式幫助系統。如果實(shí)參是一個(gè)字符串，則在模塊、函數、類(lèi)、方法、關(guān)鍵字或文檔主題中搜索該字符串，并在控制臺上打印幫助信息。如果實(shí)參是其他任意對象，則會(huì )生成該對象的幫助頁(yè)。

請注意，如果在調用 help() 時(shí)，目標函數的形參列表中存在斜杠（/），則意味著(zhù)斜杠之前的參數只能是位置參數。詳情請參閱 有關(guān)僅限位置形參的 FAQ 條目。

該函數通過(guò) site 模塊加入到內置命名空間。

在 3.4 版更改: pydoc 和 inspect 的變更使得可調用對象的簽名信息更加全面和一致。

hex(x)?

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

>>>

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

如果要將整數轉換為大寫(xiě)或小寫(xiě)的十六進(jìn)制字符串，并可選擇有無(wú)“0x”前綴，則可以使用如下方法：

>>>

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

另見(jiàn) format() 獲取更多信息。

另請參閱 int() 將十六進(jìn)制字符串轉換為以 16 為基數的整數。

備注

如果要獲取浮點(diǎn)數的十六進(jìn)制字符串形式，請使用 float.hex() 方法。

id(object)?

返回對象的“標識值”。該值是一個(gè)整數，在此對象的生命周期中保證是唯一且恒定的。兩個(gè)生命期不重疊的對象可能具有相同的 id() 值。

CPython implementation detail: This is the address of the object in memory.

引發(fā)一個(gè) 審計事件 builtins.id，附帶參數 id。

input([prompt])?

如果存在 prompt 實(shí)參，則將其寫(xiě)入標準輸出，末尾不帶換行符。接下來(lái)，該函數從輸入中讀取一行，將其轉換為字符串（除了末尾的換行符）并返回。當讀取到 EOF 時(shí)，則觸發(fā) EOFError。例如:

>>>

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

如果加載了 readline 模塊，input() 將使用它來(lái)提供復雜的行編輯和歷史記錄功能。

引發(fā)一個(gè) 審計事件 builtins.input 附帶參數 prompt。

Raises an auditing event builtins.input/result with the result after successfully reading input.

class int([x])?

class int(x, base=10)

返回一個(gè)基于數字或字符串 x 構造的整數對象，或者在未給出參數時(shí)返回 0。 如果 x 定義了 __int__()，int(x) 將返回 x.__int__()。 如果 x 定義了 __index__()，它將返回 x.__index__()。 如果 x 定義了 __trunc__()，它將返回 x.__trunc__()。 對于浮點(diǎn)數，它將向零舍入。

如果 x 不是數字，或者有 base 參數，x 必須是字符串、bytes、表示進(jìn)制為 base 的 整數字面值 的 bytearray 實(shí)例。該文字前可以有 + 或 - （中間不能有空格），前后可以有空格。一個(gè)進(jìn)制為 n 的數字包含 0 到 n-1 的數，其中 a 到 z （或 A 到 Z ）表示 10 到 35。默認的 base 為 10 ，允許的進(jìn)制有 0、2-36。2、8、16 進(jìn)制的數字可以在代碼中用 0b/0B 、 0o/0O 、 0x/0X 前綴來(lái)表示。進(jìn)制為 0 將安照代碼的字面量來(lái)精確解釋?zhuān)詈蟮慕Y果會(huì )是 2、8、10、16 進(jìn)制中的一個(gè)。所以 int('010', 0) 是非法的，但 int('010') 和 int('010', 8) 是合法的。

整數類(lèi)型定義請參閱 數字類(lèi)型 --- int, float, complex 。

在 3.4 版更改: 如果 base 不是 int 的實(shí)例，但 base 對象有 base.__index__ 方法，則會(huì )調用該方法來(lái)獲取進(jìn)制數。以前的版本使用 base.__int__ 而不是 base.__index__。

在 3.6 版更改: 您可以使用下劃線(xiàn)將代碼文字中的數字進(jìn)行分組。

在 3.7 版更改: x 現在只能作為位置參數。

在 3.8 版更改: 如果 __int__() 未定義則回退至 __index__()。

在 3.11 版更改: The delegation to __trunc__() is deprecated.

isinstance(object, classinfo)?

Return True if the object argument is an instance of the classinfo argument, or of a (direct, indirect, or virtual) subclass thereof. If object is not an object of the given type, the function always returns False. If classinfo is a tuple of type objects (or recursively, other such tuples) or a union 類(lèi)型 of multiple types, return True if object is an instance of any of the types. If classinfo is not a type or tuple of types and such tuples, a TypeError exception is raised. TypeError may not be raised for an invalid type if an earlier check succeeds.

在 3.10 版更改: classinfo 可以是一個(gè) union 類(lèi)型。

issubclass(class, classinfo)?

Return True if class is a subclass (direct, indirect, or virtual) of classinfo. A class is considered a subclass of itself. classinfo may be a tuple of class objects (or recursively, other such tuples) or a union 類(lèi)型, in which case return True if class is a subclass of any entry in classinfo. In any other case, a TypeError exception is raised.

在 3.10 版更改: classinfo 可以是一個(gè) union 類(lèi)型。

iter(object[, sentinel])?

Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, object must be a collection object which supports the iterable protocol (the __iter__() method), or it must support the sequence protocol (the __getitem__() method with integer arguments starting at 0). If it does not support either of those protocols, TypeError is raised. If the second argument, sentinel, is given, then object must be a callable object. The iterator created in this case will call object with no arguments for each call to its __next__() method; if the value returned is equal to sentinel, StopIteration will be raised, otherwise the value will be returned.

另請參閱 迭代器類(lèi)型。

適合 iter() 的第二種形式的應用之一是構建塊讀取器。 例如，從二進(jìn)制數據庫文件中讀取固定寬度的塊，直至到達文件的末尾:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(s)?

返回對象的長(cháng)度（元素個(gè)數）。實(shí)參可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

CPython implementation detail: len 對于大于 sys.maxsize 的長(cháng)度如 range(2 ** 100) 會(huì )引發(fā) OverflowError。

class list([iterable])

雖然被稱(chēng)為函數，list 實(shí)際上是一種可變序列類(lèi)型，詳情請參閱 列表 和 序列類(lèi)型 --- list, tuple, range。

locals()?

更新并返回表示當前本地符號表的字典。 在函數代碼塊但不是類(lèi)代碼塊中調用 locals() 時(shí)將返回自由變量。 請注意在模塊層級上，locals() 和 globals() 是同一個(gè)字典。

備注

不要更改此字典的內容；更改不會(huì )影響解釋器使用的局部變量或自由變量的值。

map(function, iterable, ...)?

返回一個(gè)將 function 應用于 iterable 中每一項并輸出其結果的迭代器。 如果傳入了額外的 iterable 參數，function 必須接受相同個(gè)數的實(shí)參并被應用于從所有可迭代對象中并行獲取的項。 當有多個(gè)可迭代對象時(shí)，最短的可迭代對象耗盡則整個(gè)迭代就將結束。 對于函數的輸入已經(jīng)是參數元組的情況，請參閱 itertools.starmap()。

max(iterable, *[, key, default])?

max(arg1, arg2, *args[, key])

返回可迭代對象中最大的元素，或者返回兩個(gè)及以上實(shí)參中最大的。

如果只提供了一個(gè)位置參數，它必須是非空 iterable，返回可迭代對象中最大的元素；如果提供了兩個(gè)及以上的位置參數，則返回最大的位置參數。

有兩個(gè)可選只能用關(guān)鍵字的實(shí)參。key 實(shí)參指定排序函數用的參數，如傳給 list.sort() 的。default 實(shí)參是當可迭代對象為空時(shí)返回的值。如果可迭代對象為空，并且沒(méi)有給 default ，則會(huì )觸發(fā) ValueError。

如果有多個(gè)最大元素，則此函數將返回第一個(gè)找到的。這和其他穩定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

3.4 新版功能: keyword-only 實(shí)參 default 。

在 3.8 版更改: key 可以為 None。

class memoryview(object)

返回由給定實(shí)參創(chuàng )建的“內存視圖”對象。有關(guān)詳細信息，請參閱 內存視圖。

min(iterable, *[, key, default])?

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

返回可迭代對象中最小的元素，或者返回兩個(gè)及以上實(shí)參中最小的。

如果只提供了一個(gè)位置參數，它必須是 iterable，返回可迭代對象中最小的元素；如果提供了兩個(gè)及以上的位置參數，則返回最小的位置參數。

有兩個(gè)可選只能用關(guān)鍵字的實(shí)參。key 實(shí)參指定排序函數用的參數，如傳給 list.sort() 的。default 實(shí)參是當可迭代對象為空時(shí)返回的值。如果可迭代對象為空，并且沒(méi)有給 default ，則會(huì )觸發(fā) ValueError。

如果有多個(gè)最小元素，則此函數將返回第一個(gè)找到的。這和其他穩定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

3.4 新版功能: keyword-only 實(shí)參 default 。

在 3.8 版更改: key 可以為 None。

next(iterator[, default])?

Retrieve the next item from the iterator by calling its __next__() method. If default is given, it is returned if the iterator is exhausted, otherwise StopIteration is raised.

class object?

返回一個(gè)不帶特征的新對象。object 是所有類(lèi)的基類(lèi)。它帶有所有 Python 類(lèi)實(shí)例均通用的方法。本函數不接受任何參數。

備注

由于 object 沒(méi)有 __dict__，因此無(wú)法將任意屬性賦給 object 的實(shí)例。

oct(x)?

將一個(gè)整數轉變?yōu)橐粋€(gè)前綴為“0o”的八進(jìn)制字符串。結果是一個(gè)合法的 Python 表達式。如果 x 不是 Python 的 int 對象，那它需要定義 __index__() 方法返回一個(gè)整數。一些例子：

>>>

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

若要將整數轉換為八進(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')

另見(jiàn) format() 獲取更多信息。

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

打開(kāi) file 并返回對應的 file object。 如果該文件不能被打開(kāi)，則引發(fā) OSError。 請參閱 讀寫(xiě)文件 獲取此函數的更多用法示例。

file 是一個(gè) path-like object，表示將要打開(kāi)的文件的路徑（絕對路徑或者相對當前工作目錄的路徑），也可以是要封裝文件對應的整數類(lèi)型文件描述符。（如果給出的是文件描述符，則當返回的 I/O 對象關(guān)閉時(shí)它也會(huì )關(guān)閉，除非將 closefd 設為 False 。）

mode is an optional string that specifies the mode in which the file is opened. It defaults to 'r' which means open for reading in text mode. Other common values are 'w' for writing (truncating the file if it already exists), 'x' for exclusive creation, and 'a' for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform-dependent: locale.getencoding() is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:

字符	含意
'r'	讀?。J）
'w'	寫(xiě)入，并先截斷文件
'x'	排它性創(chuàng )建，如果文件已存在則失敗
'a'	打開(kāi)文件用于寫(xiě)入，如果文件存在則在末尾追加
'b'	二進(jìn)制模式
't'	文本模式（默認）
'+'	打開(kāi)用于更新（讀取與寫(xiě)入）

默認模式為 'r' （打開(kāi)文件用于讀取文本，與 'rt' 同義）。'w+' 和 'w+b' 模式將打開(kāi)文件并清空內容。而 'r+' 和 'r+b' 模式將打開(kāi)文件但不清空內容。

正如在 概述 中提到的，Python區分二進(jìn)制和文本I/O。以二進(jìn)制模式打開(kāi)的文件（包括 mode 參數中的 'b' ）返回的內容為 bytes 對象，不進(jìn)行任何解碼。在文本模式下（默認情況下，或者在 mode 參數中包含 't' ）時(shí)，文件內容返回為 str ，首先使用指定的 encoding （如果給定）或者使用平臺默認的的字節編碼解碼。

備注

Python不依賴(lài)于底層操作系統的文本文件概念;所有處理都由Python本身完成，因此與平臺無(wú)關(guān)。

buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. Note that specifying a buffer size this way applies for binary buffered I/O, but TextIOWrapper (i.e., files opened with mode='r+') would have another buffering. To disable buffering in TextIOWrapper, consider using the write_through flag for io.TextIOWrapper.reconfigure(). When no buffering argument is given, the default buffering policy works as follows:

• 二進(jìn)制文件以固定大小的塊進(jìn)行緩沖；使用啟發(fā)式方法選擇緩沖區的大小，嘗試確定底層設備的“塊大小”或使用 io.DEFAULT_BUFFER_SIZE。在許多系統上，緩沖區的長(cháng)度通常為4096或8192字節。

• “交互式”文本文件（ isatty() 返回 True 的文件）使用行緩沖。其他文本文件使用上述策略用于二進(jìn)制文件。

encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent (whatever locale.getencoding() returns), but any text encoding supported by Python can be used. See the codecs module for the list of supported encodings.

errors 是一個(gè)可選的字符串參數，用于指定如何處理編碼和解碼錯誤 - 這不能在二進(jìn)制模式下使用?？梢允褂酶鞣N標準錯誤處理程序（列在 錯誤處理方案 ），但是使用 codecs.register_error() 注冊的任何錯誤處理名稱(chēng)也是有效的。標準名稱(chēng)包括:

• 如果存在編碼錯誤，'strict' 會(huì )引發(fā) ValueError 異常。 默認值 None 具有相同的效果。

• 'ignore' 忽略錯誤。請注意，忽略編碼錯誤可能會(huì )導致數據丟失。

• 'replace' 會(huì )將替換標記（例如 '?' ）插入有錯誤數據的地方。

• 'surrogateescape' 將把任何不正確的字節表示為 U+DC80 至 U+DCFF 范圍內的下方替代碼位。 當在寫(xiě)入數據時(shí)使用 surrogateescape 錯誤處理句柄時(shí)這些替代碼位會(huì )被轉回到相同的字節。 這適用于處理具有未知編碼格式的文件。

• 只有在寫(xiě)入文件時(shí)才支持 'xmlcharrefreplace'。編碼不支持的字符將替換為相應的XML字符引用 &#nnn;。

• 'backslashreplace' 用Python的反向轉義序列替換格式錯誤的數據。

• 'namereplace' （也只在編寫(xiě)時(shí)支持）用 \N{...} 轉義序列替換不支持的字符。

newline 控制 universal newlines 模式如何生效（它僅適用于文本模式）。它可以是 None，''，'\n'，'\r' 和 '\r\n'。它的工作原理:

• 從流中讀取輸入時(shí)，如果 newline 為 None，則啟用通用換行模式。輸入中的行可以以 '\n'，'\r' 或 '\r\n' 結尾，這些行被翻譯成 '\n' 在返回呼叫者之前。如果它是 ''，則啟用通用換行模式，但行結尾將返回給調用者未翻譯。如果它具有任何其他合法值，則輸入行僅由給定字符串終止，并且行結尾將返回給未調用的調用者。

• 將輸出寫(xiě)入流時(shí)，如果 newline 為 None，則寫(xiě)入的任何 '\n' 字符都將轉換為系統默認行分隔符 os.linesep。如果 newline 是 '' 或 '\n'，則不進(jìn)行翻譯。如果 newline 是任何其他合法值，則寫(xiě)入的任何 '\n' 字符將被轉換為給定的字符串。

如果 closefd 為 False 且給出的不是文件名而是文件描述符，那么當文件關(guān)閉時(shí)，底層文件描述符將保持打開(kāi)狀態(tài)。如果給出的是文件名，則 closefd 必須為 True （默認值），否則將觸發(fā)錯誤。

可以通過(guò)傳遞可調用的 opener 來(lái)使用自定義開(kāi)啟器。然后通過(guò)使用參數（ file，flags ）調用 opener 獲得文件對象的基礎文件描述符。 opener 必須返回一個(gè)打開(kāi)的文件描述符（使用 os.open as opener 時(shí)與傳遞 None 的效果相同）。

新創(chuàng )建的文件是 不可繼承的。

下面的示例使用 os.open() 函數的 dir_fd 的形參，從給定的目錄中用相對路徑打開(kāi)文件:

>>>

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

open() 函數所返回的 file object 類(lèi)型取決于所用模式。 當使用 open() 以文本模式 ('w', 'r', 'wt', 'rt' 等) 打開(kāi)文件時(shí)，它將返回 io.TextIOBase (特別是 io.TextIOWrapper) 的一個(gè)子類(lèi)。 當使用緩沖以二進(jìn)制模式打開(kāi)文件時(shí)，返回的類(lèi)是 io.BufferedIOBase 的一個(gè)子類(lèi)。 具體的類(lèi)會(huì )有多種：在只讀的二進(jìn)制模式下，它將返回 io.BufferedReader；在寫(xiě)入二進(jìn)制和追加二進(jìn)制模式下，它將返回 io.BufferedWriter，而在讀/寫(xiě)模式下，它將返回 io.BufferedRandom。 當禁用緩沖時(shí)，則會(huì )返回原始流，即 io.RawIOBase 的一個(gè)子類(lèi) io.FileIO。

另請參閱文件操作模塊，如 fileinput、io （聲明了 open()）、os、os.path、tempfile 和 shutil。

引發(fā)一個(gè) 審計事件 open 附帶參數 file, mode, flags。

mode 與 flags 參數可以在原始調用的基礎上被修改或傳遞。

在 3.3 版更改:

• 增加了 opener 形參。

• 增加了 'x' 模式。

• 過(guò)去觸發(fā)的 IOError，現在是 OSError 的別名。

• 如果文件已存在但使用了排它性創(chuàng )建模式（ 'x' ），現在會(huì )觸發(fā) FileExistsError。

在 3.4 版更改:

• 文件現在禁止繼承。

在 3.5 版更改:

• 如果系統調用被中斷，但信號處理程序沒(méi)有觸發(fā)異常，此函數現在會(huì )重試系統調用，而不是觸發(fā) InterruptedError 異常 (原因詳見(jiàn) PEP 475)。

• 增加了 'namereplace' 錯誤處理接口。

在 3.6 版更改:

• 增加對實(shí)現了 os.PathLike 對象的支持。

• 在 Windows 上，打開(kāi)一個(gè)控制臺緩沖區將返回 io.RawIOBase 的子類(lèi)，而不是 io.FileIO。

在 3.11 版更改: The 'U' mode has been removed.

ord(c)?

對表示單個(gè) Unicode 字符的字符串，返回代表它 Unicode 碼點(diǎn)的整數。例如 ord('a') 返回整數 97， ord('€') （歐元符號）返回 8364 。這是 chr() 的逆函數。

pow(base, exp[, mod])?

返回 base 的 exp 次冪；如果 mod 存在，則返回 base 的 exp 次冪對 mod 取余（比 pow(base, exp) % mod 更高效）。 兩參數形式 pow(base, exp) 等價(jià)于乘方運算符: base**exp。

The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, pow(10, 2) returns 100, but pow(10, -2) returns 0.01. For a negative base of type int or float and a non-integral exponent, a complex result is delivered. For example, pow(-9, 0.5) returns a value close to 3j.

對于 int 操作數 base 和 exp，如果給出 mod，則 mod 必須為整數類(lèi)型并且 mod 必須不為零。 如果給出 mod 并且 exp 為負值，則 base 必須相對于 mod 不可整除。 在這種情況下，將會(huì )返回 pow(inv_base, -exp, mod)，其中 inv_base 為 base 的倒數對 mod 取余。

下面的例子是 38 的倒數對 97 取余:

>>>

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

在 3.8 版更改: 對于 int 操作數，三參數形式的 pow 現在允許第二個(gè)參數為負值，即可以計算倒數的余數。

在 3.8 版更改: 允許關(guān)鍵字參數。 之前只支持位置參數。

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)?

將 objects 打印輸出至 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep 、 end 、 file 和 flush 必須以關(guān)鍵字參數的形式給出。

所有非關(guān)鍵字參數都會(huì )被轉換為字符串，就像是執行了 str() 一樣，并會(huì )被寫(xiě)入到流，以 sep 且在末尾加上 end。 sep 和 end 都必須為字符串；它們也可以為 None，這意味著(zhù)使用默認值。 如果沒(méi)有給出 objects，則 print() 將只寫(xiě)入 end。

file 參數必須是一個(gè)具有 write(string) 方法的對象；如果參數不存在或為 None，則將使用 sys.stdout。 由于要打印的參數會(huì )被轉換為文本字符串，因此 print() 不能用于二進(jìn)制模式的文件對象。 對于這些對象，應改用 file.write(...)。

輸出是否緩存通常取決于 file，但如果 flush 關(guān)鍵字參數為 True，輸出流會(huì )被強制刷新。

在 3.3 版更改: 增加了 flush 關(guān)鍵字參數。

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

返回 property 屬性。

fget 是獲取屬性值的函數。 fset 是用于設置屬性值的函數。 fdel 是用于刪除屬性值的函數。并且 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 的實(shí)例，c.x 將調用 getter，c.x = value 將調用 setter， del c.x 將調用 deleter。

如果給出，doc 將成為該 property 屬性的文檔字符串。 否則該 property 將拷貝 fget 的文檔字符串（如果存在）。 這令使用 property() 作為 decorator 來(lái)創(chuàng )建只讀的特征屬性可以很容易地實(shí)現:

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

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

以上 @property 裝飾器會(huì )將 voltage() 方法轉化為一個(gè)具有相同名稱(chēng)的只讀屬性的 "getter"，并將 voltage 的文檔字符串設置為 "Get the current voltage."

特征屬性對象具有 getter, setter 以及 deleter 方法，它們可用作裝飾器來(lái)創(chuàng )建該特征屬性的副本，并將相應的訪(fǎng)問(wèn)函數設為所裝飾的函數。 這最好是用一個(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è)例子完全等價(jià)。 注意一定要給附加函數與原始的特征屬性相同的名稱(chēng) (在本例中為 x。)

返回的特征屬性對象同樣具有與構造器參數相對應的屬性 fget, fset 和 fdel。

在 3.5 版更改: 特征屬性對象的文檔字符串現在是可寫(xiě)的。

class range(stop)

class range(start, stop[, step])

雖然被稱(chēng)為函數，但 range 實(shí)際上是一個(gè)不可變的序列類(lèi)型，參見(jiàn)在 range 對象 與 序列類(lèi)型 --- list, tuple, range 中的文檔說(shuō)明。

repr(object)?

返回對象的可打印形式字符串。對于很多類(lèi)型而言，本函數試圖返回的字符串，會(huì )與將對象傳給 eval() 所生成的結果相同；不然，結果就是一個(gè)尖括號包裹的字符串，包含了對象類(lèi)型名稱(chēng)及其附加信息，附加信息通常包括對象的名稱(chēng)和內存地址。通過(guò)定義 __repr__() 方法，類(lèi)可以控制本函數將為實(shí)例返回的內容。

reversed(seq)?

返回一個(gè)反向的 iterator。 seq 必須是一個(gè)具有 __reversed__() 方法的對象或者是支持該序列協(xié)議（具有從 0 開(kāi)始的整數類(lèi)型參數的 __len__() 方法和 __getitem__() 方法）。

round(number[, ndigits])?

返回 number 舍入到小數點(diǎn)后 ndigits 位精度的值。 如果 ndigits 被省略或為 None，則返回最接近輸入值的整數。

對于支持 round() 方法的內置類(lèi)型，結果值會(huì )舍入至最接近的 10 的負 ndigits 次冪的倍數；如果與兩個(gè)倍數同樣接近，則選用偶數。因此，round(0.5) 和 round(-0.5) 均得出 0 而 round(1.5) 則為 2。ndigits 可為任意整數值（正數、零或負數）。如果省略了 ndigits 或為 None ，則返回值將為整數。否則返回值與 number 的類(lèi)型相同。

對于一般的 Python 對象 number, round 將委托給 number.__round__。

備注

對浮點(diǎn)數執行 round() 的行為可能會(huì )令人驚訝：例如，round(2.675, 2) 將給出 2.67 而不是期望的 2.68。 這不算是程序錯誤：這一結果是由于大多數十進(jìn)制小數實(shí)際上都不能以浮點(diǎn)數精確地表示。 請參閱 浮點(diǎn)算術(shù)：爭議和限制 了解更多信息。

class set([iterable])

返回一個(gè)新的 set 對象，可以選擇帶有從 iterable 獲取的元素。 set 是一個(gè)內置類(lèi)型。 請查看 set 和 集合類(lèi)型 --- set, frozenset 獲取關(guān)于這個(gè)類(lèi)的文檔。

有關(guān)其他容器請參看內置的 frozenset, list, tuple 和 dict 類(lèi)，以及 collections 模塊。

setattr(object, name, value)?

本函數與 getattr() 相對應。其參數為一個(gè)對象、一個(gè)字符串和一個(gè)任意值。字符串可以為某現有屬性的名稱(chēng)，或為新屬性。只要對象允許，函數會(huì )將值賦給屬性。如 setattr(x, 'foobar', 123) 等價(jià)于 x.foobar = 123。

備注

由于 私有名稱(chēng)混合 發(fā)生在編譯時(shí)，因此必須手動(dòng)混合私有屬性（以?xún)蓚€(gè)下劃線(xiàn)打頭的屬性）名稱(chēng)以便使用 setattr() 來(lái)設置它。

class slice(stop)?

class slice(start, stop[, step])

返回一個(gè) slice 對象，代表由 range(start, stop, step) 指定索引集的切片。 其中參數 start 和 step 的默認值為 None。切片對象具有只讀數據屬性 start 、stop 和 step，只是返回對應的參數值（或默認值）。這幾個(gè)屬性沒(méi)有其他明確的功能；不過(guò) NumPy 和其他第三方擴展會(huì )用到。在使用擴展索引語(yǔ)法時(shí)，也會(huì )生成切片對象。例如： a[start:stop:step] 或 a[start:stop, i]。 另一種方案是返回迭代器對象，可參閱 itertools.islice() 。

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

根據 iterable 中的項返回一個(gè)新的已排序列表。

具有兩個(gè)可選參數，它們都必須指定為關(guān)鍵字參數。

key 指定帶有單個(gè)參數的函數，用于從 iterable 的每個(gè)元素中提取用于比較的鍵 (例如 key=str.lower)。 默認值為 None (直接比較元素)。

reverse 為一個(gè)布爾值。 如果設為 True，則每個(gè)列表元素將按反向順序比較進(jìn)行排序。

使用 functools.cmp_to_key() 可將老式的 cmp 函數轉換為 key 函數。

內置的 sorted() 確保是穩定的。 如果一個(gè)排序確保不會(huì )改變比較結果相等的元素的相對順序就稱(chēng)其為穩定的 --- 這有利于進(jìn)行多重排序（例如先按部門(mén)、再按薪級排序）。

The sort algorithm uses only < comparisons between items. While defining an __lt__() method will suffice for sorting, PEP 8 recommends that all six rich comparisons be implemented. This will help avoid bugs when using the same data with other ordering tools such as max() that rely on a different underlying method. Implementing all six comparisons also helps avoid confusion for mixed type comparisons which can call reflected the __gt__() method.

有關(guān)排序示例和簡(jiǎn)要排序教程，請參閱 排序指南 。

@staticmethod?

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

靜態(tài)方法不會(huì )接收隱式的第一個(gè)參數。要聲明一個(gè)靜態(tài)方法，請使用此語(yǔ)法

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

@staticmethod 這樣的形式稱(chēng)為函數的 decorator -- 詳情參閱 函數定義。

靜態(tài)方法既可以由類(lèi)中調用（如 C.f()），也可以由實(shí)例中調用（如```C().f()``）。此外，還可以作為普通的函數進(jìn)行調用（如``f()``）。

Python 的靜態(tài)方法與 Java 或 C++ 類(lèi)似。另請參閱 classmethod() ，可用于創(chuàng )建另一種類(lèi)構造函數。

像所有裝飾器一樣，也可以像常規函數一樣調用 staticmethod ，并對其結果執行某些操作。比如某些情況下需要從類(lèi)主體引用函數并且您希望避免自動(dòng)轉換為實(shí)例方法。對于這些情況，請使用此語(yǔ)法:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

想了解更多有關(guān)靜態(tài)方法的信息，請參閱 標準類(lèi)型層級結構 。

在 3.10 版更改: 靜態(tài)方法繼承了方法的多個(gè)屬性（__module__、__name__、__qualname__、__doc__ 和 __annotations__），還擁有一個(gè)新的``__wrapped__`` 屬性，并且現在還可以作為普通函數進(jìn)行調用。

class str(object='')

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

返回一個(gè) str 版本的 object 。有關(guān)詳細信息，請參閱 str() 。

str 是內置字符串 class 。更多關(guān)于字符串的信息查看 文本序列類(lèi)型 --- str。

sum(iterable, /, start=0)?

從 start 開(kāi)始自左向右對 iterable 的項求和并返回總計值。 iterable 的項通常為數字，而 start 值則不允許為字符串。

對某些用例來(lái)說(shuō)，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是調用 ''.join(sequence)。 要以擴展精度對浮點(diǎn)值求和，請參閱 math.fsum()。 要拼接一系列可迭代對象，請考慮使用 itertools.chain()。

在 3.8 版更改: start 形參可用關(guān)鍵字參數形式來(lái)指定。

class super([type[, object-or-type]])?

返回一個(gè)代理對象，它會(huì )將方法調用委托給 type 的父類(lèi)或兄弟類(lèi)。 這對于訪(fǎng)問(wèn)已在類(lèi)中被重載的繼承方法很有用。

object-or-type 確定用于搜索的 method resolution order。 搜索會(huì )從 type 之后的類(lèi)開(kāi)始。

舉例來(lái)說(shuō)，如果 object-or-type 的 __mro__ 為 D -> B -> C -> A -> object 并且 type 的值為 B，則 super() 將會(huì )搜索 C -> A -> object。

object-or-type 的 __mro__ 屬性列出了 getattr() 和 super() 所共同使用的方法解析搜索順序。 該屬性是動(dòng)態(tài)的，可以在任何繼承層級結構發(fā)生更新的時(shí)候被改變。

如果省略第二個(gè)參數，則返回的超類(lèi)對象是未綁定的。 如果第二個(gè)參數為一個(gè)對象，則 isinstance(obj, type) 必須為真值。 如果第二個(gè)參數為一個(gè)類(lèi)型，則 issubclass(type2, type) 必須為真值（這適用于類(lèi)方法）。

super 有兩個(gè)典型用例。 在具有單繼承的類(lèi)層級結構中，super 可用來(lái)引用父類(lèi)而不必顯式地指定它們的名稱(chēng)，從而令代碼更易維護。 這種用法與其他編程語(yǔ)言中 super 的用法非常相似。

第二個(gè)用例是在動(dòng)態(tài)執行環(huán)境中支持協(xié)作多重繼承。 此用例為 Python 所獨有而不存在于靜態(tài)編碼語(yǔ)言或僅支持單繼承的語(yǔ)言當中。 這使用實(shí)現“菱形圖”成為可能，即有多個(gè)基類(lèi)實(shí)現相同的方法。 好的設計強制要求這樣的方法在每個(gè)情況下都具有相同的調用簽名（因為調用順序是在運行時(shí)確定的，也因為這個(gè)順序要適應類(lèi)層級結構的更改，還因為這個(gè)順序可能包括在運行時(shí)之前未知的兄弟類(lèi)）。

對于以上兩個(gè)用例，典型的超類(lèi)調用看起來(lái)是這樣的:

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

除了方法查找之外，super() 也可用于屬性查找。 一個(gè)可能的應用場(chǎng)合是在上級或同級類(lèi)中調用 描述器。

請注意 super() 是作為顯式加點(diǎn)屬性查找的綁定過(guò)程的一部分來(lái)實(shí)現的，例如 super().__getitem__(name)。 它做到這一點(diǎn)是通過(guò)實(shí)現自己的 __getattribute__() 方法，這樣就能以可預測的順序搜索類(lèi)，并且支持協(xié)作多重繼承。 對應地，super() 在像 super()[name] 這樣使用語(yǔ)句或操作符進(jìn)行隱式查找時(shí)則未被定義。

還要注意的是，除了零個(gè)參數的形式以外，super() 并不限于在方法內部使用。 兩個(gè)參數的形式明確指定參數并進(jìn)行相應的引用。 零個(gè)參數的形式僅適用于類(lèi)定義內部，因為編譯器需要填入必要的細節以正確地檢索到被定義的類(lèi)，還需要讓普通方法訪(fǎng)問(wèn)當前實(shí)例。

對于有關(guān)如何使用 super() 來(lái)如何設計協(xié)作類(lèi)的實(shí)用建議，請參閱 使用 super() 的指南。

class tuple([iterable])

雖然被稱(chēng)為函數，但 tuple 實(shí)際上是一個(gè)不可變的序列類(lèi)型，參見(jiàn)在 元組 與 序列類(lèi)型 --- list, tuple, range 中的文檔說(shuō)明。

class type(object)?

class type(name, bases, dict, **kwds)

傳入一個(gè)參數時(shí)，返回 object 的類(lèi)型。 返回值是一個(gè) type 對象，通常與 object.__class__ 所返回的對象相同。

推薦使用 isinstance() 內置函數來(lái)檢測對象的類(lèi)型，因為它會(huì )考慮子類(lèi)的情況。

傳入三個(gè)參數時(shí)，返回一個(gè)新的 type 對象。 這在本質(zhì)上是 class 語(yǔ)句的一種動(dòng)態(tài)形式，name 字符串即類(lèi)名并會(huì )成為 __name__ 屬性；bases 元組包含基類(lèi)并會(huì )成為 __bases__ 屬性；如果為空則會(huì )添加所有類(lèi)的終極基類(lèi) object。 dict 字典包含類(lèi)主體的屬性和方法定義；它在成為 __dict__ 屬性之前可能會(huì )被拷貝或包裝。 下面兩條語(yǔ)句會(huì )創(chuàng )建相同的 type 對象:

>>>

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

另請參閱 類(lèi)型對象。

提供給三參數形式的關(guān)鍵字參數會(huì )被傳遞給適當的元類(lèi)機制 (通常為 __init_subclass__())，相當于類(lèi)定義中關(guān)鍵字 (除了 metaclass) 的行為方式。

另請參閱 自定義類(lèi)創(chuàng )建。

在 3.6 版更改: type 的子類(lèi)如果未重載 type.__new__，將不再能使用一個(gè)參數的形式來(lái)獲取對象的類(lèi)型。

vars([object])?

返回模塊、類(lèi)、實(shí)例或任何其它具有 __dict__ 屬性的對象的 __dict__ 屬性。

模塊和實(shí)例這樣的對象具有可更新的 __dict__ 屬性；但是，其它對象的 __dict__ 屬性可能會(huì )設為限制寫(xiě)入（例如，類(lèi)會(huì )使用 types.MappingProxyType 來(lái)防止直接更新字典）。

不帶參數時(shí)，vars() 的行為類(lèi)似 locals()。 請注意，locals 字典僅對于讀取起作用，因為對 locals 字典的更新會(huì )被忽略。

如果指定了一個(gè)對象但它沒(méi)有 __dict__ 屬性（例如，當它所屬的類(lèi)定義了 __slots__ 屬性時(shí)）則會(huì )引發(fā) TypeError 異常。

zip(*iterables, strict=False)?

在多個(gè)迭代器上并行迭代，從每個(gè)迭代器返回一個(gè)數據項組成元組。

示例:

>>>

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

更正式的說(shuō)法： zip() 返回元組的迭代器，其中第 i 個(gè)元組包含的是每個(gè)參數迭代器的第 i 個(gè)元素。

不妨換一種方式認識 zip() ：它會(huì )把行變成列，把列變成行。這類(lèi)似于 矩陣轉置 。

zip() 是延遲執行的：直至迭代時(shí)才會(huì )對元素進(jìn)行處理，比如 for 循環(huán)或放入 list 中。

值得考慮的是，傳給 zip() 的可迭代對象可能長(cháng)度不同；有時(shí)是有意為之，有時(shí)是因為準備這些對象的代碼存在錯誤。Python 提供了三種不同的處理方案：

• 默認情況下，zip() 在最短的迭代完成后停止。較長(cháng)可迭代對象中的剩余項將被忽略，結果會(huì )裁切至最短可迭代對象的長(cháng)度：

  >>>

  >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
  [(0, 'fee'), (1, 'fi'), (2, 'fo')]
  

• 通常 zip() 用于可迭代對象等長(cháng)的情況下。這時(shí)建議用 strict=True 的選項。輸出與普通的 zip() 相同：。

  >>>

  >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
  [('a', 1), ('b', 2), ('c', 3)]
  

  與默認行為不同的是，它會(huì )檢查可迭代對象的長(cháng)度是否相同，如果不相同則觸發(fā) ValueError 。

  >>>

  >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True))
  Traceback (most recent call last):
    ...
  ValueError: zip() argument 2 is longer than argument 1
  

  如果未指定 strict=True 參數，所有導致可迭代對象長(cháng)度不同的錯誤都會(huì )被抑制，這可能會(huì )在程序的其他地方表現為難以發(fā)現的錯誤。

• 為了讓所有的可迭代對象具有相同的長(cháng)度，長(cháng)度較短的可用常量進(jìn)行填充。這可由 itertools.zip_longest() 來(lái)完成。

極端例子是只有一個(gè)可迭代對象參數，zip() 會(huì )返回一個(gè)一元組的迭代器。如果未給出參數，則返回一個(gè)空的迭代器。

小技巧：

• 可確保迭代器的求值順序是從左到右的。這樣就能用 zip(*[iter(s)]*n, strict=True) 將數據列表按長(cháng)度 n 進(jìn)行分組。這將重復 相同 的迭代器 n 次，輸出的每個(gè)元組都包含 n 次調用迭代器的結果。這樣做的效果是把輸入拆分為長(cháng)度為 n 的塊。

• zip() 與 * 運算符相結合可以用來(lái)拆解一個(gè)列表:

  >>>

  >>> x = [1, 2, 3]
  >>> y = [4, 5, 6]
  >>> list(zip(x, y))
  [(1, 4), (2, 5), (3, 6)]
  >>> x2, y2 = zip(*zip(x, y))
  >>> x == list(x2) and y == list(y2)
  True
  

在 3.10 版更改: 增加了 strict 參數。

__import__(name, globals=None, locals=None, fromlist=(), level=0)?

備注

與 importlib.import_module() 不同，這是一個(gè)日常 Python 編程中不需要用到的高級函數。

此函數會(huì )由 import 語(yǔ)句發(fā)起調用。 它可以被替換 (通過(guò)導入 builtins 模塊并賦值給 builtins.__import__) 以便修改 import 語(yǔ)句的語(yǔ)義，但是 強烈 不建議這樣做，因為使用導入鉤子 (參見(jiàn) PEP 302) 通常更容易實(shí)現同樣的目標，并且不會(huì )導致代碼問(wèn)題，因為許多代碼都會(huì )假定所用的是默認實(shí)現。 同樣也不建議直接使用 __import__() 而應該用 importlib.import_module()。

本函數會(huì )導入模塊 name，利用 globals 和 locals 來(lái)決定如何在包的上下文中解釋該名稱(chēng)。fromlist 給出了應從 name 模塊中導入的對象或子模塊的名稱(chēng)。標準的實(shí)現代碼完全不會(huì )用到 locals 參數，只用到了 globals 用于確定 import 語(yǔ)句所在的包上下文。

level 指定是使用絕對還是相對導入。 0 (默認值) 意味著(zhù)僅執行絕對導入。 level 為正數值表示相對于模塊調用 __import__() 的目錄，將要搜索的父目錄層數 (詳情參見(jiàn) PEP 328)。

當 name 變量的形式為 package.module 時(shí)，通常將會(huì )返回最高層級的包（第一個(gè)點(diǎn)號之前的名稱(chēng)），而 不是 以 name 命名的模塊。 但是，當給出了非空的 fromlist 參數時(shí)，則將返回以 name 命名的模塊。

例如，語(yǔ)句 import spam 的結果將為與以下代碼作用相同的字節碼:

spam = __import__('spam', globals(), locals(), [], 0)

語(yǔ)句 import spam.ham 的結果將為以下調用:

spam = __import__('spam.ham', globals(), locals(), [], 0)

請注意在這里 __import__() 是如何返回頂層模塊的，因為這是通過(guò) import 語(yǔ)句被綁定到特定名稱(chēng)的對象。

另一方面，語(yǔ)句 from spam.ham import eggs, sausage as saus 的結果將為

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

在這里， spam.ham 模塊會(huì )由 __import__() 返回。 要導入的對象將從此對象中提取并賦值給它們對應的名稱(chēng)。

如果您只想按名稱(chēng)導入模塊（可能在包中），請使用 importlib.import_module()

在 3.3 版更改: level 的值不再支持負數（默認值也修改為0）。

在 3.9 版更改: 當使用了命令行參數 -E 或 -I 時(shí)，環(huán)境變量 PYTHONCASEOK 現在將被忽略。

備注

1

解析器只接受 Unix 風(fēng)格的行結束符。如果您從文件中讀取代碼，請確保用換行符轉換模式轉換 Windows 或 Mac 風(fēng)格的換行符。