內(nèi)置函數(shù)?

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

abs(x)?

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

aiter(async_iterable)?

返回 asynchronous iterable 的 asynchronous iterator 。相當(dāng)于調(diào)用 x.__aiter__()。

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

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

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

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

調(diào)用 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() 類似，返回一個(gè)字符串，表示對象的可打印形式，但在 repr() 返回的字符串中，非 ASCII 字符會(huì)用 \x、\u 和 \U 進(jìn)行轉(zhuǎn)義。生成的字符串類似于 Python 2 中 repr() 的返回結(jié)果。

bin(x)?

將整數(shù)轉(zhuǎn)變?yōu)橐浴?b”前綴的二進(jìn)制字符串。結(jié)果是一個(gè)合法的 Python 表達(dá)式。如果 x 不是 Python 的 int 對象，它必須定義 __index__() 方法，以便返回整數(shù)值。下面是一些例子：

>>>

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

若要控制是否顯示前綴“0b”，可以采用以下兩種方案：

>>>

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

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

class bool([x])?

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

在 3.7 版更改: x 現(xiàn)在只能作為位置參數(shù)。

breakpoint(*args, **kws)?

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

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

3.7 新版功能.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

callable(object)?

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

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

chr(i)?

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

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

@classmethod?

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

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

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

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

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

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

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

在 3.10 版更改: 類方法現(xiàn)在繼承了方法的屬性（__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() 執(zhí)行。source 可以是常規(guī)的字符串、字節(jié)字符串，或者 AST 對象。參見 ast 模塊的文檔了解如何使用 AST 對象。

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

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

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

編譯器選項(xiàng)和 future 語句是由比特位來指明的。 比特位可以通過一起按位 OR 來指明多個(gè)選項(xiàng)。 指明特定 future 特性所需的比特位可以在 __future__ 模塊的 _Feature 實(shí)例的 compiler_flag 屬性中找到。 編譯器旗標(biāo) 可以在 ast 模塊中查找?guī)в?PyCF_ 前綴的名稱。

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

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

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

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

備注

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

警告

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

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

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

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

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

返回值為 real + imag*1j 的復(fù)數(shù)，或?qū)⒆址驍?shù)字轉(zhuǎn)換為復(fù)數(shù)。如果第一個(gè)形參是字符串，則它被解釋為一個(gè)復(fù)數(shù)，并且函數(shù)調(diào)用時(shí)必須沒有第二個(gè)形參。第二個(gè)形參不能是字符串。每個(gè)實(shí)參都可以是任意的數(shù)值類型（包括復(fù)數(shù)）。如果省略了 imag，則默認(rèn)值為零，構(gòu)造函數(shù)會(huì)像 int 和 float 一樣進(jìn)行數(shù)值轉(zhuǎn)換。如果兩個(gè)實(shí)參都省略，則返回 0j。

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

備注

當(dāng)從字符串轉(zhuǎn)換時(shí)，字符串在 + 或 - 的周圍必須不能有空格。例如 complex('1+2j') 是合法的，但 complex('1 + 2j') 會(huì)觸發(fā) ValueError 異常。

數(shù)字類型 --- int, float, complex 描述了復(fù)數(shù)類型。

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

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

delattr(object, name)?

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir([object])?

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

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

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

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

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

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

• 否則，列表包含對象的屬性名稱，它的類屬性名稱，并且遞歸查找它的類的所有基類的屬性。

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

>>>

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

備注

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

divmod(a, b)?

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

enumerate(iterable, start=0)?

返回一個(gè)枚舉對象。iterable 必須是一個(gè)序列，或 iterator，或其他支持迭代的對象。 enumerate() 返回的迭代器的 __next__() 方法返回一個(gè)元組，里面包含一個(gè)計(jì)數(shù)值（從 start 開始，默認(rèn)為 0）和通過迭代 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 可以是任何映射對象。

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

返回值就是表達(dá)式的求值結(jié)果。 語法錯(cuò)誤將作為異常被報(bào)告。 例如：

>>>

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

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

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

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

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

引發(fā)一個(gè) 審計(jì)事件 exec 附帶參數(shù) 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.

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

如果 globals 字典不包含 __builtins__ 鍵值，則將為該鍵插入對內(nèi)建 builtins 模塊字典的引用。因此，在將執(zhí)行的代碼傳遞給 exec() 之前，可以通過將自己的 __builtins__ 字典插入到 globals 中來控制可以使用哪些內(nè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è) 審計(jì)事件 exec 附帶參數(shù) code_object。

備注

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

備注

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

在 3.11 版更改: Added the closure parameter.

filter(function, iterable)?

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

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

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

class float([x])?

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

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

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

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

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

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

如果沒有實(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

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

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

在 3.7 版更改: x 現(xiàn)在只能作為位置參數(shù)。

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

format(value[, format_spec])?

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

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

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

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

class frozenset([iterable])

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

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

getattr(object, name[, default])?

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

備注

由于 私有名稱混合 發(fā)生在編譯時(shí)，因此必須 手動(dòng)混合私有屬性（以兩個(gè)下劃線打頭的屬性）名稱以使使用 getattr() 來提取它。

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è)字符串。如果字符串是對象的屬性之一的名稱，則返回 True，否則返回 False。（此功能是通過調(diào)用 getattr(object, name) 看是否有 AttributeError 異常來實(shí)現(xiàn)的。）

