# 內建函式

Python 直譯器有內建多個可隨時使用的函式和型別。以下按照英文字母排序列出。

內建函式
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `breakpoint()` `bytearray()` `bytes()` C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` `dict()` `dir()` `divmod()` | E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` `frozenset()` G `getattr()` `globals()` H `hasattr()` `hash()` `help()` `hex()` I `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()` | L `len()` `list()` `locals()` M `map()` `max()` `memoryview()` `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()` | R `range()` `repr()` `reversed()` `round()` S `set()` `setattr()` `sentinel()` `slice()` `sorted()` `staticmethod()` `str()` `sum()` `super()` T `tuple()` `type()` V `vars()` Z `zip()` _ `__import__()`

abs(number, /)

  回傳一個數的絕對值，引數可以是整數、浮點數或有實現 `__abs__()` 的物件。如果引數是一個複數，回傳它的純量（大小）。

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

awaitable anext(async_iterator, /)
awaitable anext(async_iterator, default, /)

  當進入 await 時，從給定的 asynchronous iterator 中回傳下一個項目（item），疊代完畢則回傳 default 。

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

  呼叫 async_iterator 的 `__anext__()` 方法，回傳 awaitable。等待回傳疊代器的下一個值。如果指定 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()`，回傳一個表示物件的字串，但是 `repr()` 回傳的字串中非 ASCII 編碼的字元會被跳脫 (escape)，像是 `\x`、`\u` 和 `\U`。這個函式生成的字串和 Python 2 的 `repr()` 回傳的結果相似。

bin(integer, /)

  將一個整數轉變為一個前綴為 "0b" 的二進位制字串。結果是一個有效的 Python 運算式。如果 integer 不是 Python 的 `int` 物件，那它需要定義 `__index__()` method 回傳一個整數。舉例來說：

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

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

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

  也請參閱 `enum.bin()` 以二補數表示負數。

  可參考 `format()` 取得更多資訊。

class bool(object=False, /)

  回傳一個布林值，即 `True` 或者 `False`。引數會使用標準的真值測試程序來轉換。如果引數為假或者被省略，則回傳 `False`；其他情況回傳 `True`。`bool` class（類別）是 `int` 的 subclass（子類別）（參見 數值型別 --- int、float、complex），其他 class 不能繼承自它。它只有 `False` 和 `True` 兩個實例（參見 Boolean 型別 - 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()` 被替換了，則無法保證此功能。

  引發一個附帶引數 `breakpointhook` 的稽核事件 `builtins.breakpoint`。

  在 3.7 版被加入.

class bytearray(source=b'')
class bytearray(source, encoding, errors='strict')

  回傳一個新的 bytes 陣列。`bytearray` class 是一個可變的整數序列，包含範圍為 0 <= x < 256 的整數。它有可變序列大部分常見的 method（如在 可變序列型別 中所述），同時也有 `bytes` 型別大部分的 method，參見 Bytes 和 Bytearray 的操作。

  選擇性參數 source 可以被用來以不同的方式初始化陣列：

  - 如果是一個 string，你必須提供 encoding 參數（以及選擇性地提供 errors ）；`bytearray()` 會使用 `str.encode()` method 來將 string 轉變成 bytes。

  - 如果是一個 integer，陣列則會有該數值的長度，並以 null bytes 來當作初始值。

  - 如果是一個符合 buffer 介面的物件，該物件的唯讀 buffer 會被用來初始化 bytes 陣列。

  - 如果是一個 iterable，它的元素必須是範圍為 `0 <= x < 256` 的整數，並且會被用作陣列的初始值。

  如果沒有引數，則建立長度為 0 的陣列。

  可參考 Binary Sequence Types --- bytes, bytearray, memoryview 和 Bytearray 物件。

class bytes(source=b'')
class bytes(source, encoding, errors='strict')

  回傳一個新的 "bytes" 物件，會是一個元素是範圍為 `0 <= x < 256` 整數的不可變序列。`bytes` 是 `bytearray` 的不可變版本 — 它的同樣具備不改變物件的 method，也有相同的索引和切片操作。

  因此，建構函式的引數和 `bytearray()` 相同。

  Bytes 物件還可以用文字建立，參見 String and Bytes literals。

  可參考 Binary Sequence Types --- bytes, bytearray, memoryview、Bytes Objects 和 Bytes 和 Bytearray 的操作。

callable(object, /)

  如果引數 object 是可呼叫的，回傳 `True`，否則回傳 `False`。如果回傳 `True`，呼叫仍可能會失敗；但如果回傳 `False`，則呼叫 object 肯定會失敗。注意 class 是可呼叫的（呼叫 class 會回傳一個新的實例）；如果實例的 class 有定義 `__call__()` method，則它是可呼叫的。

  在 3.2 版被加入: 這個函式一開始在 Python 3.0 被移除，但在 Python 3.2 又被重新加入。

chr(codepoint, /)

  回傳代表有特定 Unicode 編碼位置字元的字串。例如，`chr(97)` 回傳字串 `'a'`，而 `chr(8364)` 回傳字串 `'€'`。這是 `ord()` 的逆函式。

  引數的有效範圍是 0 到 1,114,111（16 進制表示為 0x10FFFF）。如果它超過這個範圍，會引發 `ValueError`。

