內置函數

Python 解釋器內置了很多函數和類型，您可以在任何時候使用它們。以下按字母表順序列出它們。

		內置函數
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

abs(x)

返回一個數的絕對值。實參可以是整數或浮點數。如果實參是一個復數，返回它的模。

all(iterable)

如果 iterable 的所有元素為真（或迭代器為空），返回 True 。等價于:

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

any(iterable)

如果 iterable 的任一元素為真則返回 True。 如果迭代器為空，返回 False。 等價于:

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

ascii(object)

與 repr() 類似，返回一個包含對象的可打印表示形式的字符串，但是使用 \x、\u 和 \U 對 repr() 返回的字符串中非 ASCII 編碼的字符進行轉義。 生成的字符串和 Python 2 的 repr() 返回的結果相似。

bin(x)

將一個整數轉變為一個前綴為“0b”的二進制字符串。結果是一個合法的 Python 表達式。如果 x 不是 Python 的 int 對象，那它需要定義 __index__() 方法返回一個整數。一些例子：

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

如果不一定需要前綴“0b”，還可以使用如下的方法。

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

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

class bool([x])

返回一個布爾值，True 或者 False。 x 使用標準的 真值測試過程 來轉換。 如果 x 是假值或者被省略，返回 False；其他情況返回 True。 bool 類是 int 的子類（參見 數字類型 --- int, float, complex ）。其他類不能繼承自它。它只有 False 和 True 兩個實例（參見 布爾值 ）。

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

breakpoint(*args, **kws)

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

3.7 新版功能.

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

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

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

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

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

• 如果是一個符合 buffer 接口的對象，該對象的只讀 buffer 會用來初始化字節數組。

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

如果沒有實參，則創建大小為 0 的數組。

另見 二進制序列類型 --- bytes, bytearray, memoryview 和 bytearray 對象。

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

返回一個新的“bytes”對象， 是一個不可變序列，包含范圍為 0 <= x < 256 的整數。bytes 是 bytearray 的不可變版本 - 它有其中不改變序列的方法和相同的索引、切片操作。

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

字節對象還可以用字面值創建，參見 字符串和字節串字面值。

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

callable(object)

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

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

chr(i)

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

實參的合法范圍是 0 到 1,114,111（16 進制表示是 0x10FFFF）。如果 i 超過這個范圍，會觸發 ValueError 異常。

@classmethod

把一個方法封裝成類方法。

一個類方法把類自己作為第一個實參，就像一個實例方法把實例自己作為第一個實參。請用以下習慣來聲明類方法:

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

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

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

類方法與 C++ 或 Java 中的靜態方法不同。 如果你需要后者，請參閱 staticmethod()。

想了解更多有關類方法的信息，請參閱 標準類型層級結構 。

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

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

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

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

可選參數 flags 和 dont_inherit 控制在編譯 source 時要用到哪個 future 語句。 如果兩者都未提供（或都為零）則會使用調用 compile() 的代碼中有效的 future 語句來編譯代碼。 如果給出了 flags 參數但沒有 dont_inherit (或是為零) 則 flags 參數所指定的 以及那些無論如何都有效的 future 語句會被使用。 如果 dont_inherit 為一個非零整數，則只使用 flags 參數 -- 在調用外圍有效的 future 語句將被忽略。

Future 語句使用比特位來指定，多個語句可以通過按位或來指定。具體特性的比特位可以通過 __future__ 模塊中的 _Feature 類的實例的 compiler_flag 屬性來獲得。

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

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

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

注解

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

警告

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

在 3.2 版更改: 允許使用 Windows 和 Mac 的換行符。在 'exec' 模式不再需要以換行符結尾。增加了 optimize 形參。

在 3.5 版更改: 之前 source 中包含 null 字節的話會觸發 TypeError 異常。

class complex([real[, imag]])

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

注解

當從字符串轉換時，字符串在 + 或 - 的周圍必須不能有空格。例如 complex('1+2j') 是合法的，但 complex('1 + 2j') 會觸發 ValueError 異常。

數字類型 --- int, float, complex 描述了復數類型。

在 3.6 版更改: 您可以使用下劃線將代碼文字中的數字進行分組。

delattr(object, name)

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