hash(object)?

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

備注

如果對象實(shí)現(xiàn)了自己的 __hash__() 方法，請注意，hash() 根據(jù)機(jī)器的字長來截?cái)喾祷刂怠Ａ碚垍㈤?__hash__()。

help([object])?

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

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

該函數(shù)通過 site 模塊加入到內(nèi)置命名空間。

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

hex(x)?

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

>>>

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

如果要將整數(shù)轉(zhuǎn)換為大寫或小寫的十六進(jìn)制字符串，并可選擇有無“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')

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

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

備注

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

id(object)?

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

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

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

input([prompt])?

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

>>>

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

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

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

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

class int([x])?

class int(x, base=10)

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

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

整數(shù)類型定義請參閱 數(shù)字類型 --- int, float, complex 。

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

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

在 3.7 版更改: x 現(xiàn)在只能作為位置參數(shù)。

在 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 類型 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 類型。

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 類型, 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 類型。

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.

另請參閱 迭代器類型。

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

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)?

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

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

class list([iterable])

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

locals()?

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

備注

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

map(function, iterable, ...)?

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

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

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

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

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

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

如果有多個(gè)最大元素，則此函數(shù)將返回第一個(gè)找到的。這和其他穩(wěn)定排序工具如 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)建的“內(nèi)存視圖”對象。有關(guān)詳細(xì)信息，請參閱 內(nèi)存視圖。

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

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

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

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

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

如果有多個(gè)最小元素，則此函數(shù)將返回第一個(gè)找到的。這和其他穩(wěn)定排序工具如 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 是所有類的基類。它帶有所有 Python 類實(shí)例均通用的方法。本函數(shù)不接受任何參數(shù)。

備注

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

oct(x)?

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

>>>

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

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

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

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

file 是一個(gè) path-like object，表示將要打開的文件的路徑（絕對路徑或者相對當(dāng)前工作目錄的路徑），也可以是要封裝文件對應(yīng)的整數(shù)類型文件描述符。（如果給出的是文件描述符，則當(dāng)返回的 I/O 對象關(guān)閉時(shí)它也會(huì)關(guān)閉，除非將 closefd 設(shè)為 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(rèn)）
'w'	寫入，并先截?cái)辔募?/p>
'x'	排它性創(chuàng)建，如果文件已存在則失敗
'a'	打開文件用于寫入，如果文件存在則在末尾追加
'b'	二進(jìn)制模式
't'	文本模式（默認(rèn)）
'+'	打開用于更新（讀取與寫入）

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

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

備注

Python不依賴于底層操作系統(tǒng)的文本文件概念;所有處理都由Python本身完成，因此與平臺(tái)無關(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ā)式方法選擇緩沖區(qū)的大小，嘗試確定底層設(shè)備的“塊大小”或使用 io.DEFAULT_BUFFER_SIZE。在許多系統(tǒng)上，緩沖區(qū)的長度通常為4096或8192字節(jié)。

• “交互式”文本文件（ 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è)可選的字符串參數(shù)，用于指定如何處理編碼和解碼錯(cuò)誤 - 這不能在二進(jìn)制模式下使用。可以使用各種標(biāo)準(zhǔn)錯(cuò)誤處理程序（列在 錯(cuò)誤處理方案 ），但是使用 codecs.register_error() 注冊的任何錯(cuò)誤處理名稱也是有效的。標(biāo)準(zhǔn)名稱包括:

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

• 'ignore' 忽略錯(cuò)誤。請注意，忽略編碼錯(cuò)誤可能會(huì)導(dǎo)致數(shù)據(jù)丟失。

• 'replace' 會(huì)將替換標(biāo)記（例如 '?' ）插入有錯(cuò)誤數(shù)據(jù)的地方。

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

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

• 'backslashreplace' 用Python的反向轉(zhuǎn)義序列替換格式錯(cuò)誤的數(shù)據(jù)。

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

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

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

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

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

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

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

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

>>>

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

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

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

mode 與 flags 參數(shù)可以在原始調(diào)用的基礎(chǔ)上被修改或傳遞。

在 3.3 版更改:

• 增加了 opener 形參。

• 增加了 'x' 模式。

• 過去觸發(fā)的 IOError，現(xiàn)在是 OSError 的別名。

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

在 3.4 版更改:

• 文件現(xiàn)在禁止繼承。

在 3.5 版更改:

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

• 增加了 'namereplace' 錯(cuò)誤處理接口。

在 3.6 版更改:

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

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

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

ord(c)?

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

pow(base, exp[, mod])?

返回 base 的 exp 次冪；如果 mod 存在，則返回 base 的 exp 次冪對 mod 取余（比 pow(base, exp) % mod 更高效）。 兩參數(shù)形式 pow(base, exp) 等價(jià)于乘方運(yùn)算符: 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 操作數(shù) base 和 exp，如果給出 mod，則 mod 必須為整數(shù)類型并且 mod 必須不為零。 如果給出 mod 并且 exp 為負(fù)值，則 base 必須相對于 mod 不可整除。 在這種情況下，將會(huì)返回 pow(inv_base, -exp, mod)，其中 inv_base 為 base 的倒數(shù)對 mod 取余。