@classmethod

  把一個 method 封裝成 class method（類別方法）。

  一個 class method 把自己的 class 作為第一個引數，就像一個實例 method 把實例自己作為第一個引數。請用以下慣例來宣告 class method：

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

  `@classmethod` 語法是一個函式 decorator — 參見 函式定義 中關於函式定義的詳細介紹。

  一個 class method 可以在 class（如 `C.f()`）或實例（如 `C().f()`）上呼叫。實例除了它的 class 資訊，其他都會被忽略。如果一個 class method 在 subclass 上呼叫，subclass 會作為第一個引數傳入。

  Class method 和 C++ 與 Java 的 static method 是有區別的。如果你想瞭解 static method，請看本節的 `staticmethod()`。關於 class method 的更多資訊，請參考標準型別階層。

  在 3.9 版的變更: Class methods 現在可以包裝其他描述器，例如 `property()`

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

  自從版本 3.11 後不推薦使用，已從版本 3.13 中移除。: Class methods 不能再包裝其他的描述器，例如 `property()`。

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

  將 source 編譯成程式碼或 AST 物件。程式碼物件可以被 `exec()` 或 `eval()` 執行。source 可以是一般的字串、bytes 字串、或者 AST 物件。參見 `ast` module（模組）的說明文件瞭解如何使用 AST 物件。

  filename 引數必須是程式碼的檔名；如果程式碼不是從檔案中讀取，可以傳入一些可辨識的值（經常會使用 `'<string>'` 來替代）。

  mode 引數指定了編譯程式碼時必須用的模式。如果 source 是一系列的陳述式，可以是 `'exec'`；如果是單一運算式，可以是 `'eval'`；如果是單個互動式陳述式，可以是 `'single'`（在最後一種情況下，如果運算式執行結果不是 `None` 則會被印出來）。

  可選引數 flags 和 dont_inherit 控制啟用哪個編譯器選項以及允許哪個未來功能。如果兩者都不存在（或兩者都為零），則會呼叫與 `compile()` 相同旗標的程式碼來編譯。如果給定 flags 引數而未給定 dont_inherit（或為零）則無論如何都會使用由 flags 引數所指定的編譯器選項和未來陳述式。如果 dont_inherit 是一個非零整數，則使用 flags 引數 -- 周圍程式碼中的旗標（未來功能和編譯器選項）將被忽略。

  編譯器選項和 future 陳述式使用 bits 來表示，可以一起被位元操作 OR 來表示複數個選項。需要被具體定義特徵的位元域可以透過 `__future__` module 中 `_Feature` 實例中的 `compiler_flag` 屬性來獲得。編譯器旗標可以在 `ast` module 中搜尋有 `PyCF_` 前綴的名稱。

  引數 optimize 用來指定編譯器的最佳化級別；預設值 `-1` 選擇與直譯器的 `-O` 選項相同的最佳化級別。其他級別為 `0`（沒有最佳化；`__debug__` 為真值）、`1`（assert 被刪除，`__debug__` 為假值）或 `2`（說明字串 (docstring) 也被刪除）。

  The optional argument module specifies the module name. It is needed to unambiguous filter syntax warnings by module name.

  如果編譯的原始碼無效，此函式會引發 `SyntaxError` 或 `ValueError`。

  如果你想解析 Python 程式碼為 AST 運算式，請參閱 `ast.parse()`。

  引發一個附帶引數 `source`、`filename` 的稽核事件 `compile`。此事件也可能由隱式編譯 (implicit compilation) 所引發。

  備註

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

  警告

  如果編譯足夠大或者足夠複雜的字串成 AST 物件時，Python 直譯器會因為 Python AST 編譯器的 stack 深度限制而崩潰。

  在 3.2 版的變更: 允許使用 Windows 和 Mac 的換行符號。此外，在 `'exec'` 模式不需要以換行符號結尾。增加了 optimize 參數。

  在 3.5 版的變更: 在之前的版本，source 中包含 null bytes 會引發 `TypeError`。

  在 3.8 版被加入: `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` 現在可以傳遞旗標以啟用對頂層 `await`、`async for` 和 `async with` 的支援。

  在 3.15 版被加入: Added the module parameter.

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") |
                    floatvalue sign absfloatvalue ("j" | "J")

  如果引數是一個數字，則建構函式會像 `int` 和 `float` 一樣進行數值轉換。對於一個普通的 Python 物件 `x`，`complex(x)` 會委派給 `x.__complex__()`。如果 `__complex__()` 未定義，則會回退 (fall back) 到 `__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 識別符 (identifier)（請見 `setattr()`）。

class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

  建立一個新的 dictionary（字典）。`dict` 物件是一個 dictionary class。參見 `dict` 和 Mapping types --- dict, frozendict 來瞭解這個 class。

  其他容器型別，請參見內建的 `list`、`set` 和 `tuple` class，以及 `collections` module。

dir()
dir(object, /)

  如果沒有引數，則回傳目前區域作用域 (local scope) 中的名稱列表。如果有引數，它會嘗試回傳該物件的有效屬性列表。

  如果物件有一個名為 `__dir__()` 的 method，那麼該 method 將被呼叫，並且必須回傳一個屬性列表。這允許實現自訂 `__getattr__()` 或 `__getattribute__()` 函式的物件能夠自訂 `dir()` 來報告它們的屬性。

  如果物件不提供 `__dir__()`，這個函式會嘗試從物件已定義的 `__dict__` 屬性和型別物件收集資訊。結果列表並不總是完整的，如果物件有自訂 `__getattr__()`，那結果可能不準確。

  預設的 `dir()` 機制對不同型別的物件有不同行為，它會試圖回傳最相關而非最完整的資訊：

  - 如果物件是 module 物件，則列表包含 module 的屬性名稱。

  - 如果物件是型別或 class 物件，則列表包含它們的屬性名稱，並且遞迴查詢其基礎的所有屬性。

  - 否則，包含物件的屬性名稱列表、它的 class 屬性名稱，並且遞迴查詢它的 class 的所有基礎 class 的屬性。

  回傳的列表按字母表排序，例如：

      >>> 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__', '__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()` 主要是為了便於在互動式提示字元時使用，所以它會試圖回傳人們感興趣的名稱集合，而不是試圖保證結果的嚴格性或一致性，它具體的行為也可能在不同版本之間改變。例如，當引數是一個 class 時，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)

  回傳一個列舉 (enumerate) 物件。iterable 必須是一個序列、iterator 或其他支援疊代的物件。`enumerate()` 回傳之 iterator 的 `__next__()` method 回傳一個 tuple（元組），裡面包含一個計數值（從 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)
  參數:

    - source (`str` | code object) -- 一個 Python 運算式。

    - globals (`dict` | `frozendict` | `None`) -- 全域命名空間（預設值：`None`）。

    - locals (mapping | `None`) -- 區域命名空間（預設：`None`）。

  回傳:

    被求值的運算式之結果。

  引發:

    語法錯誤會報告為例外。

  警告

  此函式會執行任意程式碼。以不受信任的使用者提供的輸入來呼叫它將導致安全漏洞。

  source 引數會被視為一條 Python 運算式（技術上而言，是條件列表）來剖析及求值，而 globals 和 locals 對映分別用作全域和區域命名空間。如果 globals dictionary 存在但缺少 `__builtins__` 的鍵值，那 source 被剖析之前，將為該鍵插入對內建 `builtins` module dictionary 的引用。覆寫 `__builtins__` 可以用來限制或更改可用的名稱，但這不是一種安全機制：被執行的程式碼仍然可以存取所有內建名稱。如果 locals 對映被省略，那它的預設值是 globals dictionary。如果兩個對映都被省略，則以在 `eval()` 被呼叫的環境中的 globals 和 locals 執行原始碼。請注意，eval() 在封閉 (enclosing) 環境中無法存取巢狀作用域 (non-locals)，除非呼叫 `eval()` 的作用域已經有參照它們（例如透過 `nonlocal` 陳述式）。

  範例：

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

  這個函式也可以用來執行任意程式碼物件（如被 `compile()` 建立的那些）。這種情況下，傳入的引數是程式碼物件而不是字串。如果編譯該物件時的 mode 引數是 `'exec'`，那麼 `eval()` 回傳值為 `None`。

  提示：`exec()` 函式支援動態執行陳述式。`globals()` 和 `locals()` 函式分別回傳目前的全域性和局部性 dictionary，它們對於將引數傳遞給 `eval()` 或 `exec()` 可能會方便許多。

  如果給定來源是一個字串，那麼其前後的空格和定位字元會被移除。

  另外可以參閱 `ast.literal_eval()`，該函式可用來執行僅包含文字的運算式字串。

  引發一個附帶程式碼物件為引數的稽核事件 `exec`。也可能會引發程式碼編譯事件。

  在 3.13 版的變更: globals 和 locals 引數現在可以作為關鍵字傳遞。

  在 3.13 版的變更: 如 `locals()` 內建物件所述，已調整預設 locals 命名空間的語意。

  在 3.15 版的變更: globals can now be a `frozendict`.