創建一個新的字典。dict 對象是一個字典類。參見 dict 和 映射類型 --- dict 了解這個類。

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

dir([object])

如果沒有實參，則返回當前本地作用域中的名稱列表。如果有實參，它會嘗試返回該對象的有效屬性列表。

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

如果對象不提供 __dir__()，這個函數會嘗試從對象已定義的 __dict__ 屬性和類型對象收集信息。結果列表并不總是完整的，如果對象有自定義 __getattr__()，那結果可能不準確。

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

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

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

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

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

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

注解

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

divmod(a, b)

它將兩個（非復數）數字作為實參，并在執行整數除法時返回一對商和余數。對于混合操作數類型，適用雙目算術運算符的規則。對于整數，結果和 (a // b, a % b) 一致。對于浮點數，結果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能會比 1 小。在任何情況下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符號和 b 一樣，并且 0 <= abs(a % b) < abs(b) 。

enumerate(iterable, start=0)

返回一個枚舉對象。iterable 必須是一個序列，或 iterator，或其他支持迭代的對象。 enumerate() 返回的迭代器的 __next__() 方法返回一個元組，里面包含一個計數值（從 start 開始，默認為 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')]

等價于:

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

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

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

expression 參數會作為一個 Python 表達式（從技術上說是一個條件列表）被解析并求值，使用 globals 和 locals 字典作為全局和局部命名空間。 如果 globals 字典存在且不包含以 __builtins__ 為鍵的值，則會在解析 expression 之前插入以此為鍵的對內置模塊 builtins 的字典的引用。 這意味著 expression 通常具有對標準 builtins 模塊的完全訪問權限且受限的環境會被傳播。 如果省略 locals 字典則其默認值為 globals 字典。 如果兩個字典同時省略，表達式會在 eval() 被調用的環境中執行。 返回值為表達式求值的結果。 語法錯誤將作為異常被報告。 例如:

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

這個函數也可以用來執行任何代碼對象（如 compile() 創建的）。這種情況下，參數是代碼對象，而不是字符串。如果編譯該對象時的 mode 實參是 'exec' 那么 eval() 返回值為 None 。

提示： exec() 函數支持動態執行語句。 globals() 和 locals() 函數各自返回當前的全局和本地字典，因此您可以將它們傳遞給 eval() 或 exec() 來使用。

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

exec(object[, globals[, locals]])

這個函數支持動態執行 Python 代碼。object 必須是字符串或者代碼對象。如果是字符串，那么該字符串將被解析為一系列 Python 語句并執行（除非發生語法錯誤）。1 如果是代碼對象，它將被直接執行。在任何情況下，被執行的代碼都需要和文件輸入一樣是有效的（見參考手冊中關于文件輸入的章節）。請注意即使在傳遞給 exec() 函數的代碼的上下文中，return 和 yield 語句也不能在函數定義之外使用。該函數返回值是 None 。

無論哪種情況，如果省略了可選參數，代碼將在當前范圍內執行。如果提供了 globals 參數，就必須是字典類型，而且會被用作全局和本地變量。如果同時提供了 globals 和 locals 參數，它們分別被用作全局和本地變量。如果提供了 locals 參數，則它可以是任何映射型的對象。請記住在模塊層級，全局和本地變量是相同的字典。如果 exec 有兩個不同的 globals 和 locals 對象，代碼就像嵌入在類定義中一樣執行。

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

注解

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

注解

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

filter(function, iterable)

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

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

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

class float([x])

返回從數字或字符串 x 生成的浮點數。

如果實參是字符串，則它必須是包含十進制數字的字符串，字符串前面可以有符號，之前也可以有空格。可選的符號有 '+' 和 '-' ； '+' 對創建的值沒有影響。實參也可以是 NaN（非數字）、正負無窮大的字符串。確切地說，除去首尾的空格后，輸入必須遵循以下語法：

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

這里， floatnumber 是 Python 浮點數的字符串形式，詳見 浮點數字面值。字母大小寫都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正無窮大。

另一方面，如果實參是整數或浮點數，則返回具有相同值（在 Python 浮點精度范圍內）的浮點數。如果實參在 Python 浮點精度范圍外，則會觸發 OverflowError。

對于一般的 Python 對象 x ， float(x) 指派給 x.__float__() 。

如果沒有實參，則返回 0.0 。

示例:

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

數字類型 --- int, float, complex 描述了浮點類型。

在 3.6 版更改: 您可以使用下劃線將代碼文字中的數字進行分組。

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

format(value[, format_spec])

將 value 轉換為 format_spec 控制的“格式化”表示。format_spec 的解釋取決于 value 實參的類型，但是大多數內置類型使用標準格式化語法：格式規格迷你語言。

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

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

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

class frozenset([iterable])

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

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

getattr(object, name[, default])

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

globals()

返回表示當前全局符號表的字典。這總是當前模塊的字典（在函數或方法中，不是調用它的模塊，而是定義它的模塊）。

hasattr(object, name)

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

hash(object)

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

注解

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

help([object])

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

請注意如果在函數的形參列表中出現了斜杠 (/)，則它在發起調用 help() 的時候意味著斜杠之前的均為僅限位置形參。 更多相關信息，請參閱 有關僅限位置形參的 FAQ 條目。

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

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

hex(x)

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

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

如果要將整數轉換為大寫或小寫的十六進制字符串，并可選擇有無“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() 將十六進制字符串轉換為以 16 為基數的整數。

注解

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

id(object)

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

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

input([prompt])

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

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

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

class int([x])

class int(x, base=10)

返回一個使用數字或字符串 x 生成的整數對象，或者沒有實參的時候返回 0 。如果 x 定義了 __int__()，int(x) 返回 x.__int__() 。如果 x 定義了 __trunc__()，它返回 x.__trunc__() 。對于浮點數，它向零舍入。

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

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

在 3.4 版更改: 如果 base 不是 int 的實例，但 base 對象有 base.__index__ 方法，則會調用該方法來獲取進制數。以前的版本使用 base.__int__ 而不是 base.__index__。

在 3.6 版更改: 您可以使用下劃線將代碼文字中的數字進行分組。

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

isinstance(object, classinfo)

如果參數 object 是參數 classinfo 的實例或者是其 (直接、間接或 虛擬) 子類則返回 True。 如果 object 不是給定類型的對象，函數將總是返回 False。 如果 classinfo 是類型對象元組（或由其他此類元組遞歸組成的元組），那么如果 object 是其中任何一個類型的實例就返回 True。 如果 classinfo 既不是類型，也不是類型元組或類型元組的元組，則將引發 TypeError 異常。

issubclass(class, classinfo)

如果 class 是 classinfo 的 (直接、間接或 虛擬) 子類則返回 True。 類會被視作其自身的子類。 classinfo 也以是類對象的元組，在此情況下 classinfo 中的每個條目都將被檢查。 在任何其他情況下，都將引發 TypeError 異常。

iter(object[, sentinel])

返回一個 iterator 對象。根據是否存在第二個實參，第一個實參的解釋是非常不同的。如果沒有第二個實參，object 必須是支持迭代協議（有 __iter__() 方法）的集合對象，或必須支持序列協議（有 __getitem__() 方法，且數字參數從 0 開始）。如果它不支持這些協議，會觸發 TypeError。如果有第二個實參 sentinel，那么 object 必須是可調用的對象。這種情況下生成的迭代器，每次迭代調用它的 __next__() 方法時都會不帶實參地調用 object；如果返回的結果是 sentinel 則觸發 StopIteration，否則返回調用結果。

另請參閱 迭代器類型。

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

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)

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

