內建函式¶
Python 直譯器內建了許多始終可用的函式和型別。它們在這裡按字母順序列出。
內建函式 |
|||
|---|---|---|---|
- aiter(async_iterable)¶
返回 非同步迭代器 用於 非同步可迭代物件。等效於呼叫
x.__aiter__()。注意：與
iter()不同，aiter()沒有 2 引數變體。3.10 版本新增。
- all(iterable)¶
如果 iterable 的所有元素都為真（或者如果 iterable 為空），則返回
True。等效於def all(iterable): for element in iterable: if not element: return False return True
- awaitable anext(async_iterator)¶
- awaitable anext(async_iterator, default)
等待時，從給定的 非同步迭代器 返回下一個專案，如果給定且迭代器已耗盡，則返回 default。
這是
next()內建函式的非同步變體，行為類似。這會呼叫 async_iterator 的
__anext__()方法，返回一個 可等待物件。等待此物件會返回迭代器的下一個值。如果給定了 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(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(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。預設情況下，可以使用
PYTHONBREAKPOINT環境變數更改breakpoint()的行為。有關用法詳細資訊，請參閱sys.breakpointhook()。請注意，如果
sys.breakpointhook()已被替換，則不能保證此行為。引發一個帶有引數
breakpointhook的 審計事件builtins.breakpoint。在 3.7 版本中加入。
- class bytearray(source=b'')
- class bytearray(source, encoding)
- class bytearray(source, encoding, errors)
返回一個新的位元組陣列。
bytearray類是 0 <= x < 256 範圍內的整數可變序列。它具有可變序列的大多數常用方法（在 可變序列型別 中描述），以及bytes型別的大多數方法，請參閱 位元組和位元組陣列操作。可選的 source 引數可用於以幾種不同的方式初始化陣列
如果它是一個字串，您還必須提供 encoding （以及可選的 errors）引數；然後
bytearray()使用str.encode()將字串轉換為位元組。如果它是一個整數，則陣列將具有該大小，並將使用空位元組進行初始化。
如果它是一個符合 緩衝區介面 的物件，則將使用該物件的只讀緩衝區來初始化位元組陣列。
如果它是一個可迭代物件，則它必須是範圍為
0 <= x < 256的整數的可迭代物件，這些整數用作陣列的初始內容。
如果沒有引數，則會建立一個大小為 0 的陣列。
- class bytes(source=b'')
- class bytes(source, encoding)
- class bytes(source, encoding, errors)
返回一個新的“位元組”物件，它是 0 <= x < 256 範圍內的整數的不可變序列。
bytes是bytearray的不可變版本——它具有相同的非變異方法以及相同的索引和切片行為。因此，建構函式引數的解釋與
bytearray()相同。也可以使用字面量建立位元組物件，請參閱 字串和位元組字面量。
另請參閱 二進位制序列型別 — bytes、bytearray、memoryview、Bytes 物件 和 位元組和位元組陣列操作。
- 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（十六進位制為 0x10FFFF）。如果 i 超出該範圍，將引發
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'；如果由單個互動式語句組成（在後一種情況下，求值為None之外的內容的表示式語句將被列印），則可以是'single'。可選引數 flags 和 dont_inherit 控制應啟用哪些編譯器選項以及應允許哪些未來特性。 如果兩者都不存在（或都為零），則程式碼將使用影響呼叫
compile()的程式碼的相同標誌進行編譯。 如果給定了 flags 引數，而 dont_inherit 沒有給出（或為零），則除了無論如何都會使用的標誌外，還會使用 flags 引數指定的編譯器選項和未來語句。 如果 dont_inherit 是非零整數，則 flags 引數就是它——周圍程式碼中的標誌（未來特性和編譯器選項）將被忽略。編譯器選項和未來語句由位指定，這些位可以按位或運算在一起以指定多個選項。 指定給定未來特性所需的位欄位可以在
compiler_flag屬性上找到，該屬性位於_Feature例項中，該例項位於__future__模組中。編譯器標誌可以在ast模組中找到，帶有PyCF_字首。引數 optimize 指定編譯器的最佳化級別；預設值
-1選擇直譯器的最佳化級別，該級別由-O選項給出。 顯式級別為0（無最佳化；__debug__為 true），1（刪除斷言，__debug__為 false）或2（也刪除 docstring）。如果編譯後的源無效，此函式將引發
SyntaxError，如果源包含空位元組，則引發ValueError。如果要將 Python 程式碼解析為其 AST 表示形式，請參閱
ast.parse()。引發帶有引數
source和filename的審計事件compile。此事件也可能由隱式編譯引發。注意
當在
'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的複數。如果其中一個引數是實數，則在上述表示式中僅使用其實部。如果省略所有引數，則返回
0j。複數型別在 數值型別 — int, float, complex 中描述。
在 3.6 版本中更改: 允許像程式碼字面量一樣使用下劃線對數字進行分組。
在 3.8 版本中更改: 如果
__complex__()和__float__()未定義，則回退到__index__()。
- delattr(object, name)¶
這是
setattr()的一個親戚。引數是一個物件和一個字串。字串必須是物件的一個屬性的名稱。該函式會刪除指定的屬性，前提是該物件允許刪除。例如，delattr(x, 'foobar')等效於del x.foobar。name 不必是 Python 識別符號（請參閱setattr()）。
- class dict(**kwarg)
- class dict(mapping, **kwarg)
- class dict(iterable, **kwarg)
建立一個新的字典。
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。在任何情況下，q * b + a % b都非常接近於 a，如果a % b非零，則其符號與 b 相同，並且0 <= abs(a % b) < abs(b)。
- enumerate(iterable, start=0)¶
返回一個列舉物件。iterable 必須是一個序列，一個 迭代器，或某些支援迭代的其他物件。
__next__()由enumerate()返回的迭代器的方法返回一個包含計數（從 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__字典插入到 globals 中，然後將其傳遞給eval()，從而控制可用於執行程式碼的內建函式。如果省略 locals 對映，則預設為 globals 字典。如果省略兩個對映，則會在呼叫eval()的環境中，使用 globals 和 locals 執行表示式。請注意，如果 巢狀作用域（非區域性）已經在呼叫eval()的作用域中被引用（例如透過nonlocal語句），則 eval() 將只能訪問封閉環境中的巢狀作用域。示例
>>> 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] 如果它是程式碼物件，則直接執行。在所有情況下，執行的程式碼都應作為檔案輸入有效（請參閱參考手冊中的 檔案輸入 部分）。請注意，
nonlocal、yield和return語句即使在傳遞給exec()函式的程式碼的上下文中，也不能在函式定義之外使用。返回值是None。在所有情況下，如果省略可選部分，則程式碼將在當前作用域中執行。如果僅提供 globals，則它必須是一個字典（而不是字典的子類），它將用於全域性變數和區域性變數。如果給出 globals 和 locals，則它們分別用於全域性變數和區域性變數。如果提供，locals 可以是任何對映物件。請記住，在模組級別，全域性變數和區域性變數是同一個字典。
注意
當
exec獲取兩個單獨的物件作為 globals 和 locals 時，程式碼的執行方式將如同它嵌入在類定義中一樣。這意味著在執行的程式碼中定義的函式和類將無法訪問在頂層分配的變數（因為“頂層”變數在類定義中被視為類變數）。如果 globals 字典不包含鍵
__builtins__的值，則會在該鍵下插入對內建模組builtins的字典的引用。這樣，您可以透過在將 globals 傳遞給exec()之前，將您自己的__builtins__字典插入到 globals 中來控制哪些內建函式可用於執行的程式碼。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__()。如果沒有給出引數，則返回
0.0。浮點型別在 數字型別 — int、float、complex 中描述。
在 3.6 版本中更改: 允許像程式碼字面量一樣使用下劃線對數字進行分組。
在 3.7 版本中更改：該引數現在是僅限位置的引數。
在 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。
- class frozenset(iterable=set())
返回一個新的
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，則返回該值，否則引發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()時，函式的引數列表中出現斜槓(/)，則表示斜槓之前的引數是僅限位置的。有關更多資訊，請參閱 有關僅限位置引數的常見問題解答條目。此函式由
site模組新增到內建名稱空間中。
- hex(x)¶
將整數轉換為以“0x”為字首的小寫十六進位制字串。如果 x 不是 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 實現細節: 這是物件在記憶體中的地址。
使用引數
id引發 稽核事件builtins.id。
- input()¶
- input(prompt)
如果存在 prompt 引數，則將其寫入標準輸出，而不帶有尾隨換行符。然後，該函式從輸入中讀取一行，將其轉換為字串（去除尾隨換行符），然後返回該字串。當讀取到 EOF 時，將引發
EOFError異常。示例>>> s = input('--> ') --> Monty Python's Flying Circus >>> s "Monty Python's Flying Circus"
如果載入了
readline模組，則input()將使用它來提供精細的行編輯和歷史記錄功能。在讀取輸入之前，使用引數
prompt引發 稽核事件builtins.input成功讀取輸入後，使用結果引發 稽核事件
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__()。如果引數定義了__trunc__()，則返回x.__trunc__()。對於浮點數，這將向零截斷。如果引數不是數字，或者給出了 base，則它必須是字串、
bytes或bytearray例項，表示以 base 為基數的整數。可選地，字串可以以+或-開頭（中間沒有空格），可以有前導零，可以被空格包圍，並且數字之間可以散佈單個下劃線。一個 n 進位制整數字符串包含數字，每個數字表示從 0 到 n-1 的一個值。值 0-9 可以用任何 Unicode 十進位制數字表示。值 10-35 可以用
a到z(或A到Z) 表示。預設的進位制為 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 版本中更改: 委託給
__trunc__()已棄用。在 3.11 版本中更改:
int字串輸入和字串表示可以被限制，以幫助避免拒絕服務攻擊。當將字串轉換為int時超出限制或將int轉換為字串會超出限制時，將引發ValueError。請參閱整數字符串轉換長度限制文件。
- 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(object)¶
- iter(object, sentinel)
返回一個迭代器物件。第一個引數的解釋方式因是否存在第二個引數而異。如果沒有第二個引數，則 object 必須是一個支援可迭代協議（
__iter__()方法）的集合物件，或者它必須支援序列協議（從0開始的整數引數的__getitem__()方法）。如果它不支援這些協議中的任何一個，則會引發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)¶
返回物件的長度（專案數）。引數可以是序列（例如字串、位元組、元組、列表或範圍）或集合（例如字典、集合或凍結集合）。
CPython 實現細節：
len在長度大於sys.maxsize時引發OverflowError，例如range(2 ** 100)。
- class list
- class list(iterable)
與其說是一個函式，不如說
list實際上是一個可變序列型別，如列表和序列型別 — list, tuple, range中所述。
- locals()¶
返回一個對映物件，表示當前的區域性符號表，其中變數名作為鍵，它們當前繫結的引用作為值。
在模組作用域，以及使用
exec()或eval()並使用單個名稱空間時，此函式返回與globals()相同的名稱空間。在類作用域中，它返回將傳遞給元類建構函式的名稱空間。
當使用帶有單獨的區域性和全域性引數的
exec()或eval()時，它會返回傳遞給函式呼叫的區域性名稱空間。在上述所有情況下，在給定的執行幀中每次呼叫
locals()都將返回相同的對映物件。透過locals()返回的對映物件所做的更改將顯示為已賦值、重新賦值或已刪除的區域性變數，並且賦值、重新賦值或刪除區域性變數將立即影響返回的對映物件的內容。在最佳化作用域（包括函式、生成器和協程）中，每次呼叫
locals()都會返回一個新的字典，其中包含該函式區域性變數的當前繫結和任何非區域性單元格引用。在這種情況下，透過返回的字典進行的名稱繫結更改不會寫回到相應的區域性變數或非區域性單元格引用，並且賦值、重新賦值或刪除區域性變數和非區域性單元格引用不會影響先前返回的字典的內容。在函式、生成器或協程中呼叫
locals()作為推導的一部分，等效於在包含作用域中呼叫它，但會包含推導的初始化迭代變數。在其他作用域中，它的行為就好像推導式作為巢狀函式執行一樣。呼叫
locals()作為生成器表示式的一部分，等效於在巢狀的生成器函式中呼叫它。在 3.12 版本中更改: 根據 PEP 709 中的描述，更新了
locals()在推導式中的行為。
- map(function, iterable, *iterables)¶
返回一個迭代器，該迭代器將 function 應用於 iterable 的每個項，併產生結果。如果傳遞了額外的 iterables 引數，則 function 必須接受那麼多引數，並且並行地應用於所有可迭代物件中的項。使用多個可迭代物件時，當最短的可迭代物件耗盡時，迭代器停止。對於函式輸入已經排列成引數元組的情況，請參閱
itertools.starmap()。
- 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，則在迭代器耗盡時返回，否則會引發StopIteration。
- class object¶
這是所有其他類的最終基類。它具有所有 Python 類例項通用的方法。當建構函式被呼叫時，它會返回一個新的無特徵物件。建構函式不接受任何引數。
- 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* 並返回相應的 檔案物件。如果無法開啟檔案，則會引發
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* 引數時，預設的緩衝策略按如下方式工作二進位制檔案以固定大小的塊進行緩衝；緩衝區的大小是透過使用啟發式方法來確定的，該方法嘗試確定底層裝置的 “塊大小”，並回退到
io.DEFAULT_BUFFER_SIZE。在許多系統上，緩衝區通常為 4096 或 8192 位元組長。“互動式” 文字檔案（
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 來使用自定義的 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。使用引數
path、mode、flags引發 審計事件open。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(c)¶
給定一個表示一個 Unicode 字元的字串，返回一個表示該字元的 Unicode 碼位的整數。例如，
ord('a')返回整數97，而ord('€')(歐元符號) 返回8364。這是chr()的逆函式。
- 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型別的運算元底數和指數，如果存在 模數，則 模數 也必須是整數型別，且 模數 必須非零。如果存在 模數 且指數為負數，則底數必須與模數互質。在這種情況下，返回pow(inv_base, -exp, mod)，其中 inv_base 是 底數 模 模數 的逆元。下面是一個計算
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”，併為 voltage 設定文件字串為 “Get the current voltage.”。- @getter¶
- @setter¶
- @deleter¶
屬性物件具有
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實際上不是一個函式，而是一個不可變的序列型別，如 範圍 和 序列型別 — 列表，元組，範圍 中所述。
- 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(seq)¶
返回一個反向 迭代器。seq 必須是一個具有
__reversed__()方法或支援序列協議的物件（__len__()方法和__getitem__()方法，其整數引數從0開始）。
- 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。 這不是一個錯誤：這是因為大多數十進位制小數不能完全表示為浮點數的結果。有關更多資訊，請參見 浮點運算：問題和限制。
- class set
- 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¶
切片物件具有隻讀資料屬性
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()函式保證是穩定的。如果排序保證不改變相等元素的相對順序，則排序是穩定的 —— 這對於多次排序很有幫助（例如，先按部門排序，然後再按工資等級排序）。排序演算法僅使用專案之間的
<比較。雖然定義一個__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(object='')
- class str(object=b'', encoding='utf-8', errors='strict')
返回 object 的
str版本。有關詳細資訊，請參閱str()。str是內建的字串 類。有關字串的常規資訊，請參閱 文字序列型別 — str。
- sum(iterable, /, start=0)¶
從左到右求 start 和 iterable 的專案之和，並返回總和。 iterable 的專案通常是數字，並且不允許 start 值是字串。
對於某些用例，
sum()有很好的替代方案。連線字串序列的首選快速方法是呼叫''.join(sequence)。要使用擴充套件精度新增浮點值，請參閱math.fsum()。要連線一系列可迭代物件，請考慮使用itertools.chain()。在 3.8 版本中更改: start 引數可以指定為關鍵字引數。
在 3.12 版本中更改: 浮點數的求和切換到一種演算法，該演算法在大多數構建中提供更高的精度和更好的可交換性。
- 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()使用的方法解析搜尋順序。該屬性是動態的，並且可以在繼承層次結構更新時更改。如果省略第二個引數，則返回的 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()[name]）的隱式查詢，super()是未定義的。另請注意，除了零引數形式外，
super()不僅限於在方法內部使用。兩引數形式精確指定了引數並進行了適當的引用。零引數形式僅在類定義內部有效，因為編譯器會填充必要的細節以正確檢索正在定義的類，以及訪問普通方法的當前例項。有關如何使用
super()設計協作類的實用建議，請參閱使用 super() 的指南。
- class tuple
- class tuple(iterable)
tuple實際上是一個不可變的序列型別，而不是一個函式，如元組和序列型別 — 列表、元組、範圍中所述。
- class type(object)¶
- class type(name, bases, dict, **kwds)
使用一個引數，返回一個 *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()的可迭代物件可能具有不同的長度；有時是設計使然，有時是因為準備這些可迭代物件的程式碼中存在錯誤。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
在這裡，從
__import__()返回spam.ham模組。從此物件中檢索要匯入的名稱，並將其分配給各自的名稱。如果只是想按名稱匯入模組（可能在包內），請使用
importlib.import_module()。3.3 版本更改: 不再支援 *level* 的負值（這也將預設值更改為 0）。
3.9 版本更改: 當使用命令列選項
-E或-I時，現在將忽略環境變數PYTHONCASEOK。
腳註