exec(source, /, globals=None, locals=None, *, closure=None)

  警告

  此函式會執行任意程式碼。以不受信任的使用者提供的輸入來呼叫它將導致安全漏洞。

  這個函式支援動態執行 Python 程式碼。source 必須是字串或者程式碼物件。如果是字串，那麼該字串將被剖析為一系列 Python 陳述式並執行（除非發生語法錯誤）。[1] 如果是程式碼物件，它將被直接執行。無論哪種情況，被執行的程式碼都需要和檔案輸入一樣是有效的（可參閱語言參考手冊中關於檔案輸入的章節）。請注意，即使在傳遞給 `exec()` 函式的程式碼的上下文中，`nonlocal`、`yield` 和 `return` 陳述式也不能在函式之外使用。該函式回傳值是 `None`。

  無論哪種情況，如果省略了選擇性的部分，程式碼將在目前作用域內執行。如果只提供了 globals 引數，就必須是 dictionary 型別（且不能是 dictionary 的子類別），而且會被用作全域和區域變數。如果同時提供了 globals 和 locals，它們分別被用作全域和區域變數。如果提供了 locals，則它可以是任何對映物件。請記住在 module 層級中全域和區域變數是相同的 dictionary。

  備註

  當 `exec` 得到兩個獨立的物件作為 globals 和 locals，程式碼會被執行，就像它被嵌入在類別定義中一樣。這表示在執行的程式碼中定義的函式和類別將無法存取在頂層指定的變數（因為在類別定義中，「頂層」變數被視為類別變數）。

  如果 globals dictionary 不包含 `__builtins__` 鍵值，則將為該鍵插入對內建 `builtins` module dictionary 的引用。覆寫 `__builtins__` 可以用來限制或更改可用的名稱，但這不是一種安全機制：被執行的程式碼仍然可以存取所有內建名稱。

  closure 引數會指定一個閉包 (closure) — 它是一個 cellvar（格變數）的 tuple。只有在 object 是一個含有自由（閉包）變數 (free (closure) variables) 的程式碼物件時，它才有效。Tuple 的長度必須與程式碼物件的 `co_freevars` 屬性完全匹配。

  引發一個附帶程式碼物件為引數的稽核事件 `exec`。也可能會引發程式碼編譯事件。

  備註

  內建 `globals()` 和 `locals()` 函式各自回傳目前的全域和區域命名空間，因此可以將它們傳遞給 `exec()` 的第二個和第三個引數以供後續使用。

  備註

  預設情況下，locals 的行為如下面 `locals()` 函式描述的一樣。如果你想在 `exec()` 函式回傳時知道程式碼對 locals 的變動，請明確地傳遞 locals dictionary 。

  在 3.11 版的變更: 增加了 closure 參數。

  在 3.13 版的變更: globals 和 locals 引數現在可以作為關鍵字傳遞。

  在 3.13 版的變更: 如 `locals()` 內建物件所述，已調整預設 locals 命名空間的語意。

  在 3.15 版的變更: globals can now be a `frozendict`.

filter(function, iterable, /)

  用 iterable 中函式 function 為 True 的那些元素，構建一個新的 iterator。iterable 可以是一個序列、一個支援疊代的容器、或一個 iterator。如果 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(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] digitpart
      floatnumber:   number [exponent]
      absfloatvalue: floatnumber | infinity | nan
      floatvalue:    [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='', /)

  將 value 轉換為 format_spec 控制的 "格式化" 表示。format_spec 的解釋取決於 value 引數的型別，但是大多數內建型別使用標準格式化語法：格式規格 (Format Specification) 迷你語言。

  預設的 format_spec 是一個空字串，它通常和呼叫 `str(value)` 的效果相同。

  呼叫 `format(value, format_spec)` 會轉換成 `type(value).__format__(value, format_spec)`，當搜尋 value 的 `__format__()` method 時，會忽略實例中的字典。如果搜尋到 `object` 這個 method 但 format_spec 不為空，或是 format_spec 或回傳值不是字串，則會引發 `TypeError`。

  在 3.4 版的變更: 當 format_spec 不是空字串時，`object().__format__(format_spec)` 會引發 `TypeError`。

class frozenset(iterable=(), /)

  回傳一個新的 `frozenset` 物件，它包含選擇性引數 iterable 中的元素。`frozenset` 是一個內建的 class。有關此 class 的文件，請參閱 `frozenset` 和 Set Types --- set, frozenset。

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

getattr(object, name, /)
getattr(object, name, default, /)

  回傳 object 之具名屬性的值。name 必須是字串。如果該字串是物件屬性之一的名稱，則回傳該屬性的值。例如，`getattr(x, 'foobar')` 等同於 `x.foobar`。如果指定的屬性不存在，且提供了 default 值，則回傳其值，否則引發 `AttributeError`。name 不必是個 Python 識別符 (identifier)（請見 `setattr()`）。

  備註

  由於私有名稱改編 (private name mangling) 是發生在編譯期，因此你必須手動改編私有屬性（有兩個前導底線的屬性）的名稱，才能使用 `getattr()` 來取得它。

globals()

  回傳代表目前 module 命名空間的 dictionary。對於在函式中的程式碼來說，這在定義函式時設定且不論該函式是在何處呼叫都會保持相同。