class list([iterable])

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

locals()

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

注解

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

map(function, iterable, ...)

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

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

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

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

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

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

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

3.4 新版功能: keyword-only 實參 default 。

class memoryview(obj)

返回由給定實參創建的“內存視圖”對象。有關詳細信息，請參閱 內存視圖。

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

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

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

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

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

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

3.4 新版功能: keyword-only 實參 default 。

next(iterator[, default])

通過調用 iterator 的 __next__() 方法獲取下一個元素。如果迭代器耗盡，則返回給定的 default，如果沒有默認值則觸發 StopIteration。

class object

返回一個沒有特征的新對象。object 是所有類的基類。它具有所有 Python 類實例的通用方法。這個函數不接受任何實參。

注解

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

oct(x)

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

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

如果要將整數轉換為八進制字符串，并可選擇有無“0o”前綴，則可以使用如下方法：

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

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

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

打開 file 并返回對應的 file object。如果該文件不能打開，則觸發 OSError。

file 是一個 path-like object，表示將要打開的文件的路徑（絕對路徑或者當前工作目錄的相對路徑），也可以是要被封裝的整數類型文件描述符。（如果是文件描述符，它會隨著返回的 I/O 對象關閉而關閉，除非 closefd 被設為 False 。）

mode 是一個可選字符串，用于指定打開文件的模式。默認值是 'r' ，這意味著它以文本模式打開并讀取。其他常見模式有：寫入 'w' （截斷已經存在的文件）；排它性創建 'x' ；追加寫 'a' （在 一些 Unix 系統上，無論當前的文件指針在什么位置，所有 寫入都會追加到文件末尾）。在文本模式，如果 encoding 沒有指定，則根據平臺來決定使用的編碼：使用 locale.getpreferredencoding(False) 來獲取本地編碼。（要讀取和寫入原始字節，請使用二進制模式并不要指定 encoding。）可用的模式有：

