官方連結：3.10內建函式

https://docs.python.org/zh-cn/3/library/functions.html

內建函式

Python 直譯器內建了很多函式和型別，任何時候都能使用。以下按字母順序給出列表。

abs(x)

返回一個數的絕對值。 引數可以是整數、浮點數或任何實現了__abs__()的物件。 如果引數是一個複數，則返回它的模。

aiter(async_iterable)

返回asynchronous iterable的asynchronous iterator

。相當於呼叫x.__aiter__()。

aiter(x)本身帶有__aiter__()方法，返回x，所以aiter(aiter(x))與aiter(x)相同。

注意：與iter()不同，aiter()沒有兩個引數的版本。

3.10 新版功能.

all(iterable)

如果iterable的所有元素均為真值（或可迭代物件為空）則返回True。 等價於：

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

awaitableanext(async_iterator[,default])

當進入 await 狀態時，從給定asynchronous iterator返回下一資料項，迭代完畢則返回default。

這是內建函式next()的非同步版本，類似於：

呼叫async_iterator的__anext__()方法，返回一個awaitable。等待返回迭代器的下一個值。若有給出default，則在迭代完畢後會返回給出的值，否則會觸發StopAsyncIteration。

3.10 新版功能.

any(iterable)

如果iterable的任一元素為真值則返回True。 如果可迭代物件為空，返回False。 等價於:

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

ascii(object)

與repr()類似，返回一個字串，表示物件的可列印形式，但在repr()返回的字串中，非 ASCII 字元會用\x、\u和\U進行轉義。生成的字串類似於 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()獲取更多資訊。

classbool([x])

返回布林值，True或False。x用標準的真值測試過程進行轉換。如果x為 False 或省略，則返回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()自動呼叫，以允許進入你想用的偵錯程式。

引發一個審計事件builtins.breakpoint並附帶引數breakpointhook。

3.7 新版功能.

classbytearray([source[,encoding[,errors]]])

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

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

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

• 如果是一個integer，會初始化大小為該數字的陣列，並使用 null 位元組填充。

• 如果是一個遵循緩衝區介面的物件，該物件的只讀緩衝區將被用來初始化位元組陣列。

• 如果是一個iterable可迭代物件，它的元素的範圍必須是0<=x<256的整數，它會被用作陣列的初始內容。

如果沒有實參，則建立大小為 0 的陣列。

另見二進位制序列型別 --- bytes, bytearray, memoryview和bytearray 物件。