hasattr(object, name, /)

  該引數是一個物件和一個字串。如果字串是物件屬性之一的名稱，則回傳 `True`，否則回傳 `False`。（此功能是透過呼叫 `getattr(object, name)` 並檢查是否引發 `AttributeError` 來實作的。）

hash(object, /)

  回傳該物件的雜湊值（如果它有的話）。雜湊值是整數。它們在 dictionary 查詢元素時用來快速比較 dictionary 的鍵。相同大小的數字數值有相同的雜湊值（即使它們型別不同，如 1 和 1.0）。

  備註

  請注意，如果物件帶有自訂的 `__hash__()` 方法，`hash()` 將根據運行機器的位元長度來截斷回傳值。

help()
help(request)

  啟動內建的幫助系統（此函式主要以互動式使用）。如果沒有引數，直譯器控制台裡會啟動互動式幫助系統。如果引數是一個字串，則會在 module、函式、class、method、關鍵字或說明文件主題中搜尋該字串，並在控制台上列印幫助資訊。如果引數是其他任意物件，則會生成該物件的幫助頁。

  請注意，呼叫 `help()` 時，如果斜線 (/) 出現在函式的參數列表中，這表示斜線前面的參數是僅限位置 (positional-only) 參數。有關更多資訊，請參閱常見問答集中的僅限位置參數條目。

  此函式會被 `site` module 加入到內建命名空間。

  在 3.4 版的變更: 對於 `pydoc` 和 `inspect` 的變更，使得可呼叫物件回報的的簽名 (signature) 更加全面和一致。