字符	含義
'r'	讀取（默認）
'w'	寫入，并先截斷文件
'x'	排它性創建，如果文件已存在則失敗
'a'	寫入，如果文件存在則在末尾追加
'b'	二進制模式
't'	文本模式（默認）
'+'	更新磁盤文件（讀取并寫入）

默認的模式是 'r' （打開并讀取文本，同 'rt' ）。對于二進制寫入， 'w+b' 模式打開并把文件截斷成 0 字節； 'r+b' 則不會截斷。

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

此外還允許使用一個模式字符 'U'，該字符已不再具有任何效果，并被視為已棄用。 之前它會在文本模式中啟用 universal newlines，這在 Python 3.0 中成為默認行為。 請參閱 newline 形參的文檔了解更多細節。

注解

Python不依賴于底層操作系統的文本文件概念;所有處理都由Python本身完成，因此與平臺無關。

buffering 是一個可選的整數，用于設置緩沖策略。傳遞0以切換緩沖關閉（僅允許在二進制模式下），1選擇行緩沖（僅在文本模式下可用），并且>1的整數以指示固定大小的塊緩沖區的大小（以字節為單位）。如果沒有給出 buffering 參數，則默認緩沖策略的工作方式如下:

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

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

encoding 是用于解碼或編碼文件的編碼的名稱。這應該只在文本模式下使用。默認編碼是依賴于平臺的（不 管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有關支持的編碼列表，請參閱 codecs 模塊。

errors 是一個可選的字符串參數，用于指定如何處理編碼和解碼錯誤 - 這不能在二進制模式下使用。可以使用各種標準錯誤處理程序（列在 錯誤處理方案 ），但是使用 codecs.register_error() 注冊的任何錯誤處理名稱也是有效的。標準名稱包括:

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

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

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

• 'surrogateescape' 將表示任何不正確的字節作為Unicode專用區中的代碼點，范圍從U+DC80到U+DCFF。當在寫入數據時使用 surrogateescape 錯誤處理程序時，這些私有代碼點將被轉回到相同的字節中。這對于處理未知編碼的文件很有用。

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

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

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

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

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

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

如果 closefd 是 False 并且給出了文件描述符而不是文件名，那么當文件關閉時，底層文件描述符將保持打開狀態。如果給出文件名則 closefd 必須為 True （默認值），否則將引發錯誤。

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

新創建的文件是 不可繼承的。

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

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

在 3.3 版更改:

• 增加了 opener 形參。

• 增加了 'x' 模式。

• 過去觸發的 IOError，現在是 OSError 的別名。

• 如果文件已存在但使用了排它性創建模式（ 'x' ），現在會觸發 FileExistsError。

在 3.4 版更改:

• 文件現在禁止繼承。

Deprecated since version 3.4, will be removed in version 3.9: 'U' 模式。

在 3.5 版更改:

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

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

在 3.6 版更改:

• 增加對實現了 os.PathLike 對象的支持。

• 在 Windows 上，打開一個控制臺緩沖區將返回 io.RawIOBase 的子類，而不是 io.FileIO。

ord(c)

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

