內建函式
********

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

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

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

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

      >>> MISSING = sentinel("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.

   在 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 風格的換行符號。