hex(integer, /)

  將整數轉換為以 "0x" 為前綴的小寫十六進位制字串。如果 integer 不是 Python `int` 物件，則必須定義一個 `__index__()` method 並且回傳一個整數。舉例來說：

      >>> 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()` method。

id(object, /)

  回傳物件的 "識別性" 。該值是一個整數，在此物件的生命週期中保證是唯一且恆定的。兩個生命期不重疊的物件可能具有相同的 `id()` 值。

  這是該物件在記憶體中的位址。

  引發一個附帶引數 `id` 的稽核事件 `builtins.id`。

input()
input(prompt, /)

  如果有提供 prompt 引數，則將其寫入標準輸出，末尾不帶換行符。接下來，該函式從輸入中讀取一行，將其轉換為字串（去除末尾的換行符）並回傳。當讀取到 EOF 時，則引發 `EOFError`。例如：

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

  如果載入了 `readline` module，`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__()`。對於浮點數，則會向零的方向無條件捨去。

  如果引數不是數字或如果有給定 base，則它必須是個字串、`bytes` 或 `bytearray` 實例，表示基數 (radix) base 中的整數。可選地，字串之前可以有 `+` 或 `-`（中間沒有空格）、可有個前導的零、也可被空格包圍、或在數字間有單一底線。

  一個 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 的字串將以和程式碼整數字面值 (integer literal in code) 類似的方式來直譯，最後由前綴決定的結果會是 2、8、10、16 進制中的一個，所以 `int('010', 0)` 是非法的，但 `int('010')` 和 `int('010', 8)` 是有效的。

  整數型別定義請參閱數值型別 --- int、float、complex。

  在 3.4 版的變更: 如果 base 不是 `int` 的實例，但 base 物件有 `base.__index__` method，則會呼叫該 method 來取得此進位制所需的整數。以前的版本使用 `base.__int__` 而不是 `base.__index__`。

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

  在 3.7 版的變更: 第一個參數為僅限位置參數。

  在 3.8 版的變更: 如果未定義 `__int__()` 則會回退到 `__index__()`。

  在 3.11 版的變更: `int` 的字串輸入和字串表示法可以被限制，以避免阻斷服務攻擊 (denial of service attack)。在字串 x 轉換為 `int` 時已超出限制，或是在 `int` 轉換為字串時將會超出限制時，會引發 `ValueError`。請參閱整數字串轉換的長度限制說明文件。

  在 3.14 版的變更: `int()` 不再委派給 `__trunc__()` method。

isinstance(object, classinfo, /)

  如果 object 引數是 classinfo 引數的實例，或者是（直接、間接或 virtual）subclass 的實例，則回傳 `True`。如果 object 不是給定型別的物件，函式始終回傳 `False`。如果 classinfo 是包含物件型別的 tuple（或多個遞迴 tuple）或一個包含多種型別的 聯合型別 (Union Type)，若 object 是其中的任何一個物件的實例則回傳 `True`。如果 classinfo 既不是型別，也不是型別 tuple 或型別的遞迴 tuple，那麼會引發 `TypeError` 異常。若是先前檢查已經成功，`TypeError` 可能不會再因為不合格的型別而被引發。

  在 3.10 版的變更: classinfo 可以是一個 聯合型別 (Union Type)。

issubclass(cls, classinfo, /)

  Return `True` if cls 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 recursively, other such tuples) or a 聯合型別 (Union Type), in which case return `True` if cls is a subclass of any entry in classinfo. In any other case, a `TypeError` exception is raised.

  在 3.10 版的變更: classinfo 可以是一個 聯合型別 (Union Type)。

iter(iterable, /)
iter(callable, sentinel, /)

  回傳一個 iterator 物件。根據是否存在第二個引數，第一個引數的意義是非常不同的。如果沒有第二個引數，該單一引數必須是支援 iterable 協定（有 `__iter__()` method）的集合物件，或必須支援序列協定（有 `__getitem__()` 方法，且數字引數從 `0` 開始）。如果它不支援這些協定，會引發 `TypeError`。如果有第二個引數 sentinel，那麼第一引數必須是可呼叫的物件，這種情況下生成的 iterator，每次疊代呼叫 `__next__()` 時會不帶引數地呼叫 callable；如果回傳的結果是 sentinel 則引發 `StopIteration`，否則回傳呼叫結果。

  另請參閱 疊代器型別。

  `iter()` 的第二種形式有一個好用的應用，是能夠建立一個區塊閱讀器 (block-reader)。例如，從二進位資料庫檔案中讀取固定寬度的區塊，直到檔案的結尾：

      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, /)

  回傳物件的長度（元素個數）。引數可以是序列（如 string、bytes、tuple、list 或 range）或集合（如 dictionary、set 或 frozen set）。

  如果物件長度大於 `sys.maxsize`，像是 `range(2 ** 100)`，則 `len` 會引發 `OverflowError`。

class list(iterable=(), /)

  除了是函式，`list` 也是可變序列型別，詳情請參閱 List（串列） 和 Sequence Types --- list, tuple, range。

locals()

  回傳代表目前區域符號表的對映物件，變數名稱為鍵，目前綁定的參照為值。

  在模組作用域，以及使用 `exec()` 或 `eval()` 單一命名空間時，此函式會回傳與 `globals()` 相同的命名空間。

  在類別作用域中，它會回傳將傳遞給元類別 (metaclass) 建構函式的命名空間。

  當使用 `exec()` 或 `eval()`，並分別使用本機和全局參數時，它會回傳傳入函式呼叫的本機命名空間。

  在上述所有情況下，在指定的執行框架中，每次呼叫 `locals()` 都會回傳相同的對映物件。透過 `locals()` 回傳的對映物件所做的變更，會以被指派、重新指派或刪除的區域變數的形式顯示，而指派、重新指派或刪除區域變數會立即影響回傳的對映物件的內容。

  在optimized scope 中（包括函式、產生器和協程），每次呼叫 `locals()` 都會回傳一個新的字典，其中包含函式的區域變數和任何非區域 cell 參照的目前綁定。在這種情況下，透過回傳的字典所做的名稱綁定變更，不會寫回對應的區域變數或非區域 cell 參照，而且指派、重新指派或刪除區域變數和非區域 cell 參照，不會影響先前回傳字典的內容。

  在函式、產生器或協程中作為綜合運算的一部分呼叫 `locals()` 等同於在包含的作用域中呼叫它，但綜合運算已初始化的疊代變數將被包含在內。在其他作用域中，它的行為就像綜合運算作為巢狀函式運行一樣。

  呼叫 `locals()` 作為產生器運算式的一部分，等同於在巢狀的產生器函式中呼叫它。

  在 3.12 版的變更: 如 PEP 709 所述，更新了綜合運算中 `locals()` 的行為。

  在 3.13 版的變更: 作為 PEP 667 的一部分，現在定義了變更此函式回傳的對映物件的語意。在 optimized scopes 中的行為現在如上所述。除了被定義外，其他作用域中的行為與先前版本保持不變。

map(function, iterable, /, *iterables, strict=False)

  產生一個將 function 應用於 iterable 中所有項目並 yield 回傳結果的疊代器。如果傳遞了額外的 iterables 引數，則 function 必須接受相同個數的引數，且 function 會平行地被應用於所有可疊代物件的項目。當有多個可疊代物件時，項目最少的可疊代物件耗盡時疊代器也會結束。如果 strict 為 `True` 且其中一個可疊代物件在其他可疊代物件之前耗盡，則會拋出 `ValueError`。如果函式的輸入已經被編排為引數的元組，請參閱 `itertools.starmap()`。

  在 3.14 版的變更: 增加了 strict 參數。

max(iterable, /, *, key=None)
max(iterable, /, *, default, key=None)
max(arg1, arg2, /, *args, key=None)

  回傳 iterable 中最大的元素，或者回傳兩個以上的引數中最大的。

  如果只提供了一個位置引數，它必須是個 iterable，iterable 中最大的元素會被回傳。如果提供了兩個或以上的位置引數，則回傳最大的位置引數。

  這個函式有兩個選擇性的僅限關鍵字引數。key 引數能指定單一引數所使用的排序函式，如同 `list.sort()` 的使用方式。default 引數是當 iterable 為空時回傳的物件。如果 iterable 為空，並且沒有提供 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)

  回傳由給定的引數所建立之「memory view（記憶體檢視）」物件。有關詳細資訊，請參閱Memory Views。

min(iterable, /, *, key=None)
min(iterable, /, *, default, key=None)
min(arg1, arg2, /, *args, key=None)

  回傳 iterable 中最小的元素，或者回傳兩個以上的引數中最小的。

  如果只提供了一個位置引數，它必須是 iterable，iterable 中最小的元素會被回傳。如果提供了兩個以上的位置引數，則回傳最小的位置引數。

  這個函式有兩個選擇性的僅限關鍵字引數。key 引數能指定單一引數所使用的排序函式，如同 `list.sort()` 的使用方式。default 引數是當 iterable 為空時回傳的物件。如果 iterable 為空，並且沒有提供 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, /)

  透過呼叫 iterator 的 `__next__()` method 取得下一個元素。如果 iterator 耗盡，則回傳給定的預設值 default，如果沒有預設值則引發 `StopIteration`。

class object

  這是所有其他 class 的基礎，它具有所有 Python class 實例的通用 method。當建構函式被呼叫時，它會回傳一個新的沒有特徵 (featureless) 的物件。這個建構函式不接受任何引數。

  備註

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

oct(integer, /)

  將一個整數轉變為一個前綴為 "0o" 的八進位制字串。回傳結果是一個有效的 Python 運算式。如果 integer 不是 Python 的 `int` 物件，那它需要定義 `__index__()` method 回傳一個整數。舉例來說：

      >>> 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 是一個類路徑物件，是將被開啟之檔案的路徑（絕對路徑或目前工作目錄的相對路徑），或是要被包裝 (wrap) 檔案的整數檔案描述器 (file descriptor)。（如果有給定檔案描述器，它會隨著回傳的 I/O 物件關閉而關閉，除非 closefd 被設為 `False`。）

  mode 是一個選擇性字串，用於指定開啟檔案的模式。預設值是 `'r'`，這意味著它以文字模式開啟並讀取。其他常見模式有：寫入 `'w'`（會捨去已經存在的檔案）、唯一性建立 `'x'`、追加寫入 `'a'`（在一些 Unix 系統上，無論目前的檔案指標在什麼位置，所有 寫入都會追加到檔案末尾）。在文字模式，如果沒有指定 encoding，則根據電腦平臺來決定使用的編碼：呼叫 `locale.getencoding()` 來取得目前的本地編碼。（要讀取和寫入原始 bytes，請使用二進位制模式且不要指定 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。

  備註

  Python 不會使用底層作業系統對於文字檔案的操作概念；所有的處理都是由 Python 獨自完成的，因此能獨立於不同平台。

  buffering 是一個選擇性的整數，用於設定緩衝策略。傳入 0 表示關閉緩衝（僅在二進制模式下被允許），1 表示行緩衝（line buffering，僅在文字模式下可用），而 >1 的整數是指示一個大小固定的區塊緩衝區 (chunk buffer)，其位元組的數量。請注意，此類指定緩衝區大小的方式適用於二進制緩衝 I/O，但是 `TextIOWrapper`（以 `mode='r+'` 開啟的檔案）會有另一種緩衝方式。若要在 `TextIOWrapper` 中停用緩衝，可考慮使用 `io.TextIOWrapper.reconfigure()` 的 `write_through` 旗標。若未給定 buffering 引數，則預設的緩衝策略會運作如下：

  - 二進位檔案會以固定大小的區塊進行緩衝；緩衝區的大小為 `max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)`，當裝置區塊大小可用時。在大多數系統上，緩衝區的長度通常為 128 KB。

  - 「互動式」文字檔（`isatty()` 回傳 `True` 的檔案）會使用列緩衝。其他文字檔則使用上述的二進制檔案緩衝策略。

  encoding 是用於解碼或編碼檔案的編碼系統之名稱。它只應該在文字模式下使用。預設的編碼系統會取決於平台（根據 `locale.getencoding()` 回傳的內容），但 Python 支援的任何 text encoding（文字編碼）都是可以使用的。關於支援的編碼系統清單，請參閱 `codecs` module。

  errors is an optional string that specifies how encoding and decoding errors are to be handled—this cannot be used in binary mode. A variety of standard error handlers are available, though any error handling name that has been registered with `codecs.register_error()` is also valid. The standard names can be found in Error Handlers.

  newline 會決定如何剖析資料串流 (stream) 中的換行字元。它可以是 `None`、`''`、`'\n'`、`'\r'` 或 `'\r\n'`。它的運作規則如下：

  - 從資料串流讀取輸入時，如果 newline 是 `None`，則會啟用通用換行模式。輸入資料中的行結尾可以是 `'\n'`、`'\r'` 或 `'\r\n'`，這些符號會被轉換為 `'\n'` 之後再回傳給呼叫方。如果是 `''`，也會啟用通用換行模式，但在回傳給呼叫方時，行尾符號不會被轉換。如果它是任何其他有效的值，則輸入資料的行只會由給定的字串做結尾，且在回傳給呼叫方時，行尾符號不會被轉換。

  - 將輸出寫入資料串流時，如果 newline 是 `None`，則被寫入的任何 `'\n'` 字元都會轉換為系統預設的行分隔符號 `os.linesep`。如果 newline 是 `''` 或 `'\n'`，則不做任何轉換。如果 newline 是任何其他有效的值，則寫入的任何 `'\n'` 字元都將轉換為給定的字串。

  如果 closefd 是 `False`，且給定的 file 引數是一個檔案描述器而不是檔名，則當檔案關閉時，底層的檔案描述器會保持開啟狀態。如果有給定一個檔名，則 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()` 函式回傳的 file object 型別取決於模式。當 `open()` 是在文字模式中開啟檔案時（`'w'`、`'r'`、`'wt'`、`'rt'` 等），它會回傳 `io.TextIOBase` 的一個 subclass（具體來說，就是 `io.TextIOWrapper`）。使用有緩衝的二進制模式開啟檔案時，回傳的 class 則會是 `io.BufferedIOBase` 的 subclass。確切的 class 各不相同：在讀取的二進制模式，它會回傳 `io.BufferedReader`；在寫入和附加的二進制模式，它會回傳 `io.BufferedWriter`，而在讀／寫模式，它會回傳 `io.BufferedRandom`。當緩衝被停用時，會回傳原始資料串流 `io.FileIO`，它是 `io.RawIOBase` 的一個 subclass。

  另請參閱檔案操作模組，例如 `fileinput`、`io`（定義了 `open()` 的 module ）、`os`、`os.path`、`tempfile` 以及 `shutil`。

  引發一個附帶引數 `path`、`mode`、`flags` 的稽核事件 `open`。

  `mode` 和 `flags` 引數可能會被原始的呼叫所修改或推論 (infer)。

  在 3.3 版的變更:

  - 新增 opener 參數。

  - 新增 `'x'` 模式。

  - 過去引發的 `IOError`，現在是 `OSError` 的別名。

  - 如果檔案已存在但使用了唯一性建立模式 (`'x'`)，現在會引發 `FileExistsError`。

  在 3.4 版的變更:

  - 檔案在此版本開始是不可繼承的。

  在 3.5 版的變更:

  - 如果系統呼叫被中斷，但訊號處理程式沒有引發例外，此函式現在會重試系統呼叫，而不是引發 `InterruptedError` 例外（原因詳見 PEP 475）。

  - 增加了 `'namereplace'` 錯誤處理程式。

  在 3.6 版的變更:

  - 增加對於實作 `os.PathLike` 物件的支援。

  - 在 Windows 上，開啟一個控制臺緩衝區可能會回傳 `io.RawIOBase` 的 subclass，而不是 `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(exp, exp)` 等價於次方運算子：`base**exp`。

  當引數為內建數值型別且運算元型別為混合型別時，會套用二元算術運算子的強制轉型 (coercion) 規則。對於 `int` 運算元，運算結果會（在強制轉型後）與運算元的型別相同，除非第二個引數是負數；在這種情況下，所有的引數都會被轉換為浮點數並得到浮點數的結果。例如，`pow(10, 2)` 會回傳 `100`，但 `pow(10, -2)` 會回傳 `0.01`。如果底數 (base) 是型別為 `int` 或 `float` 的負數且指數 (exponent) 為非整數，則會傳回複數結果。例如 `pow(-9, 0.5)` 會回傳一個接近 `3j` 的值。然而，如果底數 (base) 是型別為 `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 的模倒數 (inverse modulo)。

  以下是一個計算 `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)` method 的物件；如果沒有給定或被設為 `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, "我是 'x' 屬性。")

  如果 c 是 C 的一個實例，則 `c.x` 將會叫用取得器 (getter)，`c.x = value` 會呼叫設定器 (setter)，而 `del c.x` 會叫用刪除器 (deleter)。

  如果有給定 doc，它將會是 property 屬性的說明字串。否則，property 會複製 fget 的說明字串（如果它存在的話）。這樣一來，就能夠輕鬆地使用 `property()` 作為裝飾器來建立唯讀屬性：

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

          @property
          def voltage(self):
              """取得目前的電壓。"""
              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):
                """我是 'x' 屬性。"""
                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 版的變更: 屬性物件的 docstrings 現在可以寫入。

  __name__

    持有屬性名稱的屬性。屬性名稱可在 runtime 變更。

    在 3.13 版被加入.