pow(x, y[, z])

返回 x 的 y 次冪；如果 z 存在，則對 z 取余（比直接 pow(x, y) % z 計算更高效）。兩個參數形式的 pow(x, y) 等價于冪運算符： x**y。

參數必須為數值類型。 對于混用的操作數類型，則適用二元算術運算符的類型強制轉換規則。 對于 int 操作數，結果具有與操作數相同的類型（轉換后），除非第二個參數為負值；在這種情況下，所有參數將被轉換為浮點數并輸出浮點數結果。 例如，10**2 返回 100，但 10**-2 返回 0.01。 如果第二個參數為負值，則第三個參數必須省略。 如果存在 z，則 x 和 y 必須為整數類型，且 y 必須為非負數。

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

將 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它們必須以關鍵字參數的形式給出。

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

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

輸出是否被緩存通常決定于 file，但如果 flush 關鍵字參數為真值，流會被強制刷新。

在 3.3 版更改: 增加了 flush 關鍵字參數。

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

返回 property 屬性。

fget 是獲取屬性值的函數。 fset 是用于設置屬性值的函數。 fdel 是用于刪除屬性值的函數。并且 doc 為屬性對象創建文檔字符串。

一個典型的用法是定義一個托管屬性 x:

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

如果 c 是 C 的實例，c.x 將調用getter，c.x = value 將調用setter， del c.x 將調用deleter。

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

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

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

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

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

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

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

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

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

上述代碼與第一個例子完全等價。 注意一定要給附加函數與原始的特征屬性相同的名稱 (在本例中為 x。)

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

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

class range(stop)

class range(start, stop[, step])

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

repr(object)

返回包含一個對象的可打印表示形式的字符串。 對于許多類型來說，該函數會嘗試返回的字符串將會與該對象被傳遞給 eval() 時所生成的對象具有相同的值，在其他情況下表示形式會是一個括在尖括號中的字符串，其中包含對象類型的名稱與通常包括對象名稱和地址的附加信息。 類可以通過定義 __repr__() 方法來控制此函數為它的實例所返回的內容。

reversed(seq)

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

round(number[, ndigits])

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

對于支持 round() 的內置類型，值會被舍入到最接近的 10 的負 ndigits 次冪的倍數；如果與兩個倍數的距離相等，則選擇偶數 (因此，round(0.5) 和 round(-0.5) 均為 0 而 round(1.5) 為 2)。 任何整數值都可作為有效的 ndigits (正數、零或負數)。 如果 ndigits 被省略或為 None 則返回值將為整數。 否則返回值與 number 的類型相同。

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

注解

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

class set([iterable])

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

有關其他容器請參看內置的 frozenset, list, tuple 和 dict 類，以及 collections 模塊。

setattr(object, name, value)

此函數與 getattr() 兩相對應。 其參數為一個對象、一個字符串和一個任意值。 字符串指定一個現有屬性或者新增屬性。 函數會將值賦給該屬性，只要對象允許這種操作。 例如，setattr(x, 'foobar', 123) 等價于 x.foobar = 123。

class slice(stop)

class slice(start, stop[, step])

返回一個表示由 range(start, stop, step) 所指定索引集的 slice 對象。 其中 start 和 step 參數默認為 None。 切片對象具有僅會返回對應參數值（或其默認值）的只讀數據屬性 start, stop 和 step。 它們沒有其他的顯式功能；不過它們會被 NumPy 以及其他第三方擴展所使用。 切片對象也會在使用擴展索引語法時被生成。 例如: a[start:stop:step] 或 a[start:stop, i]。 請參閱 itertools.islice() 了解返回迭代器的一種替代版本。

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

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

具有兩個可選參數，它們都必須指定為關鍵字參數。

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

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

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

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

有關排序示例和簡要排序教程，請參閱 排序指南 。

@staticmethod

將方法轉換為靜態方法。

靜態方法不會接收隱式的第一個參數。要聲明一個靜態方法，請使用此語法

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

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

靜態方法的調用可以在類上進行 (例如 C.f()) 也可以在實例上進行 (例如 C().f())。

Python中的靜態方法與Java或C ++中的靜態方法類似。另請參閱 classmethod() ，用于創建備用類構造函數的變體。

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

