內建函式¶
Python 直譯器內建了許多始終可用的函式和型別。它們在此處按字母順序列出。
內建函式 |
|||
|---|---|---|---|
- aiter(async_iterable, /)¶
返回一個非同步迭代器，用於非同步可迭代物件。等價於呼叫
x.__aiter__()。注意：與
iter()不同，aiter()沒有雙引數變體。在 3.10 版本加入。
- all(iterable, /)¶
如果 iterable 的所有元素都為真（或者如果 iterable 為空），則返回
True。等價於def all(iterable): for element in iterable: if not element: return False return True
- 可等待 anext(async_iterator, /)¶
- 可等待 anext(async_iterator, default, /)
當被 await 時，返回給定非同步迭代器的下一個項，如果給定 default 且迭代器已耗盡，則返回 default。
這是內建函式
next()的非同步變體，行為類似。它呼叫 async_iterator 的
__anext__()方法，返回一個可等待物件。await 它會返回迭代器的下一個值。如果給定了 default，則在迭代器耗盡時返回它，否則會引發StopAsyncIteration。在 3.10 版本加入。
- any(iterable, /)¶
如果 iterable 的任何元素為真，則返回
True。如果 iterable 為空，則返回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(integer, /)¶
將整數轉換為以“0b”為字首的二進位制字串。結果是有效的 Python 表示式。如果 integer 不是 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(object=False, /)¶
返回一個布林值，即
True或False。引數使用標準真值測試過程進行轉換。如果引數為假或省略，則返回False；否則，返回True。bool類是int的子類（參見數字型別 — int、float、complex）。它不能進一步子類化。它唯一的例項是False和True（參見布林型別 - bool）。版本 3.7 中的改變: 引數現在僅限位置。
- breakpoint(*args, **kws)¶
此函式會將您帶入呼叫位置的偵錯程式。具體來說，它會呼叫
sys.breakpointhook()，直接傳遞args和kws。預設情況下，sys.breakpointhook()呼叫pdb.set_trace()，不期望任何引數。在這種情況下，它純粹是一個方便函式，因此您不必顯式匯入pdb或輸入太多程式碼即可進入偵錯程式。但是，sys.breakpointhook()可以設定為其他函式，breakpoint()將自動呼叫該函式，從而允許您進入選擇的偵錯程式。如果sys.breakpointhook()不可訪問，此函式將引發RuntimeError。預設情況下，
breakpoint()的行為可以透過PYTHONBREAKPOINT環境變數進行更改。有關使用詳細資訊，請參閱sys.breakpointhook()。請注意，如果
sys.breakpointhook()已被替換，則無法保證這一點。引發 審計事件
builtins.breakpoint，引數為breakpointhook。在 3.7 版本加入。
- class bytearray(source=b'')
- class bytearray(source, encoding, errors='strict')
返回一個新的位元組陣列。
bytearray類是 0 <= x < 256 範圍內整數的可變序列。它擁有大多數常用的可變序列方法（在可變序列型別中描述），以及bytes型別擁有的方法，參見位元組和位元組陣列操作。可選的 source 引數可以用於以幾種不同的方式初始化陣列
如果它是 string，您還必須提供 encoding (以及可選的 errors) 引數；
bytearray()然後使用str.encode()將字串轉換為位元組。如果它是一個 integer，陣列將具有該大小並用空位元組初始化。
如果它是一個符合緩衝區介面的物件，則物件的只讀緩衝區將用於初始化位元組陣列。
如果它是一個 iterable，它必須是一個 0 <= x < 256 範圍內整數的迭代器，這些整數用作陣列的初始內容。
沒有引數時，會建立一個大小為 0 的陣列。
另請參閱 二進位制序列型別 — bytes, bytearray, memoryview 和 Bytearray 物件。
- class bytes(source=b'')
- class bytes(source, encoding, errors='strict')
返回一個新的“bytes”物件，它是一個 0 <= x < 256 範圍內整數的不可變序列。
bytes是bytearray的不可變版本——它具有相同的非變異方法以及相同的索引和切片行為。因此，建構函式引數的解釋與
bytearray()相同。位元組物件也可以透過字面量建立，參見字串和位元組字面量。
另請參閱 二進位制序列型別 — bytes, bytearray, memoryview、位元組物件 和 位元組和位元組陣列操作。
- callable(object, /)¶
如果 object 引數看起來是可呼叫的，則返回
True，否則返回False。如果此函式返回True，則呼叫仍可能失敗，但如果返回False，則呼叫 object 永遠不會成功。請注意，類是可呼叫的（呼叫類會返回一個新例項）；如果例項的類具有__call__()方法，則例項是可呼叫的。在 3.2 版本加入: 此函式最初在 Python 3.0 中被移除，然後又在 Python 3.2 中重新引入。
- chr(codepoint, /)¶
返回表示具有指定 Unicode 碼點的字元的字串。例如，
chr(97)返回字串'a'，而chr(8364)返回字串'€'。這與ord()相反。引數的有效範圍是 0 到 1,114,111 (十六進位制為 0x10FFFF)。如果超出該範圍，將引發
ValueError。
- @classmethod¶
將一個方法轉換為類方法。
類方法將類作為隱式第一個引數接收，就像例項方法接收例項一樣。要宣告一個類方法，請使用以下慣用語
class C: @classmethod def f(cls, arg1, arg2): ...
@classmethod形式是一個函式裝飾器——詳見函式定義。類方法可以在類上呼叫（例如
C.f()），也可以在例項上呼叫（例如C().f()）。例項除了其類之外被忽略。如果為派生類呼叫類方法，則派生類物件作為隱式第一個引數傳遞。類方法不同於 C++ 或 Java 的靜態方法。如果您想要那些，請參閱本節中的
staticmethod()。有關類方法的更多資訊，請參閱 標準型別層級結構。版本 3.9 中的改變: 類方法現在可以包裝其他描述符，例如
property()。版本 3.10 中的改變: 類方法現在繼承方法屬性（
__module__、__name__、__qualname__、__doc__和__annotations__）並具有新的__wrapped__屬性。自 3.11 版本棄用，在 3.13 版本移除: 類方法不再能包裝其他描述符，例如
property()。
- 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 控制應啟用哪些編譯器選項以及應允許哪些未來特性。如果兩者都不存在（或都為零），則程式碼使用影響呼叫
compile()的程式碼的相同標誌進行編譯。如果給定了 flags 引數而未給定 dont_inherit（或為零），則 flags 引數指定的編譯器選項和未來語句將用於此外仍將使用的那些。如果 dont_inherit 是非零整數，則 flags 引數就是它——周圍程式碼中的標誌（未來特性和編譯器選項）將被忽略。編譯器選項和未來語句由位指定，可以透過按位或運算子組合以指定多個選項。指定給定未來特性所需的位域可以作為
compiler_flag屬性在__future__模組的_Feature例項上找到。編譯器標誌可以在ast模組中找到，字首為PyCF_。引數 optimize 指定編譯器的最佳化級別；預設值
-1選擇由-O選項給出的直譯器最佳化級別。顯式級別為0(無最佳化；__debug__為真)，1(斷言被移除，__debug__為假) 或2(文件字串也被移除)。如果編譯後的原始碼無效，此函式會引發
SyntaxError，如果原始碼包含空位元組，則會引發ValueError。如果您想將 Python 程式碼解析為其 AST 表示，請參閱
ast.parse()。引發 審計事件
compile，引數為source和filename。此事件也可能由隱式編譯引發。備註
在
'single'或'eval'模式下編譯多行程式碼字串時，輸入必須至少以一個換行符終止。這是為了方便code模組檢測不完整和完整的語句。警告
由於 Python AST 編譯器中的堆疊深度限制，當編譯成 AST 物件時，使用足夠大/複雜的字串可能會使 Python 直譯器崩潰。
版本 3.2 中的改變: 允許使用 Windows 和 Mac 換行符。此外，
'exec'模式下的輸入不再需要以換行符結尾。添加了 optimize 引數。版本 3.5 中的改變: 以前，當在 source 中遇到空位元組時，會引發
TypeError。在 3.8 版本加入: 現在可以將
ast.PyCF_ALLOW_TOP_LEVEL_AWAIT作為標誌傳遞，以啟用對頂層await、async for和async with的支援。
- class complex(number=0, /)¶
- class complex(string, /)
- class complex(real=0, imag=0)
將單個字串或數字轉換為複數，或從實部和虛部建立複數。
示例：
>>> complex('+1.23') (1.23+0j) >>> complex('-4.5j') -4.5j >>> complex('-1.23+4.5j') (-1.23+4.5j) >>> complex('\t( -1.23+4.5J )\n') (-1.23+4.5j) >>> complex('-Infinity+NaNj') (-inf+nanj) >>> complex(1.23) (1.23+0j) >>> complex(imag=-4.5) -4.5j >>> complex(-1.23, 4.5) (-1.23+4.5j)
如果引數是字串，它必須包含實部（格式與
float()相同）或虛部（格式相同但帶有'j'或'J'字尾），或者同時包含實部和虛部（在這種情況下虛部的符號是強制性的）。字串可以可選地被空格和圓括號'('和')'包圍，這些都將被忽略。字串不能在'+'、'-'、'j'或'J'字尾和十進位制數之間包含空格。例如，complex('1+2j')是可以的，但complex('1 + 2j')會引發ValueError。更準確地說，在去除括號和前導和尾隨空格字元後，輸入必須符合以下語法中的complexvalue產生式規則complexvalue:
floatvalue|floatvalue("j" | "J") |floatvaluesignabsfloatvalue("j" | "J")如果引數是數字，則建構函式充當數值轉換，類似於
int和float。對於一般的 Python 物件x，complex(x)會委託給x.__complex__()。如果未定義__complex__()，則會回退到__float__()。如果未定義__float__()，則會回退到__index__()。如果提供了兩個引數或使用了關鍵字引數，則每個引數可以是任何數字型別（包括複數）。如果兩個引數都是實數，則返回一個複數，其實部為 real，虛部為 imag。如果兩個引數都是複數，則返回一個複數，其實部為
real.real-imag.imag，虛部為real.imag+imag.real。如果其中一個引數是實數，則在上述表示式中僅使用其實部。另請參閱
complex.from_number()，它只接受單個數字引數。如果所有引數都省略，則返回
0j。複數型別在數字型別 — int、float、complex中描述。
版本 3.6 中的改變: 允許使用下劃線對數字進行分組，如程式碼字面量所示。
版本 3.8 中的改變: 如果未定義
__complex__()和__float__()，則回退到__index__()。自 3.14 版本棄用: 將複數作為 real 或 imag 引數傳遞現已棄用；它應該只作為單個位置引數傳遞。
- delattr(object, name, /)¶
這是
setattr()的一個親戚。引數是一個物件和一個字串。字串必須是物件屬性之一的名稱。該函式刪除命名屬性，前提是物件允許。例如，delattr(x, 'foobar')等價於del x.foobar。name 不需要是 Python 識別符號（參見setattr()）。
- class dict(**kwargs)
- class dict(mapping, /, **kwargs)
- class dict(iterable, /, **kwargs)
建立一個新字典。
dict物件是字典類。有關此類的文件，請參閱dict和 對映型別 — dict。對於其他容器，請參閱內建的
list、set和tuple類，以及collections模組。
- dir()¶
- 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()主要作為互動式提示符下的便利功能提供，所以它試圖提供一組有趣的名稱，而不是試圖提供一組嚴格或一致定義的名稱，並且其詳細行為可能會在不同版本中發生變化。例如，當引數是一個類時，元類屬性不在結果列表中。
- divmod(a, b, /)¶
接受兩個（非複數）數字作為引數，並返回一對數字，包含它們使用整數除法時的商和餘數。對於混合運算元型別，適用二進位制算術運算子的規則。對於整數，結果與
(a // b, a % b)相同。對於浮點數，結果是(q, a % b)，其中 q 通常是math.floor(a / b)，但也可能比這小 1。無論如何，如果a % b非零，則它與 b 符號相同，並且0 <= abs(a % b) < abs(b)，q * b + a % b非常接近 a。
- enumerate(iterable, start=0)¶
返回一個 enumerate 物件。iterable 必須是一個序列、一個迭代器或支援迭代的其他物件。
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(iterable, start=0): n = start for elem in iterable: yield n, elem n += 1
- eval(source, /, globals=None, locals=None)¶
- 引數:
- 返回:
已求值表示式的結果。
- 引發:
語法錯誤將作為異常報告。
警告
此函式執行任意程式碼。使用使用者提供的輸入呼叫它可能會導致安全漏洞。
expression 引數將被解析並作為 Python 表示式（技術上講，是一個條件列表）進行求值，其中 globals 和 locals 對映用作全域性和區域性名稱空間。如果 globals 字典存在並且不包含鍵
__builtins__的值，則在解析 expression 之前，會在該鍵下插入對內建模組builtins的字典的引用。這樣，您就可以透過在將自己的__builtins__字典傳遞給eval()之前插入它來控制可用於執行程式碼的內建函式。如果省略 locals 對映，則預設為 globals 字典。如果兩個對映都省略，則表示式將在呼叫eval()的環境中以 globals 和 locals 執行。請注意，eval() 只有在封閉環境中的巢狀作用域（非區域性變數）已被呼叫eval()的作用域引用時（例如透過nonlocal語句）才能訪問它們。示例
>>> x = 1 >>> eval('x+1') 2
此函式也可以用於執行任意程式碼物件（例如由
compile()建立的程式碼物件）。在這種情況下，傳遞一個程式碼物件而不是字串。如果程式碼物件已編譯，並將'exec'作為 mode 引數，則eval()的返回值將是None。提示：
exec()函式支援動態執行語句。globals()和locals()函式分別返回當前全域性和區域性字典，這對於傳遞給eval()或exec()使用可能很有用。如果給定的源是一個字串，則前導和尾隨的空格和製表符將被去除。
請參閱
ast.literal_eval()，以獲取一個可以安全地求值僅包含字面量的表示式字串的函式。引發一個審計事件
exec，以程式碼物件作為引數。也可能會引發程式碼編譯事件。版本 3.13 中的改變: globals 和 locals 引數現在可以作為關鍵字引數傳遞。
版本 3.13 中的改變: 預設 locals 名稱空間的語義已根據內建函式
locals()的描述進行調整。
- exec(source, /, globals=None, locals=None, *, closure=None)¶
警告
此函式執行任意程式碼。使用使用者提供的輸入呼叫它可能會導致安全漏洞。
此函式支援 Python 程式碼的動態執行。source 必須是字串或程式碼物件。如果是字串，則該字串被解析為一組 Python 語句，然後執行（除非發生語法錯誤）。[1] 如果是程式碼物件，則直接執行。在所有情況下，執行的程式碼都應作為檔案輸入有效（請參閱參考手冊中的檔案輸入一節）。請注意，即使在傳遞給
exec()函式的程式碼上下文中，nonlocal、yield和return語句也不能在函式定義之外使用。返回值為None。在所有情況下，如果省略可選部分，程式碼將在當前作用域中執行。如果僅提供 globals，它必須是一個字典（而不是字典的子類），將用於全域性變數和區域性變數。如果提供了 globals 和 locals，它們將分別用於全域性變數和區域性變數。如果提供，locals 可以是任何對映物件。請記住，在模組級別，全域性變數和區域性變數是同一個字典。
備註
當
exec將兩個獨立的物件作為 globals 和 locals 獲取時，程式碼將像嵌入在類定義中一樣執行。這意味著在執行的程式碼中定義的函式和類將無法訪問在頂層分配的變數（因為“頂層”變數在類定義中被視為類變數）。如果 globals 字典不包含鍵
__builtins__的值，則在該鍵下插入對內建模組builtins的字典的引用。這樣，您就可以透過在將自己的__builtins__字典傳遞給exec()之前插入它來控制可用於執行程式碼的內建函式。closure 引數指定了一個閉包——一個 cellvars 元組。它僅在 object 是一個包含自由（閉包）變數的程式碼物件時有效。元組的長度必須與程式碼物件的
co_freevars屬性的長度完全匹配。引發一個審計事件
exec，以程式碼物件作為引數。也可能會引發程式碼編譯事件。版本 3.11 中的改變: 增加了 closure 引數。
版本 3.13 中的改變: globals 和 locals 引數現在可以作為關鍵字引數傳遞。
版本 3.13 中的改變: 預設 locals 名稱空間的語義已根據內建函式
locals()的描述進行調整。
- filter(function, iterable, /)¶
從 iterable 中為 function 為真的元素構造一個迭代器。iterable 可以是序列、支援迭代的容器或迭代器。如果 function 為
None，則假定為恆等函式，即移除 iterable 中所有為假的元素。注意，如果 function 不是
None，則filter(function, iterable)等價於生成器表示式(item for item in iterable if function(item))；如果 function 為None，則等價於(item for item in iterable if item)。請參閱
itertools.filterfalse()以獲取返回 iterable 中 function 為假的元素的互補函式。
- class float(number=0.0, /)¶
- class float(string, /)
返回由數字或字串構造的浮點數。
示例：
>>> float('+1.23') 1.23 >>> float(' -12345\n') -12345.0 >>> float('1e-003') 0.001 >>> float('+1E6') 1000000.0 >>> float('-Infinity') -inf
如果引數是字串，它應該包含一個十進位制數，可選地前面帶有一個符號，並且可選地嵌入在空格中。可選符號可以是
'+'或'-'；'+'符號對產生的值沒有影響。引數也可以是一個表示 NaN（非數字）或正負無窮大的字串。更準確地說，在去除前導和尾隨空格字元後，輸入必須符合以下語法中的floatvalue產生式規則sign: "+" | "-" infinity: "Infinity" | "inf" nan: "nan" digit: <a Unicode decimal digit, i.e. characters in Unicode general category Nd> digitpart:
digit(["_"]digit)* number: [digitpart] "."digitpart|digitpart["."] exponent: ("e" | "E") [sign]digitpartfloatnumber:number[exponent] absfloatvalue:floatnumber|infinity|nanfloatvalue: [sign]absfloatvalue大小寫不敏感，因此，例如，“inf”、“Inf”、“INFINITY”和“iNfINity”都是正無窮大的可接受拼寫。
否則，如果引數是整數或浮點數，則返回具有相同值（在 Python 的浮點精度範圍內）的浮點數。如果引數超出 Python 浮點數的範圍，則會引發
OverflowError。對於一個普通的 Python 物件
x，float(x)會委託給x.__float__()。如果__float__()未定義，則會回退到__index__()。另請參閱
float.from_number()，它只接受數字引數。如果沒有給出引數，則返回
0.0。浮點型別在 數字型別 — int、float、complex 中描述。
版本 3.6 中的改變: 允許使用下劃線對數字進行分組，如程式碼字面量所示。
版本 3.7 中的改變: 引數現在僅限位置。
3.8 版本新增: 如果
__float__()未定義，則回退到__index__()。
- format(value, format_spec='', /)¶
根據 format_spec 控制將 value 轉換為“格式化”表示形式。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, /)¶
- getattr(object, name, default, /)
返回 object 的命名屬性的值。name 必須是一個字串。如果該字串是物件某個屬性的名稱，則結果是該屬性的值。例如，
getattr(x, 'foobar')等價於x.foobar。如果命名屬性不存在，則如果提供了 default，則返回 default，否則引發AttributeError。name 不需要是 Python 識別符號（參見setattr()）。
- globals()¶
返回實現當前模組名稱空間的字典。對於函式內的程式碼，這在函式定義時設定，並且無論函式在哪裡呼叫都保持不變。
- hasattr(object, name, /)¶
引數是一個物件和一個字串。如果字串是物件某個屬性的名稱，則結果為
True，否則為False。（這是透過呼叫getattr(object, name)並檢視它是否引發AttributeError> 來實現的。）
- hash(object, /)¶
返回物件的雜湊值（如果它有的話）。雜湊值是整數。它們用於在字典查詢期間快速比較字典鍵。比較相等的數值具有相同的雜湊值（即使它們是不同型別，例如 1 和 1.0）。
備註
對於具有自定義
__hash__()方法的物件，請注意hash()會根據主機機器的位寬截斷返回值。
- help()¶
- help(request)
呼叫內建幫助系統。（此函式用於互動式使用。）如果沒有給出引數，則互動式幫助系統會在直譯器控制檯啟動。如果引數是字串，則會將該字串視為模組、函式、類、方法、關鍵字或文件主題的名稱，並在控制檯上列印幫助頁面。如果引數是任何其他型別的物件，則會生成該物件的幫助頁面。
請注意，如果在呼叫
help()時，函式的引數列表中出現斜槓（/），這意味著斜槓之前的引數是僅限位置的。更多資訊請參閱 關於僅限位置引數的 FAQ 條目。此函式由
site模組新增到內建名稱空間。
- hex(integer, /)¶
將整數轉換為以“0x”為字首的小寫十六進位制字串。如果 integer 不是 Python
int物件，它必須定義一個返回整數的__index__()方法。一些示例>>> hex(255) '0xff' >>> hex(-42) '-0x2a'
如果你想將整數轉換為帶或不帶字首的大寫或小寫十六進位制字串，你可以使用以下任一方式
>>> '%#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 實現細節: 這是物件在記憶體中的地址。
引發 審計事件
builtins.id，引數為id。
- input()¶
- 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，並附帶結果。
- class int(number=0, /)¶
- class int(string, /, base=10)
返回從數字或字串構造的整數物件，如果沒有給出引數則返回
0。示例：
>>> int(123.45) 123 >>> int('123') 123 >>> int(' -12_345\n') -12345 >>> int('FACE', 16) 64206 >>> int('0xface', 0) 64206 >>> int('01110011', base=2) 115
如果引數定義了
__int__()，則int(x)返回x.__int__()。如果引數定義了__index__()，則返回x.__index__()。對於浮點數，這會向零截斷。如果引數不是數字或者給出了 base，那麼它必須是表示基數 base 中的整數的字串、
bytes或bytearray例項。可選地，字串可以前面帶有+或-（之間沒有空格），可以有前導零，可以被空格包圍，並且可以在數字之間散佈單個下劃線。基數 n 整數字符串包含數字，每個數字代表從 0 到 n-1 的值。值 0–9 可以由任何 Unicode 十進位制數字表示。值 10–35 可以由
a到z（或A到Z）表示。預設的 base 是 10。允許的基數是 0 和 2–36。基數 2、8 和 16 字串可以可選地以0b/0B、0o/0O或0x/0X為字首，就像程式碼中的整數字面量一樣。對於基數 0，字串的解釋方式類似於 程式碼中的整數字面量，實際基數由字首確定為 2、8、10 或 16。基數 0 也不允許前導零：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 版本新增: 第一個引數現在是僅限位置的。
3.8 版本新增: 如果
__int__()未定義，則回退到__index__()。3.11 版本新增:
int字串輸入和字串表示可以限制，以幫助避免拒絕服務攻擊。當在將字串轉換為int或將int轉換為字串時超出限制時，會引發ValueError。請參閱 整數字符串轉換長度限制 文件。3.14 版本新增:
int()不再委託給__trunc__()方法。
- isinstance(object, classinfo, /)¶
如果 object 引數是 classinfo 引數的例項，或是其（直接、間接或 虛擬）子類的例項，則返回
True。如果 object 不是給定型別的物件，則函式始終返回False。如果 classinfo 是型別物件（或遞迴地，其他此類元組）的元組，或者是多個型別的 聯合型別，則如果 object 是其中任何一個型別的例項，則返回True。如果 classinfo 不是型別或型別元組以及此類元組，則會引發TypeError異常。如果早期檢查成功，則對於無效型別可能不會引發TypeError。3.10 版本新增: classinfo 可以是 聯合型別。
- issubclass(class, classinfo, /)¶
如果 class 是 classinfo 的子類（直接、間接或 虛擬），則返回
True。一個類被認為是其自身的子類。classinfo 可以是類物件元組（或遞迴地，其他此類元組）或 聯合型別，在這種情況下，如果 class 是 classinfo 中任何條目的子類，則返回True。在任何其他情況下，會引發TypeError異常。3.10 版本新增: classinfo 可以是 聯合型別。
- iter(iterable, /)¶
- iter(callable, sentinel, /)
返回一個 迭代器 物件。第一個引數的解釋因第二個引數的存在與否而有很大不同。如果沒有第二個引數，則單個引數必須是支援 可迭代 協議（
__iter__()方法）的集合物件，或者必須支援序列協議（從0開始的整數引數的__getitem__()方法）。如果它不支援這些協議中的任何一個，則會引發TypeError。如果給出第二個引數 sentinel，則第一個引數必須是可呼叫物件。在這種情況下建立的迭代器將在每次呼叫其__next__()方法時呼叫 callable 而不帶引數；如果返回的值等於 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(object, /)¶
返回物件的長度（專案數）。引數可以是序列（如字串、位元組、元組、列表或範圍）或集合（如字典、集合或凍結集合）。
CPython 實現細節:
len在長度大於sys.maxsize時（例如range(2 ** 100)）引發OverflowError。
- class list(iterable=(), /)
list實際上是一個可變序列型別，而不是一個函式，如 列表 和 序列型別 — list、tuple、range 中所述。
- locals()¶
返回一個對映物件，表示當前區域性符號表，其中變數名作為鍵，其當前繫結的引用作為值。
在模組作用域中，以及在使用
exec()或eval()並只傳遞一個名稱空間時，此函式返回與globals()相同的名稱空間。在類作用域中，它返回將傳遞給元類建構函式的名稱空間。
當使用
exec()或eval()並單獨傳遞區域性和全域性引數時，它返回傳遞給函式呼叫的區域性名稱空間。在上述所有情況下，在給定執行幀中每次呼叫
locals()都將返回 相同 的對映物件。透過locals()返回的對映物件所做的更改將作為已賦值、重新賦值或刪除的區域性變數可見，並且賦值、重新賦值或刪除區域性變數將立即影響返回的對映物件的內容。在 最佳化作用域 中（包括函式、生成器和協程），每次呼叫
locals()都會返回一個新字典，其中包含函式區域性變數和任何非區域性單元格引用的當前繫結。在這種情況下，透過返回的字典進行的名稱繫結更改 不會 寫回相應的區域性變數或非區域性單元格引用，並且賦值、重新賦值或刪除區域性變數和非區域性單元格引用 不會 影響先前返回的字典的內容。在函式、生成器或協程中，將
locals()作為推導式的一部分呼叫，等同於在包含作用域中呼叫它，不同之處在於推導式初始化的迭代變數將包含在內。在其他作用域中，它的行為就像推導式作為巢狀函式執行一樣。將
locals()作為生成器表示式的一部分呼叫，等同於在巢狀生成器函式中呼叫它。3.12 版本新增:
locals()在推導式中的行為已按照 PEP 709 中的描述進行了更新。
- map(function, iterable, /, *iterables, strict=False)¶
返回一個迭代器，它將 function 應用於 iterable 的每個專案，並生成結果。如果傳遞了額外的 iterables 引數，function 必須接受相同數量的引數，並並行應用於所有可迭代物件的專案。對於多個可迭代物件，當最短的可迭代物件耗盡時，迭代器停止。如果 strict 為
True並且其中一個可迭代物件在其他可迭代物件之前耗盡，則會引發ValueError。對於函式輸入已排列成引數元組的情況，請參閱itertools.starmap()。3.14 版本新增: 添加了 strict 引數。
- max(iterable, /, *, key=None)¶
- max(iterable, /, *, default, key=None)
- max(arg1, arg2, /, *args, key=None)
返回可迭代物件中的最大項，或兩個或更多引數中的最大值。
如果提供了一個位置引數，它應該是一個 可迭代物件。返回可迭代物件中最大的項。如果提供了兩個或更多位置引數，則返回位置引數中最大的項。
有兩個可選的僅限關鍵字引數。key 引數指定一個單引數排序函式，類似於
list.sort()所使用的那種。default 引數指定當提供的可迭代物件為空時要返回的物件。如果可迭代物件為空且未提供 default，則會引發ValueError。如果有多個專案是最大的，函式返回遇到的第一個。這與其它保持排序穩定性的工具一致，例如
sorted(iterable, key=keyfunc, reverse=True)[0]和heapq.nlargest(1, iterable, key=keyfunc)。3.4 版本新增: 添加了 default 僅限關鍵字引數。
3.8 版本新增: key 可以是
None。
- class memoryview(object)
返回從給定引數建立的“記憶體檢視”物件。有關更多資訊，請參閱 記憶體檢視。
- min(iterable, /, *, key=None)¶
- min(iterable, /, *, default, key=None)
- min(arg1, arg2, /, *args, key=None)
返回可迭代物件中的最小項，或兩個或更多引數中的最小值。
如果提供了一個位置引數，它應該是一個 可迭代物件。返回可迭代物件中最小的項。如果提供了兩個或更多位置引數，則返回位置引數中最小的項。
有兩個可選的僅限關鍵字引數。key 引數指定一個單引數排序函式，類似於
list.sort()所使用的那種。default 引數指定當提供的可迭代物件為空時要返回的物件。如果可迭代物件為空且未提供 default，則會引發ValueError。如果有多個專案是最小的，函式返回遇到的第一個。這與其它保持排序穩定性的工具一致，例如
sorted(iterable, key=keyfunc)[0]和heapq.nsmallest(1, iterable, key=keyfunc)。3.4 版本新增: 添加了 default 僅限關鍵字引數。
3.8 版本新增: key 可以是
None。
- next(iterator, /)¶
- next(iterator, default, /)
透過呼叫
__next__()方法從 迭代器 中檢索下一項。如果給定了 default，則在迭代器耗盡時返回 default，否則引發StopIteration。
- class object¶
這是所有其他類的終極基類。它具有所有 Python 類例項共有的方法。當呼叫建構函式時，它會返回一個新的無特徵物件。建構函式不接受任何引數。
- oct(integer, /)¶
將整數轉換為以“0o”為字首的八進位制字串。結果是有效的 Python 表示式。如果 integer 不是 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 並返回相應的 檔案物件。如果檔案無法開啟，則會引發
OSError。有關如何使用此函式的更多示例，請參閱 讀寫檔案。file 是一個 類路徑物件，給出要開啟檔案的路徑名（絕對路徑或相對於當前工作目錄的路徑），或者是包裝檔案的整數檔案描述符。（如果給出了檔案描述符，則在關閉返回的 I/O 物件時關閉它，除非 closefd 設定為
False。）mode 是一個可選字串，用於指定檔案開啟的模式。它預設為
'r'，表示以文字模式讀取。其他常見值包括'w'用於寫入（如果檔案已存在則截斷檔案）、'x'用於獨佔建立，以及'a'用於追加（在 某些 Unix 系統上，這意味著 所有 寫入都追加到檔案末尾，無論當前查詢位置如何）。在文字模式下，如果未指定 encoding，則使用的編碼是平臺相關的：呼叫locale.getencoding()以獲取當前區域設定編碼。（為了讀寫原始位元組，請使用二進位制模式並省略 encoding。）可用模式包括字元
含義
'r'以讀模式開啟（預設）
'w'以寫模式開啟，首先截斷檔案
'x'以獨佔建立模式開啟，如果檔案已存在則失敗
'a'以寫入模式開啟，如果檔案存在則追加到檔案末尾
'b'二進位制模式
't'文字模式（預設）
'+'以更新模式開啟（讀寫）
預設模式為
'r'(以文字模式讀取，與'rt'同義)。模式'w+'和'w+b'開啟並截斷檔案。模式'r+'和'r+b'開啟檔案時不截斷。如 概述 中所述，Python 區分二進位制 I/O 和文字 I/O。以二進位制模式開啟的檔案（包括 mode 引數中的
'b'）返回的內容為bytes物件，不進行任何解碼。在文字模式下（預設模式，或當 mode 引數中包含't'時），檔案內容作為str返回，位元組首先使用平臺相關的編碼進行解碼，或者如果給出 encoding 則使用指定的編碼進行解碼。備註
Python 不依賴於底層作業系統對文字檔案的概念；所有處理都由 Python 自己完成，因此是平臺獨立的。
buffering 是一個可選整數，用於設定緩衝策略。傳遞 0 關閉緩衝（僅允許在二進位制模式下），傳遞 1 選擇行緩衝（僅在文字模式下寫入時可用），傳遞大於 1 的整數表示固定大小塊緩衝區的位元組大小。請注意，以這種方式指定緩衝區大小適用於二進位制緩衝 I/O，但
TextIOWrapper（即，以mode='r+'開啟的檔案）會有另一個緩衝。要停用TextIOWrapper中的緩衝，請考慮對io.TextIOWrapper.reconfigure()使用write_through標誌。如果沒有給出 buffering 引數，預設緩衝策略如下二進位制檔案以固定大小的塊進行緩衝；當裝置塊大小可用時，緩衝區大小為
max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)。在大多數系統上，緩衝區通常為 128 千位元組。“互動式”文字檔案（
isatty()返回True的檔案）使用行緩衝。其他文字檔案使用上述二進位制檔案的策略。
encoding 是用於解碼或編碼檔案的編碼名稱。這應該只在文字模式下使用。預設編碼是平臺相關的（
locale.getencoding()返回的任何內容），但可以使用 Python 支援的任何 文字編碼。有關支援的編碼列表，請參閱codecs模組。errors 是一個可選字串，指定如何處理編碼和解碼錯誤——這不能在二進位制模式下使用。有多種標準錯誤處理程式可用（列在 錯誤處理程式 下），儘管任何已透過
codecs.register_error()註冊的錯誤處理程式名稱也是有效的。標準名稱包括'strict'在編碼錯誤時引發ValueError異常。預設值None具有相同的效果。'ignore'忽略錯誤。請注意，忽略編碼錯誤可能導致資料丟失。'replace'導致在資料格式錯誤的地方插入一個替換標記（例如'?'）。'surrogateescape'將任何不正確的位元組表示為 U+DC80 到 U+DCFF 範圍內的低位替程式碼點。當寫入資料時使用surrogateescape錯誤處理程式時，這些替程式碼點將再次轉換回相同的位元組。這對於處理未知編碼的檔案很有用。'xmlcharrefreplace'僅在寫入檔案時支援。編碼不支援的字元將替換為相應的 XML 字元引用&#nnn;。'backslashreplace'將格式錯誤的資料替換為 Python 的反斜槓轉義序列。'namereplace'（同樣僅在寫入時支援）將不支援的字元替換為\N{...}轉義序列。
newline 決定如何解析流中的換行符。它可以是
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作為 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()函式返回的 檔案物件 型別取決於模式。當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，引數為path、mode、flags。mode和flags引數可能已根據原始呼叫進行了修改或推斷。3.3 版本中的變化
添加了 opener 引數。
添加了
'x'模式。現在，如果檔案以獨佔建立模式 (
'x') 開啟時已存在，則會引發FileExistsError。
3.4 版本中的變化
檔案現在不可繼承。
3.5 版本中的變化
如果系統呼叫被中斷並且訊號處理程式沒有引發異常，則函式現在會重試系統呼叫，而不是引發
InterruptedError異常（有關原因，請參閱 PEP 475）。添加了
'namereplace'錯誤處理程式。
3.6 版本中的變化
添加了對實現
os.PathLike的物件的支援。在 Windows 上，開啟控制檯緩衝區可能會返回
io.RawIOBase的子類，而不是io.FileIO。
3.11 版本中的變化:
'U'模式已移除。
- ord(character, /)¶
返回字元的序數值。
如果引數是一個單字元字串，則返回該字元的 Unicode 碼點。例如，
ord('a')返回整數97，ord('€')（歐元符號）返回8364。這與chr()相反。如果引數是長度為 1 的
bytes或bytearray物件，則返回其單個位元組值。例如，ord(b'a')返回整數97。
- pow(base, exp, mod=None)¶
返回 base 的 exp 次冪；如果存在 mod，則返回 base 的 exp 次冪，然後取模 mod（比
pow(base, exp) % mod更高效）。兩引數形式pow(base, exp)等價於使用冪運算子：base**exp。當引數是內建數值型別且包含混合運算元型別時，適用於二進位制算術運算子的強制轉換規則。對於
int運算元，結果型別與運算元型別相同（強制轉換後），除非第二個引數為負；在這種情況下，所有引數都將轉換為浮點數並返回浮點數結果。例如，pow(10, 2)返回100，但pow(10, -2)返回0.01。對於int或float型別的負基數和非整數指數，將返回複數結果。例如，pow(-9, 0.5)返回一個接近3j的值。然而，對於int或float型別的負基數和整數指數，將返回浮點數結果。例如，pow(-9, 2.0)返回81.0。對於
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=None, 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 關鍵字引數。
- class property(fget=None, fset=None, fdel=None, doc=None)¶
返回一個屬性。
fget 是用於獲取屬性值的函式。fset 是用於設定屬性值的函式。fdel 是用於刪除屬性值的函式。doc 為屬性建立文件字串。
典型用法是定義一個託管屬性
xclass 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，它將成為屬性的文件字串。否則，該屬性將複製 fget 的文件字串（如果存在）。這使得使用
property()作為裝飾器可以輕鬆建立只讀屬性class Parrot: def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage
@property裝飾器將voltage()方法轉換為同名只讀屬性的“getter”，並將其文件字串設定為“Get the current voltage.”- @getter¶
- @setter¶
- @deleter¶
property 物件具有
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 版本發生變更: 屬性物件的文件字串現在是可寫入的。
- __name__¶
儲存屬性名稱的屬性。屬性的名稱可以在執行時更改。
在 3.13 版本加入。
- class range(stop, /)
- class range(start, stop, step=1, /)
range實際上不是一個函式，而是一個不可變序列型別，如 區間 和 序列型別 — list、tuple、range 中所述。
- repr(object, /)¶
返回一個包含物件可打印表示形式的字串。對於許多型別，此函式會嘗試返回一個字串，該字串在傳遞給
eval()時將生成具有相同值的物件；否則，表示形式是一個用尖括號括起來的字串，其中包含物件的型別名稱以及通常包括物件名稱和地址的其他資訊。類可以透過定義__repr__()方法來控制此函式為其例項返回的內容。如果無法訪問sys.displayhook()，此函式將引發RuntimeError。這個類有一個自定義表示形式，可以進行評估
class Person: def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f"Person('{self.name}', {self.age})"
- reversed(object, /)¶
返回一個逆向迭代器。引數必須是具有
__reversed__()方法或支援序列協議（__len__()方法和從0開始的整數引數的__getitem__()方法）的物件。
- round(number, ndigits=None)¶
返回 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。這不是一個 bug：這是因為大多數十進位制分數不能精確地表示為浮點數。有關更多資訊，請參閱 浮點數算術：問題和限制。
- 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。除非物件選擇強制執行此操作（例如在自定義
__getattribute__()中或透過__slots__），否則 name 不需要是 名稱（識別符號和關鍵字） 中定義的 Python 識別符號。名稱不是識別符號的屬性將無法使用點表示法訪問，但可以透過getattr()等訪問。
- class slice(stop, /)¶
- class slice(start, stop, step=None, /)
返回一個 切片 物件，表示由
range(start, stop, step)指定的索引集。start 和 step 引數預設為None。切片物件具有隻讀資料屬性
start、stop和step，它們僅返回引數值（或其預設值）。它們沒有其他明確的功能；但是，它們被 NumPy 和其他第三方包使用。- start¶
- stop¶
- step¶
當使用擴充套件索引語法時也會生成切片物件。例如：
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()函式保證是穩定的。如果排序保證不改變比較相等的元素的相對順序，則它是穩定的——這對於多次排序很有幫助（例如，按部門排序，然後按工資等級排序）。排序演算法僅使用專案之間的
<比較。雖然定義__lt__()方法足以進行排序，但 PEP 8 建議實現所有六個富比較。這將有助於在使用相同資料和依賴不同底層方法的其他排序工具（例如max()）時避免錯誤。實現所有六個比較還有助於避免混合型別比較的混淆，因為混合型別比較可以呼叫反射的__gt__()方法。有關排序示例和簡短的排序教程，請參閱排序技術。
- @staticmethod¶
將方法轉換為靜態方法。
靜態方法不接收隱式的第一個引數。要宣告靜態方法，請使用此慣用法
class C: @staticmethod def f(arg1, arg2, argN): ...
@staticmethod形式是一個函式裝飾器——有關詳細資訊，請參見函式定義。靜態方法可以在類上呼叫（例如
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__屬性，並且現在可以作為普通函式呼叫。
- class str(*, encoding='utf-8', errors='strict')
- class str(object)
- class str(object, encoding, errors='strict')
- class str(object, *, errors)
返回 object 的
str版本。有關詳細資訊，請參閱str()。str是內建的字串類。有關字串的通用資訊，請參閱文字序列型別 — str。
- sum(iterable, /, start=0)¶
從左到右將 start 和 iterable 的專案相加，並返回總和。iterable 的專案通常是數字，並且起始值不允許是字串。
對於某些用例，
sum()有很好的替代方案。連線字串序列的首選、快速方法是呼叫''.join(sequence)。要以擴充套件精度新增浮點值，請參閱math.fsum()。要連線一系列可迭代物件，請考慮使用itertools.chain()。3.8 版本發生變更: start 引數可以指定為關鍵字引數。
3.12 版本發生變更: 浮點數求和改為使用在大多數構建中提供更高精度和更好可交換性的演算法。
3.14 版本發生變更: 添加了複數求和的專門化，使用與浮點數求和相同的演算法。
- class super¶
- class super(type, object_or_type=None, /)
返回一個代理物件，該物件將方法呼叫委託給 type 的父類或兄弟類。這對於訪問在類中被覆蓋的繼承方法很有用。
object_or_type 決定要搜尋的方法解析順序。搜尋從 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)必須為 True。如果第二個引數是一個型別，則issubclass(type2, type)必須為 True（這對於類方法很有用）。在類的普通方法中直接呼叫時，兩個引數都可以省略（“零引數
super()”）。在這種情況下，type 將是封閉類，obj 將是緊鄰封閉函式的第一個引數（通常是self）。（這意味著零引數super()在巢狀函式（包括生成器表示式，它們隱式建立巢狀函式）中將無法按預期工作。）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()設計協作類的實用建議，請參閱 guide to using super()。3.14 版本發生變更:
super物件現在是pickleable和copyable。
- class tuple(iterable=(), /)
tuple實際上不是一個函式，而是一個不可變序列型別，如 元組 和 序列型別 — list、tuple、range 中所述。
- class type(object, /)¶
- class type(name, bases, dict, /, **kwargs)
使用一個引數時，返回 object 的型別。返回值是一個型別物件，通常與
object.__class__返回的物件相同。建議使用內建函式
isinstance()來測試物件的型別，因為它會考慮子類。使用三個引數時，返回一個新的型別物件。這本質上是
class語句的動態形式。name 字串是類名，併成為__name__屬性。bases 元組包含基類，併成為__bases__屬性；如果為空，則新增object，即所有類的最終基類。dict 字典包含類體的屬性和方法定義；它可以在成為__dict__屬性之前被複制或包裝。以下兩個語句建立相同的type物件>>> class X: ... a = 1 ... >>> X = type('X', (), dict(a=1))
參見
提供給三引數形式的關鍵字引數以與類定義中的關鍵字（除了 metaclass）相同的方式傳遞給適當的元類機制（通常是
__init_subclass__()）。另請參閱 自定義類的建立。
3.6 版本發生變更: 不重寫
type.__new__的type子類不能再使用單引數形式獲取物件的型別。
- vars()¶
- vars(object, /)
返回模組、類、例項或任何其他具有
__dict__屬性的物件的__dict__屬性。模組和例項等物件具有可更新的
__dict__屬性；但是，其他物件可能對其__dict__屬性有寫入限制（例如，類使用types.MappingProxyType來防止直接字典更新）。如果沒有引數，
vars()的行為與locals()類似。如果指定了一個物件但它沒有
__dict__屬性（例如，如果它的類定義了__slots__屬性），則會引發TypeError異常。3.13 版本發生變更: 不帶引數呼叫此函式的結果已更新，如內建函式
locals()所述。
- 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()的可迭代物件可能具有不同的長度；有時是設計使然，有時是由於準備這些可迭代物件的程式碼中的 bug。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。>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True): ... print(item) ... (0, 'fee') (1, 'fi') (2, 'fo') Traceback (most recent call last): ... ValueError: zip() argument 2 is longer than argument 1
如果沒有
strict=True引數，任何導致可迭代物件長度不同的錯誤都將被靜默，可能在程式的另一部分表現為難以找到的錯誤。較短的可迭代物件可以用一個常量值填充，使所有可迭代物件具有相同的長度。這透過
itertools.zip_longest()完成。
極端情況：只有一個可迭代引數時，
zip()返回一個由 1 元組組成的迭代器。沒有引數時，它返回一個空迭代器。提示和技巧
可迭代物件的從左到右評估順序是有保證的。這使得使用
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)¶
備註
這是一個高階函式，在日常 Python 程式設計中不需要，不像
importlib.import_module()。此函式由
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 版本發生變更: 不再支援 level 的負值（這也將預設值更改為 0）。
3.9 版本發生變更: 當使用命令列選項
-E或-I時，環境變數PYTHONCASEOK現在被忽略。
腳註