class range(stop, /)
class range(start, stop, step=1, /)

  與其說是函式，`range` 實際上是一個不可變的序列型別，如 Ranges 和 Sequence Types --- 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!r}, {self.age!r})"

reversed(object, /)

  回傳一個反向的疊代器。引數必須是一個擁有 `__reversed__()` 方法或支援序列協定（即 `__len__()` 方法和以 `0` 開始的整數引數的 `__getitem__()` 方法）的物件。

round(number, ndigits=None)

  回傳小數點後四捨五入到 ndigits 精度的 number。如果省略 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 Types --- set, frozenset。

  關於其他容器，請參閱內建的 `frozenset`、`list`、`tuple` 和 `dict` 類別，以及 `collections` 模組。

setattr(object, name, value, /)

  這是 `getattr()` 的對應函式。引數是一個物件、一個字串和一個任意值。該字串可以指定一個現有屬性或一個新的屬性。此函式會將值賦予該屬性，前提是該物件允許這麼做。例如 `setattr(x, 'foobar', 123)` 等效於 `x.foobar = 123`。

  name 不必是 Names (identifiers and keywords) 中定義的 Python 識別字，除非該物件選擇強制要求，例如在自訂的 `__getattribute__()` 中或透過 `__slots__`。名稱不是識別字的屬性將無法使用點記法存取，但可以透過 `getattr()` 等方式存取。

  備註

  由於私有名稱修飾發生在編譯期間，若要使用 `setattr()` 設定私有屬性（名稱以兩個底線開頭的屬性），必須手動修飾其名稱。