class C:
    builtin_open = staticmethod(open)

想了解更多有關靜態方法的信息，請參閱 標準類型層級結構 。

class str(object='')

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

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

str 是內置字符串 class 。更多關于字符串的信息查看 文本序列類型 --- str。

sum(iterable[, start])

從 start 開始自左向右對 iterable 中的項求和并返回總計值。 start 默認為 0。 iterable 的項通常為數字，開始值則不允許為字符串。

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

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

返回一個代理對象，它會將方法調用委托給 type 指定的父類或兄弟類。 這對于訪問已在類中被重載的繼承方法很有用。 搜索順序與 getattr() 所使用的相同，只是 type 指定的類型本身會被跳過。

type 的 __mro__ 屬性列出了 getattr() 和 super() 所使用的方法解析順序。 該屬性是動態的，可以在繼承層級結構更新的時候任意改變。

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

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

第二個用例是在動態執行環境中支持協作多重繼承。 此用例為 Python 所獨有，在靜態編譯語言或僅支持單繼承的語言中是不存在的。 這使得實現“菱形圖”成為可能，在這時會有多個基類實現相同的方法。 好的設計強制要求這種方法在每個情況下具有相同的調用簽名（因為調用順序是在運行時確定的，也因為該順序要適應類層級結構的更改，還因為該順序可能包含在運行時之前未知的兄弟類）。

對于以上兩個用例，典型的超類調用看起來是這樣的:

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

除了方法查找之外，super() 也可用于屬性查找。 一個可能的此種用例是在上級或同級類中調用 descriptor。

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

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

對于有關如何使用 super() 來如何設計協作類的實用建議，請參閱 使用 super() 的指南。

class tuple([iterable])

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

class type(object)

class type(name, bases, dict)

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

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

傳入三個參數時，返回一個新的 type 對象。 這在本質上是 class 語句的一種動態形式。 name 字符串即類名并且會成為 __name__ 屬性；bases 元組列出基類并且會成為 __bases__ 屬性；而 dict 字典為包含類主體定義的命名空間并且會被復制到一個標準字典成為 __dict__ 屬性。 例如，下面兩條語句會創建相同的 type 對象:

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

另請參閱 類型對象。

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

vars([object])

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

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

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

zip(*iterables)

創建一個聚合了來自每個可迭代對象中的元素的迭代器。

返回一個元組的迭代器，其中的第 i 個元組包含來自每個參數序列或可迭代對象的第 i 個元素。 當所輸入可迭代對象中最短的一個被耗盡時，迭代器將停止迭代。 當只有一個可迭代對象參數時，它將返回一個單元組的迭代器。 不帶參數時，它將返回一個空迭代器。 相當于:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

函數會保證可迭代對象按從左至右的順序被求值。 使得可以通過 zip(*[iter(s)]*n) 這樣的慣用形式將一系列數據聚類為長度為 n 的分組。 這將重復 同樣的 迭代器 n 次，以便每個輸出的元組具有第 n 次調用該迭代器的結果。 它的作用效果就是將輸入拆分為長度為 n 的數據塊。

當你不用關心較長可迭代對象末尾不匹配的值時，則 zip() 只須使用長度不相等的輸入即可。 如果那些值很重要，則應改用 itertools.zip_longest()。

zip() 與 * 運算符相結合可以用來拆解一個列表:

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

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

注解

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

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

該函數會導入 name 模塊，有可能使用給定的 globals 和 locals 來確定如何在包的上下文中解讀名稱。 fromlist 給出了應該從由 name 指定的模塊導入對象或子模塊的名稱。 標準實現完全不使用其 locals 參數，而僅使用 globals 參數來確定 import 語句的包上下文。

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

當 name 變量的形式為 package.module 時，通常將會返回最高層級的包（第一個點號之前的名稱），而 不是 以 name 命名的模塊。 但是，當給出了非空的 fromlist 參數時，則將返回以 name 命名的模塊。

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

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

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

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

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

另一方面，語句 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 模塊會由 __import__() 返回。 要導入的對象將從此對象中提取并賦值給它們對應的名稱。

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

在 3.3 版更改: Negative values for level are no longer supported (which also changes the default value to 0).

備注

1

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