下面的例子是 38 的倒數(shù)對 97 取余:

>>>

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

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

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

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

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

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

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

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

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

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

返回 property 屬性。

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

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

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

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

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

特征屬性對象具有 getter, setter 以及 deleter 方法，它們可用作裝飾器來創(chuàng)建該特征屬性的副本，并將相應(yīng)的訪問函數(shù)設(shè)為所裝飾的函數(shù)。 這最好是用一個(gè)例子來解釋:

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à)。 注意一定要給附加函數(shù)與原始的特征屬性相同的名稱 (在本例中為 x。)

返回的特征屬性對象同樣具有與構(gòu)造器參數(shù)相對應(yīng)的屬性 fget, fset 和 fdel。

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

class range(stop)

class range(start, stop[, step])

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

repr(object)?

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

reversed(seq)?

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

round(number[, ndigits])?

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

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

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

備注

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

class set([iterable])

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

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

setattr(object, name, value)?

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

備注

由于 私有名稱混合 發(fā)生在編譯時(shí)，因此必須手動(dòng)混合私有屬性（以兩個(gè)下劃線打頭的屬性）名稱以便使用 setattr() 來設(shè)置它。

class slice(stop)?

class slice(start, stop[, step])

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

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

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

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

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

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

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

內(nèi)置的 sorted() 確保是穩(wěn)定的。 如果一個(gè)排序確保不會(huì)改變比較結(jié)果相等的元素的相對順序就稱其為穩(wěn)定的 --- 這有利于進(jì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)排序示例和簡要排序教程，請參閱 排序指南 。

@staticmethod?

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

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

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

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

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

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

想了解更多有關(guān)靜態(tài)方法的信息，請參閱 標(biāo)準(zhǔn)類型層級結(jié)構(gòu) 。

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

class str(object='')

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

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

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

sum(iterable, /, start=0)?

從 start 開始自左向右對 iterable 的項(xiàng)求和并返回總計(jì)值。 iterable 的項(xiàng)通常為數(shù)字，而 start 值則不允許為字符串。

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

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

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

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

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

舉例來說，如果 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)的，可以在任何繼承層級結(jié)構(gòu)發(fā)生更新的時(shí)候被改變。

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

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

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

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

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

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

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

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

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

class tuple([iterable])

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

class type(object)?

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

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

推薦使用 isinstance() 內(nèi)置函數(shù)來檢測對象的類型，因?yàn)樗鼤?huì)考慮子類的情況。

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

>>>

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

另請參閱 類型對象。

提供給三參數(shù)形式的關(guān)鍵字參數(shù)會(huì)被傳遞給適當(dāng)?shù)脑悪C(jī)制 (通常為 __init_subclass__())，相當(dāng)于類定義中關(guān)鍵字 (除了 metaclass) 的行為方式。

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

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

vars([object])?

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

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

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

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

zip(*iterables, strict=False)?

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

示例:

>>>

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

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

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

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

值得考慮的是，傳給 zip() 的可迭代對象可能長度不同；有時(shí)是有意為之，有時(shí)是因?yàn)闇?zhǔn)備這些對象的代碼存在錯(cuò)誤。Python 提供了三種不同的處理方案：

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

  >>>

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

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

  >>>

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

  與默認(rèn)行為不同的是，它會(huì)檢查可迭代對象的長度是否相同，如果不相同則觸發(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 參數(shù)，所有導(dǎo)致可迭代對象長度不同的錯(cuò)誤都會(huì)被抑制，這可能會(huì)在程序的其他地方表現(xiàn)為難以發(fā)現(xiàn)的錯(cuò)誤。

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

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

小技巧：

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

• zip() 與 * 運(yùn)算符相結(jié)合可以用來拆解一個(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 參數(shù)。

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

備注

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

此函數(shù)會(huì)由 import 語句發(fā)起調(diào)用。 它可以被替換 (通過導(dǎo)入 builtins 模塊并賦值給 builtins.__import__) 以便修改 import 語句的語義，但是 強(qiáng)烈 不建議這樣做，因?yàn)槭褂脤?dǎo)入鉤子 (參見 PEP 302) 通常更容易實(shí)現(xiàn)同樣的目標(biāo)，并且不會(huì)導(dǎo)致代碼問題，因?yàn)樵S多代碼都會(huì)假定所用的是默認(rèn)實(shí)現(xiàn)。 同樣也不建議直接使用 __import__() 而應(yīng)該用 importlib.import_module()。

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

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

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

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

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

語句 import spam.ham 的結(jié)果將為以下調(diào)用:

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

請注意在這里 __import__() 是如何返回頂層模塊的，因?yàn)檫@是通過 import 語句被綁定到特定名稱的對象。

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

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

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

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

在 3.3 版更改: level 的值不再支持負(fù)數(shù)（默認(rèn)值也修改為0）。

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

備注

1

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