class sentinel(name, /, *, repr=None)

  Return a new unique sentinel object. name must be a `str`, and is used by default as the returned object's representation:

      >>> MISSING = sentinel("MISSING")
      >>> MISSING
      MISSING

  The optional repr argument can be used to specify a different representation:

      >>> MISSING = sentinel("MISSING", repr="<MISSING>")
      >>> MISSING
      <MISSING>

  Sentinel objects are truthy and compare equal only to themselves. They are intended to be compared with the `is` operator.

  `sentinel` does not support subclassing.

  Shallow and deep copies of a sentinel object return the object itself.

  Sentinels are conventionally assigned to a variable with a matching name. Sentinels defined in this way can be used in type hints:

      MISSING = sentinel("MISSING")

      def next_value(default: int | MISSING = MISSING):
          ...

  Sentinel objects support the | operator for use in type expressions.

  `Pickling` is supported for sentinel objects that are placed in the global scope of a module under a name matching the sentinel's name, and for sentinels placed in class scopes with a name matching the qualified name of the sentinel. Other sentinels, such as those defined in a function scope, are not picklable. The identity of the sentinel is preserved after pickling:

      import pickle

      PICKLABLE = sentinel("PICKLABLE")

      assert pickle.loads(pickle.dumps(PICKLABLE)) is PICKLABLE

      class Cls:
          PICKLABLE = sentinel("Cls.PICKLABLE")

      assert pickle.loads(pickle.dumps(Cls.PICKLABLE)) is Cls.PICKLABLE

  Sentinel objects have the following attributes:

  __name__

    The sentinel's name.

  __module__

    The name of the module where the sentinel was created. This attribute is writable.

  在 3.15 版被加入.

class slice(stop, /)
class slice(start, stop, step=None, /)

  回傳一個 slice 物件，表示由 `range(start, stop, step)` 指定的索引集合。start 和 step 引數預設為 `None`。

  Slice 物件也會在使用切片語法時產生。例如：`a[start:stop:step]` 或 `a[start:stop, i]`。

  請參閱 `itertools.islice()` 以取得回傳疊代器的替代版本。

  start
  stop
  step

    這些唯讀屬性被設定為引數值（或其預設值）。它們沒有其他明確的功能；然而，它們會被 NumPy 和其他第三方套件使用。

  在 3.12 版的變更: Slice 物件現在是可雜湊的（前提是 `start`、`stop` 和 `step` 都是可雜湊的）。

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

  從 iterable 中的項目回傳一個新的已排序 list。

  有兩個選擇性引數，只能使用關鍵字引數來指定。

  key 指定一個具有一個引數的函式，用於從 iterable 中的每個元素提取比較鍵（例如 `key=str.lower`）。預設值為 `None`（直接比較元素）。

  reverse 是一個布林值。如果設為 `True`，則 list 元素的排序方式如同每次比較都被反轉一樣。

  使用 `functools.cmp_to_key()` 將舊式的 cmp 函式轉換為 key 函式。

  內建的 `sorted()` 函式保證是穩定排序。一個排序如果保證不會改變比較結果相等的元素之間的相對順序，就是穩定的 --- 這對於多次排序很有幫助（例如，先按部門排序，再按薪資等級排序）。

  排序演算法僅使用項目之間的 `<` 比較。雖然定義 `__lt__()` 方法就足以進行排序，但 PEP 8 建議實作全部六個複合比較。這有助於避免在使用相同資料搭配其他排序工具（例如依賴不同底層方法的 `max()`）時產生錯誤。實作全部六個比較也有助於避免混合型別比較時的混淆，因為這種比較可能會呼叫被反映的 `__gt__()` 方法。

  有關排序的範例和簡要的排序教學，請參閱 排序技法。

@staticmethod

  將一個方法轉換為靜態方法 (static method)。

  靜態方法不會接收隱含的第一個引數。要宣告一個靜態方法，請使用以下慣用寫法：

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

  `@staticmethod` 語法是一個函式 decorator - 參見 函式定義 中的詳細介紹。

  靜態方法可以在類別上呼叫（例如 `C.f()`），也可以在實例上呼叫（例如 `C().f()`）。此外，靜態方法的描述器也是可呼叫的，因此可以在類別定義中使用（例如 `f()`）。

  Python 中的靜態方法類似於 Java 或 C++ 中的靜態方法。另請參閱 `classmethod()`，它是一個對於建立替代類別建構式很有用的變體。

  如同所有裝飾器，也可以將 `staticmethod` 作為一般函式呼叫並對其結果進行操作。這在某些情況下是必要的，例如當你需要從類別主體中引用一個函式，且希望避免自動轉換為實例方法時。對於這些情況，請使用以下慣用寫法：

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

  關於 static method 的更多資訊，請參考 標準型別階層。

  在 3.10 版的變更: Static method 現在繼承了 method 屬性（`__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` 是內建的字串類別。有關字串的一般資訊，請參閱 Text Sequence Type --- str。