classbytes([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()。 有關類方法的更多資訊，請參閱標準型別層級結構。

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

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

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控制應當啟用哪個編譯器選項以及應當允許哪個future 特性。 如果兩者都未提供 (或都為零) 則程式碼會應用與呼叫compile()的程式碼相同的旗標來編譯。 如果給出了flags引數而未給出dont_inherit(或者為零) 則會在無論如何都將被使用的旗標之外還會額外使用flags引數所指定的編譯器選項和 future 語句。 如果dont_inherit為非零整數，則只使用flags引數 -- 外圍程式碼中的旗標 (future 特性和編譯器選項) 會被忽略。

編譯器選項和 future 語句是由位元位來指明的。 位元位可以通過一起按位 OR 來指明多個選項。 指明特定 future 特性所需的位元位可以在__future__模組的_Feature例項的compiler_flag屬性中找到。編譯器旗標可以在ast模組中查詢帶有PyCF_字首的名稱。

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

如果編譯的原始碼不合法，此函式會觸發SyntaxError異常；如果原始碼包含 null 位元組，則會觸發ValueError異常。

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

引發一個審計事件compile附帶引數source,filename。

註解

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

警告

在將足夠大或者足夠複雜的字串編譯成 AST 物件時，Python 直譯器有可能因為 Python AST 編譯器的棧深度限制而崩潰。

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

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

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

classcomplex([real[,imag]])

返回值為real+imag*1j 的複數，或將字串或數字轉換為複數。如果第一個形參是字串，則它被解釋為一個複數，並且函式呼叫時必須沒有第二個形參。第二個形參不能是字串。每個實參都可以是任意的數值型別（包括複數）。如果省略了imag，則預設值為零，建構函式會像int和float一樣進行數值轉換。如果兩個實參都省略，則返回0j。

對於一個普通 Python 物件x，complex(x)會委託給x.__complex__()。 如果__complex__()未定義則將回退至__float__()。 如果__float__()未定義則將回退至__index__()。

註解

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

數字型別 --- int, float, complex描述了複數型別。

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

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

delattr(object,name)

setattr()相關的函式。實參是一個物件和一個字串。該字串必須是物件的某個屬性。如果物件允許，該函式將刪除指定的屬性。例如delattr(x,'foobar')等價於delx.foobar。

classdict(**kwarg)

classdict(mapping,**kwarg)

classdict(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的字典的引用為值的項。 這樣就可以在將globals傳給eval()之前通過向其傳入你自己的__builtins__字典來控制可供被執行程式碼可以使用哪些內建模組。 如果locals字典被省略則它預設為globals字典。 如果兩個字典都被省略，則將使用呼叫eval()的環境中的globals和locals來執行該表示式。 注意，eval()無法訪問閉包環境中的巢狀作用域(非區域性變數)。

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

>>>

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

該函式還可用於執行任意程式碼物件（比如由compile()建立的物件）。 這時傳入的是程式碼物件，而非一個字串了。如果程式碼物件已用引數為mode的'exec'進行了編譯，那麼eval()的返回值將為None。

提示：exec()函式支援語句的動態執行。globals()和locals()函式分別返回當前的全域性和本地字典，可供傳給eval()或exec()使用。

如果給出的源資料是個字串，那麼其前後的空格和製表符將被剔除。

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

引發一個審計事件exec附帶引數code_object。

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

This function supports dynamic execution of Python code.objectmust 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).1If 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 thenonlocal,yield, andreturnstatements may not be used outside of function definitions even within the context of code passed to theexec()function. The return value isNone.

無論在什麼情況下，如果省略了可選部分，程式碼將運行於當前作用域中。如果只提供了globals，則必須為字典物件（而不能是字典的子類），同時用於存放全域性變數和區域性變數。如果提供了globals和locals，則將分別用於全域性變數和區域性變數。locals可以是任意字典對映物件。請記住，在模組級別，globals 和 locals 是同一個字典。如果 exec 獲得兩個獨立的物件作為globals和locals，程式碼執行起來就像嵌入到某個類定義中一樣。

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

引發一個審計事件exec附帶引數code_object。

註解

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

註解

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

filter(function,iterable)

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

請注意，filter(function,iterable)相當於一個生成器表示式，當 function 不是None的時候為(itemforiteminiterableiffunction(item))；function 是None的時候為(itemforiteminiterableifitem)。

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

classfloat([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__()。 如果__float__()未定義則將回退至__index__()。

如果沒有實參，則返回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現在只能作為位置引數。

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

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。

classfrozenset([iterable])

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

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

getattr(object,name[,default])

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

註解

由於私有名稱混合發生在編譯時，因此必須 手動混合私有屬性（以兩個下劃線打頭的屬性）名稱以使使用getattr()來提取它。

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不是 Pythonint物件，則必須定義返回整數的__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.

引發一個審計事件builtins.id，附帶引數id。

input([prompt])

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

>>>

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

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

引發一個審計事件builtins.input附帶引數prompt。

在成功讀取輸入之後引發一個審計事件builtins.input/result附帶結果。

classint([x])

classint(x,base=10)

返回一個基於數字或字串x構造的整數物件，或者在未給出引數時返回0。 如果x定義了__int__()，int(x)將返回x.__int__()。 如果x定義了__index__()，它將返回x.__index__()。 如果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現在只能作為位置引數。

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

isinstance(object,classinfo)

如果object引數是classinfo引數的例項，或其（直接、間接或virtual）子類的例項，則返回True。 如果object不是給定型別的物件，則總是返回False。如果classinfo是型別物件的元組（或由該類元組遞迴生成）或多個型別的union 型別，那麼當object是其中任一型別的例項時就會返回True。如果classinfo不是某個型別或型別元組，將會觸發TypeError異常。

在 3.10 版更改:classinfo可以是一個union 型別。

issubclass(class,classinfo)

ReturnTrueifclassis a subclass (direct, indirect, orvirtual) ofclassinfo. A class is considered a subclass of itself.classinfomay be a tuple of class objects or aunion 型別, in which case returnTrueifclassis a subclass of any entry inclassinfo. In any other case, aTypeErrorexception is raised.

在 3.10 版更改:classinfo可以是一個union 型別。

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 等）。

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

classlist([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。

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

classmemoryview(object)

返回由給定實參建立的“記憶體檢視”物件。有關詳細資訊，請參閱記憶體檢視。

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。

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

next(iterator[,default])

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

classobject

返回一個不帶特徵的新物件。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+'和'w+b'模式將開啟檔案並清空內容。而'r+'和'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'將把任何不正確的位元組表示為 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.openasopener時與傳遞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。

引發一個審計事件open附帶引數file,mode,flags。

mode與flags引數可以在原始呼叫的基礎上被修改或傳遞。

在 3.3 版更改:

• 增加了opener形參。

• 增加了'x'模式。

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

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

在 3.4 版更改:

• 檔案現在禁止繼承。

Deprecated since version 3.4, removed in version 3.10:'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(base,exp[,mod])

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

The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. Forintoperands, 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)returns100, butpow(10,-2)returns0.01. For a negative base of typeintorfloatand a non-integral exponent, a complex result is delivered. For example,pow(-9,0.5)returns a value close to3j.

對於int運算元base和exp，如果給出mod，則mod必須為整數型別並且mod必須不為零。 如果給出mod並且exp為負值，則base必須相對於mod不可整除。 在這種情況下，將會返回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現在允許第二個引數為負值，即可以計算倒數的餘數。

在 3.8 版更改:允許關鍵字引數。 之前只支援位置引數。

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關鍵字引數為 True，輸出流會被強制重新整理。

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

classproperty(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，delc.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 版更改:特徵屬性物件的文件字串現在是可寫的。

classrange(stop)

classrange(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。 這不算是程式錯誤：這一結果是由於大多數十進位制小數實際上都不能以浮點數精確地表示。 請參閱浮點算術：爭議和限制瞭解更多資訊。

classset([iterable])

返回一個新的set物件，可以選擇帶有從iterable獲取的元素。set是一個內建型別。 請檢視set和集合型別 --- set, frozenset獲取關於這個類的文件。

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

setattr(object,name,value)

本函式與getattr()相對應。其引數為一個物件、一個字串和一個任意值。字串可以為某現有屬性的名稱，或為新屬性。只要物件允許，函式會將值賦給屬性。如setattr(x,'foobar',123)等價於x.foobar=123。

註解

由於私有名稱混合發生在編譯時，因此必須手動混合私有屬性（以兩個下劃線打頭的屬性）名稱以便使用setattr()來設定它。

classslice(stop)

classslice(start,stop[,step])

返回一個slice物件，代表由range(start,stop,step)指定索引集的切片。 其中引數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()確保是穩定的。 如果一個排序確保不會改變比較結果相等的元素的相對順序就稱其為穩定的 --- 這有利於進行多重排序（例如先按部門、再按薪級排序）。

The sort algorithm uses only<comparisons between items. While defining an__lt__()method will suffice for sorting,PEP 8recommends that all sixrich comparisonsbe implemented. This will help avoid bugs when using the same data with other ordering tools such asmax()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.

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

@staticmethod

將方法轉換為靜態方法。

靜態方法不會接收隱式的第一個引數。要宣告一個靜態方法，請使用此語法

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

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

靜態方法既可以由類中呼叫（如C.f()），也可以由例項中呼叫（如```C().f()``）。此外，還可以作為普通的函式進行呼叫（如``f()``）。

Python 的靜態方法與 Java 或 C++ 類似。另請參閱classmethod()，可用於建立另一種類建構函式。

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

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

在 3.10 版更改:靜態方法繼承了方法的多個屬性（__module__、__name__、__qualname__、__doc__和__annotations__），還擁有一個新的``__wrapped__`` 屬性，並且現在還可以作為普通函式進行呼叫。

classstr(object='')

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

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

str是內建字串class。更多關於字串的資訊檢視文字序列型別 --- str。

sum(iterable,/,start=0)

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

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

在 3.8 版更改:start形參可用關鍵字引數形式來指定。

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

返回一個代理物件，它會將方法呼叫委託給type的父類或兄弟類。 這對於訪問已在類中被過載的繼承方法很有用。

object-or-type確定用於搜尋的method resolution order。 搜尋會從type之後的類開始。

舉例來說，如果object-or-type的__mro__為D->B->C->A->object並且type的值為B，則super()將會搜尋C->A->object。

object-or-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()也可用於屬性查詢。 一個可能的應用場合是在上級或同級類中呼叫描述器。

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

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

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

classtuple([iterable])

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

classtype(object)

classtype(name,bases,dict,**kwds)

傳入一個引數時，返回object的型別。 返回值是一個 type 物件，通常與object.__class__所返回的物件相同。

推薦使用isinstance()內建函式來檢測物件的型別，因為它會考慮子類的情況。

傳入三個引數時，返回一個新的 type 物件。 這在本質上是class語句的一種動態形式，name字串即類名並會成為__name__屬性；bases元組包含基類並會成為__bases__屬性；如果為空則會新增所有類的終極基類object。dict字典包含類主體的屬性和方法定義；它在成為__dict__屬性之前可能會被拷貝或包裝。 下面兩條語句會建立相同的type物件:

>>>

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

另請參閱型別物件。

提供給三引數形式的關鍵字引數會被傳遞給適當的元類機制 (通常為__init_subclass__())，相當於類定義中關鍵字 (除了metaclass) 的行為方式。

另請參閱自定義類建立。

在 3.6 版更改:type的子類如果未過載type.__new__，將不再能使用一個引數的形式來獲取物件的型別。

vars([object])

返回模組、類、例項或任何其它具有__dict__屬性的物件的__dict__屬性。

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

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

如果指定了一個物件但它沒有__dict__屬性（例如，當它所屬的類定義了__slots__屬性時）則會引發TypeError異常。

zip(*iterables,strict=False)

在多個迭代器上並行迭代，從每個迭代器返回一個數據項組成元組。

示例:

>>>

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

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

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

zip()是延遲執行的：直至迭代時才會對元素進行處理，比如for迴圈或放入list中。

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

• 預設情況下，zip()在最短的迭代完成後停止。較長可迭代物件中的剩餘項將被忽略，結果會裁切至最短可迭代物件的長度：

  >>>

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

• 通常zip()用於可迭代物件等長的情況下。這時建議用strict=True的選項。輸出與普通的zip()相同：。

  >>>

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

  與預設行為不同的是，它會檢查可迭代物件的長度是否相同，如果不相同則觸發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引數，所有導致可迭代物件長度不同的錯誤都會被抑制，這可能會在程式的其他地方表現為難以發現的錯誤。

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

極端例子是隻有一個可迭代物件引數，zip()會返回一個一元組的迭代器。如果未給出引數，則返回一個空的迭代器。

小技巧：

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

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

  >>>

  >>> 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()不同，這是一個日常 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命名的模組。

例如，語句importspam的結果將為與以下程式碼作用相同的位元組碼:

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

語句importspam.ham的結果將為以下呼叫:

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

請注意在這裡__import__()是如何返回頂層模組的，因為這是通過import語句被繫結到特定名稱的物件。

另一方面，語句fromspam.hamimporteggs,sausageassaus的結果將為

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

在這裡，spam.ham模組會由__import__()返回。 要匯入的物件將從此物件中提取並賦值給它們對應的名稱。

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

在 3.3 版更改:level的值不再支援負數（預設值也修改為0）。

在 3.9 版更改:當使用了命令列引數-E或-I時，環境變數PYTHONCASEOK現在將被忽略。

備註

1

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