Python 直譯器有內建數十個函式，隨時都可以使用這些函式。以下按照英文字母排序列出。
|
內建函式 |
|||
|
A B C D |
E F G H I |
L M N O P |
R S T V Z _ |
abs(x)
返回一個數的絕對值。 參數可以是整數、浮點數或任何實現了 __abs__() 的物件。 如果參數是一個複數，則返回它的模。
aiter(async_iterable)
返回 asynchronous
iterable 的 asynchronous
iterator 。相當於調用 x.__aiter__()。
注意：與 iter() 不同，aiter() 沒有兩個參數的版本。
3.10 版新加入.
all(iterable)
如果 iterable 的所有元素均為真值（或可反覆運算物件為空）則返回 True 。 等價於：
def all(iterable):
for element in iterable:
if not element:
return False
return True
awaitable anext(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() 獲取更多資訊。
class bool([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 版新加入.
class bytearray([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 對象。
class bytes([source[, encoding[, errors]]])
返回一個新的“bytes”物件，這是一個不可變序列，包含範圍為 0 <= x < 256 的整數。bytes 是 bytearray 的不可變版本——帶有同樣不改變序列的方法，支援同樣的索引、切片操作。
因此，構造函數的實參和 bytearray() 相同。
位元組物件還可以用字面值創建，參見 字串與位元組串字面值。
另見 二進位序列類型 --- bytes, bytearray, memoryview，bytes 對象 和 bytes 和 bytearray 操作。
callable(object)
如果參數 object 是可調用的就返回 True，否則返回 False。 如果返回 True，調用仍可能失敗，但如果返回 False，則調用 object 將肯定不會成功。 請注意類是可調用的（調用類將返回一個新的實例）；如果實例所屬的類有 __call__() 則它就是可調用的。
3.2 版新加入: 這個函數一開始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。
chr(i)
返回 Unicode 碼位元為整數 i 的字元的字串格式。例如，chr(97) 返回字串 'a'，chr(8364) 返回字串 '€'。這是 ord() 的逆函數。
實參的合法範圍是 0 到 1,114,111（16 進制表示是 0x10FFFF）。如果 i 超過這個範圍，會觸發 ValueError 異常。
@classmethod
把一個方法封裝成類方法。
類方法隱含的第一個參數就是類，就像實例方法接收實例作為參數一樣。要聲明一個類方法，按慣例請使用以下方案：
class C:
@classmethod
def f(cls, arg1, arg2): ...
@classmethod 這樣的形式稱為函數的 decorator --
詳情參閱 函式定義。
類方法的調用可以在類上進行 (例如 C.f()) 也可以在實例上進行 (例如 C().f())。 其所屬類以外的類實例會被忽略。 如果類方法在其所屬類的派生類上調用，則該派生類對象會被作為隱含的第一個參數被傳入。
類方法與 C++ 或 Java 中的靜態方法不同。 如果你需要後者，請參閱本節中的 staticmethod()。 有關類方法的更多資訊，請參閱 標準類型層級結構。
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, async for 和 async with 的支持。
class complex([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') 等價於 del x.foobar 。
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
創建一個新的字典。dict 物件是一個字典類。參見 dict 和 映射類型 --- dict 瞭解這個類。
其他容器類型，請參見內置的 list、set 和 tuple 類，以及 collections 模組。
dir([object])
如果沒有實參，則返回當前本地作用域中的名稱列表。如果有實參，它會嘗試返回該物件的有效屬性清單。
如果物件有一個名為 __dir__() 的方法，那麼該方法將被調用，並且必須返回一個屬性清單。這允許實現自訂 __getattr__() 或 __getattribute__() 函數的物件能夠自訂 dir() 來報告它們的屬性。
如果物件未提供 __dir__() 方法，該函數會儘量從物件的 __dict__ 屬性和其類型物件中收集資訊。得到的清單不一定是完整，如果物件帶有自訂 __getattr__() 方法時，結果可能不準確。
默認的 dir() 機制對不同類型的物件行為不同，它會試圖返回最相關而不是最全的資訊：
·
如果物件是模組物件，則清單包含模組的屬性名稱。
·
如果物件是類型或類物件，則清單包含它們的屬性名稱，並且遞迴查找所有基類的屬性。
·
否則，清單包含物件的屬性名稱，它的類屬性名稱，並且遞迴查找它的類的所有基類的屬性。
返回的清單按字母表排序。例如：
>>>
>>> import struct
>>> dir() # show the names in the module
namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct) # show the names in the struct module
['Struct', '__all__', '__builtins__', '__cached__',
'__doc__', '__file__',
'__initializing__',
'__loader__', '__name__', '__package__',
'_clearcache',
'calcsize', 'error', 'pack', 'pack_into',
'unpack',
'unpack_from']
>>> class Shape:
... def __dir__(self):
... return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']
備註
因為 dir() 主要是為了便於在互動式時使用，所以它會試圖返回人們感興趣的名字集合，而不是試圖保證結果的嚴格性或一致性，它具體的行為也可能在不同版本之間改變。例如，當實參是一個類時，metaclass 的屬性不包含在結果清單中。
divmod(a, b)
以兩個（非複數）數字為參數，在作整數除法時，返回商和餘數。若運算元為混合類型，則適用二進位算術運算子的規則。對於整數而言，結果與 (a // b, a % b) 相同。對於浮點數則結果為``(q, a % b)``，其中 q 通常為 math.floor(a / b)，但可能比它小 1。在任何情況下，q * b + a % b 都非常接近 a，如果 a % b 非零，則結果符號與 b 相同，並且 0 <= abs(a % b) < abs(b)。
enumerate(iterable, start=0)
返回一個枚舉物件。iterable 必須是一個序列，或 iterator，或其他支援反覆運算的物件。 enumerate() 返回的反覆運算器的 __next__() 方法返回一個元組，裡面包含一個計數值（從 start 開始，默認為 0）和通過反覆運算 iterable 獲得的值。
>>>
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3,
'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4,
'Winter')]
等價於:
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1
eval(expression[, globals[, locals]])
實參是一個字串，以及可選的 globals 和 locals。globals 實參必須是一個字典。locals 可以是任何映射物件。
運算式解析參數 expression 並作為 Python 運算式進行求值（從技術上說是一個條件列表），採用 globals 和 locals 字典作為全域和局部命名空間。 如果存在 globals 字典，並且不包含 __builtins__ 鍵的值，則在解析 expression 之前會插入以該字串為鍵以對內置模組 builtins 的字典的引用為值的項。 這樣就可以在將 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. object must be either a string or a
code object. If it is a string, the string is parsed as a suite of Python
statements which is then executed (unless a syntax error occurs). 1 If
it is a code object, it is simply executed. In all cases, the code that's
executed is expected to be valid as file input (see the section 檔輸入 in the Reference Manual). Be
aware that the nonlocal, yield,
and return statements
may not be used outside of function definitions even within the context of code
passed to the exec() function.
The return value is None.
無論在什麼情況下，如果省略了可選部分，代碼將運行於當前作用域中。如果只提供了 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 的時候為 (item for item in iterable if function(item))；function 是 None 的時候為 (item for item in iterable if item) 。
請參閱 itertools.filterfalse() 瞭解，只有 function 返回 false 時才選取 iterable 中元素的補充函數。
class float([x])
返回從數位或字串 x 生成的浮點數。
如果參數是個字串，則應包含一個十進位數字字，前面可選帶上符號，也可選前後帶有空白符。符號可以是``'+'`` 或 '-'；'+' 符號對值沒有影響。參數也可以是一個代表 NaN（非數字）或正負無窮大的字串。更確切地說，在去除前導和尾部的空白符後，輸入參數必須符合以下語法：
sign ::=
"+" | "-"
infinity ::=
"Infinity" | "inf"
nan ::=
"nan"
numeric_value ::= floatnumber | infinity
| nan
numeric_string ::=
[sign]
numeric_value
這裡的 floatnumber 是指 Python 的浮點數格式，在 浮點數字面值 中有介紹。大小寫沒有關係，所以“inf”、“Inf”、“INFINITY”、“iNfINity”都可接受為正無窮的拼寫形式。
另一方面，如果實參是整數或浮點數，則返回具有相同值（在 Python 浮點精度範圍內）的浮點數。如果實參在 Python 浮點精度範圍外，則會觸發 OverflowError。
對於一個普通 Python 物件 x，float(x) 會委託給 x.__float__()。 如果 __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。
class frozenset([iterable])
返回一個新的 frozenset 物件，它包含可選參數 iterable 中的元素。 frozenset 是一個內置的類。有關此類的文檔，請參閱 frozenset 和 集合類型 --- set, frozenset。
請參閱內建的 set、list、tuple 和 dict 類，以及 collections 模組來瞭解其它的容器。
getattr(object, name[, default])
返回物件命名屬性的值。name 必須是字串。如果該字串是物件的屬性之一，則返回該屬性的值。例如， getattr(x, 'foobar') 等同於 x.foobar。如果指定的屬性不存在，且提供了 default 值，則返回它，否則觸發 AttributeError。
備註
由於 私有名稱混合 發生在編譯時，因此必須 手動混合私有屬性（以兩個底線打頭的屬性）名稱以使使用 getattr() 來提取它。
globals()
Return the
dictionary implementing the current module namespace. For code within
functions, this is set when the function is defined and remains the same
regardless of where the function is called.
hasattr(object, name)
該實參是一個物件和一個字串。如果字串是物件的屬性之一的名稱，則返回 True，否則返回 False。（此功能是通過調用 getattr(object, name) 看是否有 AttributeError 異常來實現的。）
hash(object)
返回該對象的雜湊值（如果它有的話）。雜湊值是整數。它們在字典查找元素時用來快速比較字典的鍵。相同大小的數位變數有相同的雜湊值（即使它們類型不同，如 1 和 1.0）。
備註
如果物件實現了自己的 __hash__() 方法，請注意，hash() 根據機器的字長來截斷返回值。另請參閱 __hash__()。
help([object])
啟動內置的説明系統（此函數主要在互動式中使用）。如果沒有實參，解譯器控制台裡會啟動互動式説明系統。如果實參是一個字串，則在模組、函數、類、方法、關鍵字或文檔主題中搜索該字串，並在控制台上列印説明資訊。如果實參是其他任意物件，則會生成該物件的説明頁。
請注意，如果在調用 help() 時，目標函數的形參清單中存在斜杠（/），則意味著斜杠之前的參數只能是位置參數。詳情請參閱 有關僅限位置形參的 FAQ 條目。
該函數通過 site 模組加入到內置命名空間。
3.4 版更變: pydoc 和 inspect 的變更使得可調用物件的簽名資訊更加全面和一致。
hex(x)
將整數轉換為以“0x”為首碼的小寫十六進位字串。如果 x 不是 Python int 物件，則必須定義返回整數的 __index__() 方法。一些例子：
>>>
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
如果要將整數轉換為大寫或小寫的十六進位字串，並可選擇有無“0x”首碼，則可以使用如下方法：
>>>
>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')
另見 format() 獲取更多資訊。
另請參閱 int() 將十六進位字串轉換為以 16 為基數的整數。
備註
如果要獲取浮點數的十六進位字串形式，請使用 float.hex() 方法。
id(object)
返回物件的“標識值”。該值是一個整數，在此物件的生命週期中保證是唯一且恒定的。兩個生命期不重疊的物件可能具有相同的 id() 值。
CPython
implementation detail: This is the address of the object in memory.
引發一個 審計事件 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 附帶結果。
class int([x])
class int(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)
Return True if class is a
subclass (direct, indirect, or virtual)
of classinfo. A class is considered a subclass of itself. classinfo may
be a tuple of class objects or a union 類型, in which case return True if class is a
subclass of any entry in classinfo. In any other case, a TypeError exception is raised.
3.10 版更變: classinfo 可以是一個 union 類型。
iter(object[, sentinel])
Return an iterator object.
The first argument is interpreted very differently depending on the presence of
the second argument. Without a second argument, object must be
a collection object which supports the iterable protocol
(the __iter__() method), or it must support the
sequence protocol (the __getitem__() method with integer arguments starting at 0). If it does not support either of
those protocols, TypeError is raised. If the second argument, sentinel,
is given, then object must be a callable object. The iterator
created in this case will call object with no arguments for
each call to its __next__() method; if the value returned is equal
to sentinel, StopIteration will be raised, otherwise the value will be
returned.
另請參閱 反覆運算器類型。
適合 iter() 的第二種形式的應用之一是構建塊讀取器。 例如，從二進位資料庫檔中讀取固定寬度的塊，直至到達檔的末尾:
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。
class list([iterable])
雖然被稱為函數，list 實際上是一種可變序列類型，詳情請參閱 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。
class memoryview(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])
Retrieve the
next item from the iterator by
calling its __next__() method. If default is given,
it is returned if the iterator is exhausted, otherwise StopIteration is raised.
class object
返回一個不帶特徵的新物件。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.open as opener 時與傳遞 None 的效果相同）。
新創建的文件是 不可繼承的。
下面的示例使用 os.open() 函數的 dir_fd 的形參，從給定的目錄中用相對路徑打開檔:
>>>
>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
... return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
... print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd) # don't leak a file descriptor
open() 函數所返回的 file object 類型取決於所用模式。 當使用 open() 以文字模式 ('w', 'r', 'wt', 'rt' 等) 打開文件時，它將返回 io.TextIOBase (特別是 io.TextIOWrapper) 的一個子類。 當使用緩衝以二進位模式打開檔時，返回的類是 io.BufferedIOBase 的一個子類。 具體的類會有多種：在唯讀的二進位模式下，它將返回 io.BufferedReader；在寫入二進位和追加二進位模式下，它將返回 io.BufferedWriter，而在讀/寫模式下，它將返回 io.BufferedRandom。 當禁用緩衝時，則會返回原始流，即 io.RawIOBase 的一個子類 io.FileIO。
另請參閱檔操作模組，如 fileinput、io （聲明了 open()）、os、os.path、tempfile 和 shutil。
引發一個 審計事件 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. For int operands,
the result has the same type as the operands (after coercion) unless the second
argument is negative; in that case, all arguments are converted to float and a
float result is delivered. For example, pow(10, 2) returns 100, but pow(10, -2) returns 0.01. For a negative base of type int or float and
a non-integral exponent, a complex result is delivered. For example, pow(-9, 0.5) returns a value close to 3j.
對於 int 運算元 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 關鍵字參數。
class property(fget=None, fset=None, fdel=None, doc=None)
返回 property 屬性。
fget 是獲取屬性值的函數。 fset 是用於設置屬性值的函數。 fdel 是用於刪除屬性值的函數。並且 doc 為屬性物件創建文檔字串。
一個典型的用法是定義一個託管屬性 x:
class C:
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
如果 c 為 C 的實例，c.x 將調用 getter，c.x = value 將調用 setter， del c.x 將調用 deleter。
如果給出，doc 將成為該 property 屬性的文檔字串。 否則該 property 將拷貝 fget 的文檔字串（如果存在）。 這令使用 property() 作為 decorator 來創建唯讀的特徵屬性可以很容易地實現:
class Parrot:
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current
voltage."""
return self._voltage
以上 @property 裝飾器會將 voltage() 方法轉化為一個具有相同名稱的唯讀屬性的 "getter"，並將 voltage 的文檔字串設置為 "Get the current voltage."
特徵屬性物件具有 getter, setter 以及 deleter 方法，它們可用作裝飾器來創建該特徵屬性的副本，並將相應的訪問函數設為所裝飾的函數。 這最好是用一個例子來解釋:
class C:
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
上述代碼與第一個例子完全等價。 注意一定要給附加函數與原始的特徵屬性相同的名稱 (在本例中為 x。)
返回的特徵屬性物件同樣具有與構造器參數相對應的屬性 fget, fset 和 fdel。
3.5 版更變: 特徵屬性物件的文檔字串現在是可寫的。
class range(stop)
class range(start, stop[, step])
雖然被稱為函數，但 range 實際上是一個不可變的序列類型，參見在 range 對象 與 序列類型 --- list, tuple, range 中的文檔說明。
repr(object)
返回物件的可列印形式字串。對於很多類型而言，本函數試圖返回的字串，會與將物件傳給 eval() 所生成的結果相同；不然，結果就是一個尖括弧包裹的字串，包含了物件類型名稱及其附加資訊，附加資訊通常包括物件的名稱和記憶體位址。通過定義 __repr__() 方法，類可以控制本函數將為實例返回的內容。
reversed(seq)
返回一個反向的 iterator。 seq 必須是一個具有 __reversed__() 方法的物件或者是支援該序列協定（具有從 0 開始的整數類型參數的 __len__() 方法和 __getitem__() 方法）。
round(number[, ndigits])
返回 number 舍入到小數點後 ndigits 位精度的值。 如果 ndigits 被省略或為 None，則返回最接近輸入值的整數。
對於支持 round() 方法的內置類型，結果值會舍入至最接近的 10 的負 ndigits 次冪的倍數；如果與兩個倍數同樣接近，則選用偶數。因此，round(0.5) 和 round(-0.5) 均得出 0 而 round(1.5) 則為 2。ndigits 可為任意整數值（正數、零或負數）。如果省略了 ndigits 或為 None ，則返回值將為整數。否則返回值與 number 的類型相同。
對於一般的 Python 物件 number, round 將委託給 number.__round__。
備註
對浮點數執行 round() 的行為可能會令人驚訝：例如，round(2.675, 2) 將給出 2.67 而不是期望的 2.68。 這不算是程式錯誤：這一結果是由於大多數十進位小數實際上都不能以浮點數精確地表示。 請參閱 浮點數運算：問題與限制 瞭解更多資訊。
class set([iterable])
返回一個新的 set 物件，可以選擇帶有從 iterable 獲取的元素。 set 是一個內置類型。 請查看 set 和 集合類型 --- set, frozenset 獲取關於這個類的文檔。
有關其他容器請參看內置的 frozenset, list, tuple 和 dict 類，以及 collections 模組。
setattr(object, name, value)
本函數與 getattr() 相對應。其參數為一個物件、一個字串和一個任意值。字串可以為某現有屬性的名稱，或為新屬性。只要物件允許，函數會將值賦給屬性。如 setattr(x, 'foobar', 123) 等價於 x.foobar = 123。
備註
由於 私有名稱混合 發生在編譯時，因此必須手動混合私有屬性（以兩個底線打頭的屬性）名稱以便使用 setattr() 來設置它。
class slice(stop)
class slice(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 8 recommends
that all six rich comparisons be
implemented. This will help avoid bugs when using the same data with other
ordering tools such as max() that
rely on a different underlying method. Implementing all six comparisons also
helps avoid confusion for mixed type comparisons which can call reflected
the __gt__() method.
有關排序示例和簡要排序教程，請參閱 如何排序 。
@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__`` 屬性，並且現在還可以作為普通函數進行調用。
class str(object='')
class str(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 形參可用關鍵字參數形式來指定。
class super([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() 的指南。
class tuple([iterable])
雖然被稱為函數，但 tuple 實際上是一個不可變的序列類型，參見在 元組 與 序列類型 --- list, tuple, range 中的文檔說明。
class type(object)
class type(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 命名的模組。
例如，語句 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 現在將被忽略。
沒有留言:
張貼留言