sum(iterable, /, start=0)

  從左到右加總 start 和一個 iterable 的項目並回傳總和。iterable 的項目通常是數字，且 start 值不允許為字串。

  對於某些使用情境，有比 `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()` 所使用的方法解析搜尋順序。該屬性是動態的，每當繼承階層被更新時就可能改變。

  如果省略第二個引數，回傳的 super 物件就是未繫結的。如果第二個引數是一個物件，`isinstance(obj, type)` 必須為真。如果第二個引數是一個型別，`issubclass(type2, type)` 必須為真（這對類別方法很有用）。

  在類別的一般方法中直接呼叫時，兩個引數都可以省略（「零引數 `super()`」）。在這種情況下，type 將是外圍類別，而 obj 將是直接外圍函式的第一個引數（通常是 `self`）。（這意味著零引數 `super()` 在巢狀函式中將無法如預期般運作，包括隱式建立巢狀函式的產生器運算式。）

  super 有兩種典型的使用情境。在具有單一繼承的類別階層中，super 可以用來參照父類別而不需要明確命名它們，從而使程式碼更易於維護。這種用法與 super 在其他程式語言中的用法非常相似。

  第二種使用情境是在動態執行環境中支援協作式多重繼承。這種使用情境是 Python 獨有的，在靜態編譯語言或僅支援單一繼承的語言中找不到。這使得實作「鑽石圖」（diamond diagrams）成為可能，其中多個基礎類別實作相同的方法。良好的設計要求這些實作在每種情況下都有相同的呼叫簽名（因為呼叫順序是在執行期決定的，因為該順序會適應類別階層的變化，也因為該順序可以包含在執行期之前未知的兄弟類別）。

  對於這兩種使用情境，一個典型的超類別呼叫如下：

      class C(B):
          def method(self, arg):
              super().method(arg)    # 這和以下做法相同：
                                     # super(C, self).method(arg)

  除了方法查找之外，`super()` 也適用於屬性查找。這個功能的一個可能使用情境是在父類別或兄弟類別中呼叫描述器。

  請注意，`super()` 是作為顯式點號屬性查找（例如 `super().__getitem__(name)`）之繫結過程的一部分來實作的。它透過實作自己的 `__getattribute__()` 方法來搜尋類別，以可預測的順序來支援協作式多重繼承。因此，`super()` 對於使用陳述式或運算子的隱式查找（例如 `super()[name]`）是未定義的。

  另外請注意，除了零引數形式之外，`super()` 並不限於在方法內部使用。雙引數形式會精確地指定引數並建立適當的參照。零引數形式只能在類別定義內部使用，因為編譯器會填入必要的細節以正確地取得正在被定義的類別，以及存取一般方法的目前實例。

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

  在 3.14 版的變更: `super` 物件現在可以使用 `pickle` 序列化以及使用 `copy` 複製。

class tuple(iterable=(), /)

  `tuple` 實際上不是一個函式，而是一個不可變的序列型別，如 Tuple（元組） 和 Sequence Types --- list, tuple, range 中所述。

class type(object, /)
class type(name, bases, dict, /, **kwargs)

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

  建議使用內建函式 `isinstance()` 來測試物件的型別，因為它會將子類別納入考量。

  傳入三個引數時，回傳一個新的型別物件。這本質上是 `class` 陳述式的動態形式。name 字串是類別名稱，會成為 `__name__` 屬性。bases tuple 包含基底類別，會成為 `__bases__` 屬性；如果為空，則會加入所有類別的最終基底類別 `object`。dict 字典包含類別主體的屬性和方法定義；它可能會被複製或包裝後才成為 `__dict__` 屬性。以下兩個陳述式會建立相同的 `type` 物件：

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

  另請參閱：

  - 類別的屬性和方法的文件。

  - Type Objects

  提供給三引數形式的關鍵字引數會以與類別定義中的關鍵字（除了 metaclass 之外）相同的方式，傳遞給適當的元類別機制（通常是 `__init_subclass__()`）。

  另請參閱 Customizing class creation。

  在 3.6 版的變更: 沒有覆寫 `type.__new__` 的 `type` 子類別不能再使用單引數形式來取得物件的型別。

  在 3.15 版的變更: dict can now be a `frozendict`.

vars()
vars(object, /)

  回傳模組、類別、實例或任何其他具有 `__dict__` 屬性的物件的 `__dict__` 屬性。

  像模組和實例這樣的物件具有可更新的 `__dict__` 屬性；然而，其他物件的 `__dict__` 屬性可能有寫入限制（例如，類別使用 `types.MappingProxyType` 來防止直接更新字典）。

  不帶引數時，`vars()` 的行為與 `locals()` 相同。

  如果指定了一個物件但它沒有 `__dict__` 屬性（例如，如果它的類別定義了 `__slots__` 屬性），則會引發 `TypeError` 例外。

  在 3.13 版的變更: 不帶引數呼叫此函式的結果已按照內建函式 `locals()` 的說明進行更新。

zip(*iterables, strict=False)

  平行疊代多個可疊代物件，產生包含每個可疊代物件中一個項目的 tuple。

  例如：

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

  更正式地說：`zip()` 回傳一個由 tuple 組成的疊代器，其中第 i 個 tuple 包含來自每個引數可疊代物件的第 i 個元素。

  另一種理解 `zip()` 的方式是它將列（row）轉換為行（column），將行轉換為列。這類似於轉置矩陣。

  `zip()` 是惰性的 (lazy)：元素在可疊代物件被疊代之前不會被處理，例如透過一個 `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` 引數，任何導致可疊代物件長度不同的 bug 都會被隱藏，可能會在程式的其他部分表現為難以發現的 bug。

  - 較短的可疊代物件可以填充常數值，使所有可疊代物件的長度相同。這可以透過 `itertools.zip_longest()` 來完成。

  邊界情況：對於單一可疊代引數，`zip()` 會回傳一個 1-tuple 的疊代器。如果沒有引數，它會回傳一個空的疊代器。

  秘訣與技巧：

  - 可疊代物件的從左至右求值順序是有保證的。這使得使用 `zip(*[iter(s)]*n, strict=True)` 將資料序列聚類為 n 個長度群組的慣用語成為可能。這會重複相同的疊代器 `n` 次，因此每個輸出 tuple 會有 `n` 次呼叫疊代器的結果。這樣做的效果是將輸入分割成 n 個長度的區塊。

  - `zip()` 與 `*` 運算子結合可以用來解壓縮 (unzip) 一個 list：

        >>> 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` 陳述式的語意，但這樣做是強烈不鼓勵的，因為通常使用 import 鉤子（見 PEP 302）來達到相同的目的會比較簡單，而且也不會造成假設使用預設 import 實作的程式碼問題。我們也不鼓勵直接使用 `__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` 會產生類似以下程式碼的位元組碼 (bytecode)：

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

  陳述式 `import spam.ham` 的結果是這樣的呼叫：

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

  請注意 `__import__()` 在這裡如何回傳頂層模組（toplevel module），因為這是由 `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` 現在會被忽略。

註腳

[1]

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