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

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()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| **C** "callable()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "classmethod()"   | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(x)

   回傳一個數的絕對值，引數可以是整數、浮點數或有實現 "__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(x)

   將一個整數轉變為一個前綴為 "0b" 的二進位制字串。結果是一個有效的
   Python 運算式。如果 *x* 不是 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')

   可參考 "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)
class bytearray(source, encoding, errors)

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

   選擇性參數 *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 Objects。

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

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

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

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

   可參考 Binary Sequence Types --- bytes, bytearray, memoryview、
   Bytes Objects 和 Bytes and Bytearray Operations。

callable(object)

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

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

chr(i)

   回傳代表字元之 Unicode 編碼位置為整數 *i* 的字串。例如，"chr(97)"
   回傳字串 "'a'"，而 "chr(8364)" 回傳字串 "'€'"。這是 "ord()" 的逆函
   式。

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

@classmethod

   把一個 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__" 屬性。

   Deprecated since version 3.11, removed in version 3.13: Class
   methods 不能再包裝其他的*描述器*，例如 "property()"。

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

   將 *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) 也被刪除）。

   如果編譯的原始碼無效，此函式會引發 "SyntaxError"，如果原始碼包含
   null bytes，則會引發 "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" 的支援。

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

   Convert a single string or number to a complex number, or create a
   complex number from real and imaginary parts.

   例如：

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

   If the argument is a string, it must contain either a real part (in
   the same format as for "float()") or an imaginary part (in the same
   format but with a "'j'" or "'J'" suffix), or both real and
   imaginary parts (the sign of the imaginary part is mandatory in
   this case). The string can optionally be surrounded by whitespaces
   and the round parentheses "'('" and "')'", which are ignored. The
   string must not contain whitespace between "'+'", "'-'", the "'j'"
   or "'J'" suffix, and the decimal number. For example,
   "complex('1+2j')" is fine, but "complex('1 + 2j')" raises
   "ValueError". More precisely, the input must conform to the
   "complexvalue" production rule in the following grammar, after
   parentheses and leading and trailing whitespace characters are
   removed:

      complexvalue ::= floatvalue |
                       floatvalue ("j" | "J") |
                       floatvalue sign absfloatvalue ("j" | "J")

   如果引數是一個數字，則建構函式會像 "int" 和 "float" 一樣進行數值轉
   換。對於一個普通的 Python 物件 "x"，"complex(x)" 會委派給
   "x.__complex__()"。如果 "__complex__()" 未定義，則會回退 (fall
   back) 到 "__float__()"。如果 "__float__()" 未定義，則會再回退到
   "__index__()"。

   If two arguments are provided or keyword arguments are used, each
   argument may be any numeric type (including complex). If both
   arguments are real numbers, return a complex number with the real
   component *real* and the imaginary component *imag*. If both
   arguments are complex numbers, return a complex number with the
   real component "real.real-imag.imag" and the imaginary component
   "real.imag+imag.real". If one of arguments is a real number, only
   its real component is used in the above expressions.

   If all arguments are omitted, returns "0j".

   複數型別在 數值型別 --- int、float、complex 中有相關描述。

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

   在 3.8 版的變更: 如果 "__complex__()" 和 "__float__()" 未定義，則會
   回退到 "__index__()"。

delattr(object, name)

   這是 "setattr()" 相關的函式。引數是一個物件和一個字串，該字串必須是
   物件中某個屬性名稱。如果物件允許，該函式將刪除指定的屬性。例如
   "delattr(x, 'foobar')" 等價於 "del x.foobar"。*name* 不必是個
   Python 識別符 (identifier)（請見 "setattr()"）。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

   建立一個新的 dictionary（字典）。"dict" 物件是一個 dictionary class
   。參見 "dict" 和 Mapping Types --- dict 來瞭解這個 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__', '__cached__', '__doc__', '__file__',
    '__initializing__', '__loader__', '__name__', '__package__',
    '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape:
   ...     def __dir__(self):
   ...         return ['area', 'perimeter', 'location']
   ...
   >>> s = Shape()
   >>> dir(s)
   ['area', 'location', 'perimeter']

   備註:

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

      * **globals** ("dict" | "None") -- The global namespace
        (default: "None").

      * **locals** (*mapping* | "None") -- The local namespace
        (default: "None").

   回傳:
      The result of the evaluated expression.

   引發:
      Syntax errors are reported as exceptions.

   警告:

     This function executes arbitrary code. Calling it with user-
     supplied input may lead to security vulnerabilities.

   *expression* 引數會被視為一條 Python 運算式（技術上而言，是條件列表
   ）來剖析及求值，而 *globals* 和 *locals* 對映分別用作全域和區域命名
   空間。如果 *globals* dictionary 存在但缺少 "__builtins__" 的鍵值，
   那 *expression* 被剖析之前，將為該鍵插入對內建 "builtins" module
   dictionary 的引用。這麼一來，在將 "__builtins__" dictionary 傳入
   "eval()" 之前，你可以透過將它插入 *globals* 來控制你需要哪些內建函
   式來執行程式碼。如果 *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 版的變更: The *globals* and *locals* arguments can now be
   passed as keywords.

   在 3.13 版的變更: The semantics of the default *locals* namespace
   have been adjusted as described for the "locals()" builtin.

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

   警告:

     This function executes arbitrary code. Calling it with user-
     supplied input may lead to security vulnerabilities.

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

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

   備註:

     When "exec" gets two separate objects as *globals* and *locals*,
     the code will be executed as if it were embedded in a class
     definition. This means functions and classes defined in the
     executed code will not be able to access variables assigned at
     the top level (as the "top level" variables are treated as class
     variables in a class definition).

   如果 *globals* dictionary 不包含 "__builtins__" 鍵值，則將為該鍵插
   入對內建 "builtins" module dictionary 的引用。這麼一來，在將
   "__builtins__" dictionary 傳入 "exec()" 之前，你可以透過將它插入
   *globals* 來控制你需要哪些內建函式來執行程式碼。

   *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 版的變更: The *globals* and *locals* arguments can now be
   passed as keywords.

   在 3.13 版的變更: The semantics of the default *locals* namespace
   have been adjusted as described for the "locals()" builtin.

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__()"。

   如果沒有引數，則回傳 "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=set())

   回傳一個新的 "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(x)

   將整數轉換為以 "0x" 為前綴的小寫十六進位制字串。如果 *x* 不是
   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()" 值。

   **CPython 實作細節：** 這是該物件在記憶體中的位址。

   引發一個附帶引數 "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)

   Return an integer object constructed from a number or a string, or
   return "0" if no arguments are given.

   例如：

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

   如果引數定義了 "__int__()"，則 "int(x)" 回傳 "x.__int__()"。如果引
   數定義了 "__index__()" 則回傳 "x.__index__()"。如果引數定義了
   "__trunc__()" 則回傳 "x.__trunc__()"。對於浮點數，則會向零的方向無
   條件捨去。

   如果引數不是數字或如果有給定 *base*，則它必須是個字串、"bytes" 或
   "bytearray" 實例，表示基數 (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 版的變更: 對 "__trunc__()" 的委派已棄用。

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

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(class, classinfo)

   如果 *class* 是 *classinfo* 的 subclass（直接、間接或 *virtual*），
   則回傳 "True"。*classinfo* 可以是 class 物件的 tuple（或遞迴地其他
   類似 tuple）或是一個 聯合型別 (Union Type)，此時若 *class* 是
   *classinfo* 中任一元素的 subclass 時則回傳 "True"。其他情況，會引發
   "TypeError"。

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

iter(object)
iter(object, sentinel)

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

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

   **CPython 實作細節：** 如果物件長度大於 "sys.maxsize"，像是
   "range(2 ** 100)"，則 "len" 會引發 "OverflowError"。

class list
class list(iterable)

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

locals()

      Return a mapping object representing the current local symbol
      table, with variable names as the keys, and their currently
      bound references as the values.

      At module scope, as well as when using "exec()" or "eval()" with
      a single namespace, this function returns the same namespace as
      "globals()".

      At class scope, it returns the namespace that will be passed to
      the metaclass constructor.

      When using "exec()" or "eval()" with separate local and global
      arguments, it returns the local namespace passed in to the
      function call.

      In all of the above cases, each call to "locals()" in a given
      frame of execution will return the *same* mapping object.
      Changes made through the mapping object returned from "locals()"
      will be visible as assigned, reassigned, or deleted local
      variables, and assigning, reassigning, or deleting local
      variables will immediately affect the contents of the returned
      mapping object.

      In an *optimized scope* (including functions, generators, and
      coroutines), each call to "locals()" instead returns a fresh
      dictionary containing the current bindings of the function's
      local variables and any nonlocal cell references. In this case,
      name binding changes made via the returned dict are *not*
      written back to the corresponding local variables or nonlocal
      cell references, and assigning, reassigning, or deleting local
      variables and nonlocal cell references does *not* affect the
      contents of previously returned dictionaries.

      Calling "locals()" as part of a comprehension in a function,
      generator, or coroutine is equivalent to calling it in the
      containing scope, except that the comprehension's initialised
      iteration variables will be included. In other scopes, it
      behaves as if the comprehension were running as a nested
      function.

      Calling "locals()" as part of a generator expression is
      equivalent to calling it in a nested generator function.

   在 3.12 版的變更: The behaviour of "locals()" in a comprehension
   has been updated as described in **PEP 709**.

   在 3.13 版的變更: As part of **PEP 667**, the semantics of mutating
   the mapping objects returned from this function are now defined.
   The behavior in *optimized scopes* is now as described above. Aside
   from being defined, the behaviour in other scopes remains unchanged
   from previous versions.

map(function, iterable, *iterables)

   產生一個將 *function* 應用於 *iterable* 中所有元素，並收集回傳結果
   的 iterator。如果傳遞了額外的 *iterables* 引數，則 *function* 必須
   接受相同個數的引數，並使用所有從 iterables 中同時獲取的元素。當有多
   個 iterables 時，最短的 iteratable 耗盡時 iterator 也會結束。如果函
   式的輸入已經被編排為引數的 tuple，請參閱 "itertools.starmap()"。

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(x)

   將一個整數轉變為一個前綴為 "0o" 的八進位制字串。回傳結果是一個有效
   的 Python 運算式。如果 *x* 不是 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* 引數，則預設的緩衝策略會運作如下：

   * 二進制檔案會以固定大小的區塊進行緩衝；緩衝區的大小是使用啟發式嘗
     試 (heuristic trying) 來決定底層設備的「區塊大小」，並會回退到
     "io.DEFAULT_BUFFER_SIZE"。在許多系統上，緩衝區的長度通常為 4096
     或 8192 個位元組。

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

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

   *errors* 是一個選擇性的字串，用於指定要如何處理編碼和解碼的錯誤——它
   不能在二進制模式下使用。有許多不同的標準錯誤處理程式（error handler
   ，在Error Handlers有列出清單），不過任何已註冊到
   "codecs.register_error()" 的錯誤處理程式名稱也都是有效的。標準的名
   稱包括：

   * "'strict'" 如果發生編碼錯誤，則引發 "ValueError" 例外。預設值
     "None" 也有相同的效果。

   * "'ignore'" 忽略錯誤。請注意，忽略編碼錯誤可能導致資料遺失。

   * "'replace'" 會在格式不正確的資料位置插入一個替換標誌（像是 "'?'"
     ）。

   * "'surrogateescape'" 會將任何不正確的位元組表示為低位代理碼元 (low
     surrogate code unit)，範圍從 U+DC80 到 U+DCFF。在寫入資料時，這些
     代理碼元將會被還原回 "surrogateescape" 錯誤處理程式當時所處理的那
     些相同位元組。這對於處理未知編碼方式的檔案會很好用。

   * "'xmlcharrefreplace'" 僅在寫入檔案時可支援。編碼系統不支援的字元
     會被替換為適當的 XML 字元參考 (character reference) "&#nnn;"。

   * "'backslashreplace'" 會用 Python 的反斜線跳脫序列 (backslashed
     escape sequence) 替換格式不正確的資料。

   * "'namereplace'"（也僅在寫入時支援）會將不支援的字元替換為
     "\N{...}" 跳脫序列。

   *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(c)

   對於代表單個 Unicode 字元的字串，回傳代表它 Unicode 編碼位置的整數
   。例如 "ord('a')" 回傳整數 "97"、"ord('€')"（歐元符號）回傳 "8364"
   。這是 "chr()" 的逆函式。

pow(base, exp, mod=None)

   回傳 *base* 的 *exp* 次方；如果 *mod* 存在，則回傳 *base* 的 *exp*
   次方對 *mod* 取餘數（比直接呼叫 "pow(base, exp) % mod" 計算更高效）
   。兩個引數形式的 "pow(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, "I'm the 'x' property.")

   如果 *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):
              """Get the current voltage."""
              return self._voltage

   The "@property" decorator turns the "voltage()" method into a
   "getter" for a read-only attribute with the same name, and it sets
   the docstring for *voltage* to "Get the current voltage."

   @getter

   @setter

   @deleter

      A property object has "getter", "setter", and "deleter" methods
      usable as decorators that create a copy of the property with the
      corresponding accessor function set to the decorated function.
      This is best explained with an example:

         class C:
             def __init__(self):
                 self._x = None

             @property
             def x(self):
                 """I'm the 'x' property."""
                 return self._x

             @x.setter
             def x(self, value):
                 self._x = value

             @x.deleter
             def x(self):
                 del self._x

      This code is exactly equivalent to the first example.  Be sure
      to give the additional functions the same name as the original
      property ("x" in this case.)

      The returned property object also has the attributes "fget",
      "fset", and "fdel" corresponding to the constructor arguments.

   在 3.5 版的變更: The docstrings of property objects are now
   writeable.

   __name__

      Attribute holding the name of the property. The name of the
      property can be changed at runtime.

      在 3.13 版被加入.

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

   Rather than being a function, "range" is actually an immutable
   sequence type, as documented in Ranges and Sequence Types --- list,
   tuple, range.

repr(object)

   Return a string containing a printable representation of an object.
   For many types, this function makes an attempt to return a string
   that would yield an object with the same value when passed to
   "eval()"; otherwise, the representation is a string enclosed in
   angle brackets that contains the name of the type of the object
   together with additional information often including the name and
   address of the object.  A class can control what this function
   returns for its instances by defining a "__repr__()" method. If
   "sys.displayhook()" is not accessible, this function will raise
   "RuntimeError".

   This class has a custom representation that can be evaluated:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(seq)

   Return a reverse *iterator*.  *seq* must be an object which has a
   "__reversed__()" method or supports the sequence protocol (the
   "__len__()" method and the "__getitem__()" method with integer
   arguments starting at "0").

round(number, ndigits=None)

   Return *number* rounded to *ndigits* precision after the decimal
   point.  If *ndigits* is omitted or is "None", it returns the
   nearest integer to its input.

   For the built-in types supporting "round()", values are rounded to
   the closest multiple of 10 to the power minus *ndigits*; if two
   multiples are equally close, rounding is done toward the even
   choice (so, for example, both "round(0.5)" and "round(-0.5)" are
   "0", and "round(1.5)" is "2").  Any integer value is valid for
   *ndigits* (positive, zero, or negative).  The return value is an
   integer if *ndigits* is omitted or "None". Otherwise, the return
   value has the same type as *number*.

   For a general Python object "number", "round" delegates to
   "number.__round__".

   備註:

     The behavior of "round()" for floats can be surprising: for
     example, "round(2.675, 2)" gives "2.67" instead of the expected
     "2.68". This is not a bug: it's a result of the fact that most
     decimal fractions can't be represented exactly as a float.  See
     浮點數運算：問題與限制 for more information.

class set
class set(iterable)

   Return a new "set" object, optionally with elements taken from
   *iterable*.  "set" is a built-in class.  See "set" and Set Types
   --- set, frozenset for documentation about this class.

   For other containers see the built-in "frozenset", "list", "tuple",
   and "dict" classes, as well as the "collections" module.

setattr(object, name, value)

   This is the counterpart of "getattr()".  The arguments are an
   object, a string, and an arbitrary value.  The string may name an
   existing attribute or a new attribute.  The function assigns the
   value to the attribute, provided the object allows it.  For
   example, "setattr(x, 'foobar', 123)" is equivalent to "x.foobar =
   123".

   *name* need not be a Python identifier as defined in Identifiers
   and keywords unless the object chooses to enforce that, for example
   in a custom "__getattribute__()" or via "__slots__". An attribute
   whose name is not an identifier will not be accessible using the
   dot notation, but is accessible through "getattr()" etc..

   備註:

     Since private name mangling happens at compilation time, one must
     manually mangle a private attribute's (attributes with two
     leading underscores) name in order to set it with "setattr()".

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

   Return a *slice* object representing the set of indices specified
   by "range(start, stop, step)".  The *start* and *step* arguments
   default to "None".

   start

   stop

   step

      Slice objects have read-only data attributes "start", "stop",
      and "step" which merely return the argument values (or their
      default).  They have no other explicit functionality; however,
      they are used by NumPy and other third-party packages.

   Slice objects are also generated when extended indexing syntax is
   used.  For example: "a[start:stop:step]" or "a[start:stop, i]".
   See "itertools.islice()" for an alternate version that returns an
   *iterator*.

   在 3.12 版的變更: Slice objects are now *hashable* (provided
   "start", "stop", and "step" are hashable).

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

   Return a new sorted list from the items in *iterable*.

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

   *key* specifies a function of one argument that is used to extract
   a comparison key from each element in *iterable* (for example,
   "key=str.lower").  The default value is "None" (compare the
   elements directly).

   *reverse* is a boolean value.  If set to "True", then the list
   elements are sorted as if each comparison were reversed.

   Use "functools.cmp_to_key()" to convert an old-style *cmp* function
   to a *key* function.

   The built-in "sorted()" function is guaranteed to be stable. A sort
   is stable if it guarantees not to change the relative order of
   elements that compare equal --- this is helpful for sorting in
   multiple passes (for example, sort by department, then by salary
   grade).

   The sort algorithm uses only "<" comparisons between items.  While
   defining an "__lt__()" method will suffice for sorting, **PEP 8**
   recommends that all six rich comparisons be implemented.  This will
   help avoid bugs when using the same data with other ordering tools
   such as "max()" that rely on a different underlying method.
   Implementing all six comparisons also helps avoid confusion for
   mixed type comparisons which can call reflected the "__gt__()"
   method.

   For sorting examples and a brief sorting tutorial, see 排序技法.

@staticmethod

   Transform a method into a static method.

   A static method does not receive an implicit first argument. To
   declare a static method, use this idiom:

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

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

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()"). Moreover, the static method
   *descriptor* is also callable, so it can be used in the class
   definition (such as "f()").

   Static methods in Python are similar to those found in Java or C++.
   Also, see "classmethod()" for a variant that is useful for creating
   alternate class constructors.

   Like all decorators, it is also possible to call "staticmethod" as
   a regular function and do something with its result.  This is
   needed in some cases where you need a reference to a function from
   a class body and you want to avoid the automatic transformation to
   instance method.  For these cases, use this idiom:

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

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

   在 3.10 版的變更: Static method 現在繼承了 method 屬性（
   "__module__"、"__name__"、"__qualname__"、"__doc__" 和
   "__annotations__"），並擁有一個新的 "__wrapped__" 屬性，且為如一般
   函式的可呼叫物件。

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

   Return a "str" version of *object*.  See "str()" for details.

   "str" is the built-in string *class*.  For general information
   about strings, see Text Sequence Type --- str.

sum(iterable, /, start=0)

   Sums *start* and the items of an *iterable* from left to right and
   returns the total.  The *iterable*'s items are normally numbers,
   and the start value is not allowed to be a string.

   For some use cases, there are good alternatives to "sum()". The
   preferred, fast way to concatenate a sequence of strings is by
   calling "''.join(sequence)".  To add floating-point values with
   extended precision, see "math.fsum()".  To concatenate a series of
   iterables, consider using "itertools.chain()".

   在 3.8 版的變更: *start* 參數可被指定為關鍵字引數。

   在 3.12 版的變更: Summation of floats switched to an algorithm that
   gives higher accuracy and better commutativity on most builds.

class super
class super(type, object_or_type=None)

   Return a proxy object that delegates method calls to a parent or
   sibling class of *type*.  This is useful for accessing inherited
   methods that have been overridden in a class.

   The *object_or_type* determines the *method resolution order* to be
   searched.  The search starts from the class right after the *type*.

   For example, if "__mro__" of *object_or_type* is "D -> B -> C -> A
   -> object" and the value of *type* is "B", then "super()" searches
   "C -> A -> object".

   The "__mro__" attribute of the class corresponding to
   *object_or_type* lists the method resolution search order used by
   both "getattr()" and "super()".  The attribute is dynamic and can
   change whenever the inheritance hierarchy is updated.

   If the second argument is omitted, the super object returned is
   unbound.  If the second argument is an object, "isinstance(obj,
   type)" must be true.  If the second argument is a type,
   "issubclass(type2, type)" must be true (this is useful for
   classmethods).

   When called directly within an ordinary method of a class, both
   arguments may be omitted ("zero-argument "super()""). In this case,
   *type* will be the enclosing class, and *obj* will be the first
   argument of the immediately enclosing function (typically "self").
   (This means that zero-argument "super()" will not work as expected
   within nested functions, including generator expressions, which
   implicitly create nested functions.)

   There are two typical use cases for *super*.  In a class hierarchy
   with single inheritance, *super* can be used to refer to parent
   classes without naming them explicitly, thus making the code more
   maintainable.  This use closely parallels the use of *super* in
   other programming languages.

   The second use case is to support cooperative multiple inheritance
   in a dynamic execution environment.  This use case is unique to
   Python and is not found in statically compiled languages or
   languages that only support single inheritance.  This makes it
   possible to implement "diamond diagrams" where multiple base
   classes implement the same method.  Good design dictates that such
   implementations have the same calling signature in every case
   (because the order of calls is determined at runtime, because that
   order adapts to changes in the class hierarchy, and because that
   order can include sibling classes that are unknown prior to
   runtime).

   For both use cases, a typical superclass call looks like this:

      class C(B):
          def method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

   In addition to method lookups, "super()" also works for attribute
   lookups.  One possible use case for this is calling *descriptors*
   in a parent or sibling class.

   Note that "super()" is implemented as part of the binding process
   for explicit dotted attribute lookups such as
   "super().__getitem__(name)". It does so by implementing its own
   "__getattribute__()" method for searching classes in a predictable
   order that supports cooperative multiple inheritance. Accordingly,
   "super()" is undefined for implicit lookups using statements or
   operators such as "super()[name]".

   Also note that, aside from the zero argument form, "super()" is not
   limited to use inside methods.  The two argument form specifies the
   arguments exactly and makes the appropriate references.  The zero
   argument form only works inside a class definition, as the compiler
   fills in the necessary details to correctly retrieve the class
   being defined, as well as accessing the current instance for
   ordinary methods.

   For practical suggestions on how to design cooperative classes
   using "super()", see guide to using super().

class tuple
class tuple(iterable)

   Rather than being a function, "tuple" is actually an immutable
   sequence type, as documented in Tuples and Sequence Types --- list,
   tuple, range.

class type(object)
class type(name, bases, dict, **kwds)

   With one argument, return the type of an *object*.  The return
   value is a type object and generally the same object as returned by
   "object.__class__".

   The "isinstance()" built-in function is recommended for testing the
   type of an object, because it takes subclasses into account.

   With three arguments, return a new type object.  This is
   essentially a dynamic form of the "class" statement. The *name*
   string is the class name and becomes the "__name__" attribute. The
   *bases* tuple contains the base classes and becomes the "__bases__"
   attribute; if empty, "object", the ultimate base of all classes, is
   added.  The *dict* dictionary contains attribute and method
   definitions for the class body; it may be copied or wrapped before
   becoming the "__dict__" attribute. The following two statements
   create identical "type" objects:

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

   See also:

   * Documentation on attributes and methods on classes.

   * Type Objects

   Keyword arguments provided to the three argument form are passed to
   the appropriate metaclass machinery (usually "__init_subclass__()")
   in the same way that keywords in a class definition (besides
   *metaclass*) would.

   另請參閱 Customizing class creation。

   在 3.6 版的變更: Subclasses of "type" which don't override
   "type.__new__" may no longer use the one-argument form to get the
   type of an object.

vars()
vars(object)

   Return the "__dict__" attribute for a module, class, instance, or
   any other object with a "__dict__" attribute.

   Objects such as modules and instances have an updateable "__dict__"
   attribute; however, other objects may have write restrictions on
   their "__dict__" attributes (for example, classes use a
   "types.MappingProxyType" to prevent direct dictionary updates).

   Without an argument, "vars()" acts like "locals()".

   A "TypeError" exception is raised if an object is specified but it
   doesn't have a "__dict__" attribute (for example, if its class
   defines the "__slots__" attribute).

   在 3.13 版的變更: The result of calling this function without an
   argument has been updated as described for the "locals()" builtin.

zip(*iterables, strict=False)

   Iterate over several iterables in parallel, producing tuples with
   an item from each one.

   例如：

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

   More formally: "zip()" returns an iterator of tuples, where the
   *i*-th tuple contains the *i*-th element from each of the argument
   iterables.

   Another way to think of "zip()" is that it turns rows into columns,
   and columns into rows.  This is similar to transposing a matrix.

   "zip()" is lazy: The elements won't be processed until the iterable
   is iterated on, e.g. by a "for" loop or by wrapping in a "list".

   One thing to consider is that the iterables passed to "zip()" could
   have different lengths; sometimes by design, and sometimes because
   of a bug in the code that prepared these iterables.  Python offers
   three different approaches to dealing with this issue:

   * By default, "zip()" stops when the shortest iterable is
     exhausted. It will ignore the remaining items in the longer
     iterables, cutting off the result to the length of the shortest
     iterable:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "zip()" is often used in cases where the iterables are assumed to
     be of equal length.  In such cases, it's recommended to use the
     "strict=True" option. Its output is the same as regular "zip()":

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     Unlike the default behavior, it raises a "ValueError" if one
     iterable is exhausted before the others:

     >>> 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

     Without the "strict=True" argument, any bug that results in
     iterables of different lengths will be silenced, possibly
     manifesting as a hard-to-find bug in another part of the program.

   * Shorter iterables can be padded with a constant value to make all
     the iterables have the same length.  This is done by
     "itertools.zip_longest()".

   Edge cases: With a single iterable argument, "zip()" returns an
   iterator of 1-tuples.  With no arguments, it returns an empty
   iterator.

   Tips and tricks:

   * The left-to-right evaluation order of the iterables is
     guaranteed. This makes possible an idiom for clustering a data
     series into n-length groups using "zip(*[iter(s)]*n,
     strict=True)".  This repeats the *same* iterator "n" times so
     that each output tuple has the result of "n" calls to the
     iterator. This has the effect of dividing the input into n-length
     chunks.

   * "zip()" in conjunction with the "*" operator can be used to unzip
     a 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)

   備註:

     This is an advanced function that is not needed in everyday
     Python programming, unlike "importlib.import_module()".

   This function is invoked by the "import" statement.  It can be
   replaced (by importing the "builtins" module and assigning to
   "builtins.__import__") in order to change semantics of the "import"
   statement, but doing so is **strongly** discouraged as it is
   usually simpler to use import hooks (see **PEP 302**) to attain the
   same goals and does not cause issues with code which assumes the
   default import implementation is in use.  Direct use of
   "__import__()" is also discouraged in favor of
   "importlib.import_module()".

   The function imports the module *name*, potentially using the given
   *globals* and *locals* to determine how to interpret the name in a
   package context. The *fromlist* gives the names of objects or
   submodules that should be imported from the module given by *name*.
   The standard implementation does not use its *locals* argument at
   all and uses its *globals* only to determine the package context of
   the "import" statement.

   *level* specifies whether to use absolute or relative imports. "0"
   (the default) means only perform absolute imports.  Positive values
   for *level* indicate the number of parent directories to search
   relative to the directory of the module calling "__import__()" (see
   **PEP 328** for the details).

   When the *name* variable is of the form "package.module", normally,
   the top-level package (the name up till the first dot) is returned,
   *not* the module named by *name*.  However, when a non-empty
   *fromlist* argument is given, the module named by *name* is
   returned.

   For example, the statement "import spam" results in bytecode
   resembling the following code:

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

   The statement "import spam.ham" results in this call:

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

   Note how "__import__()" returns the toplevel module here because
   this is the object that is bound to a name by the "import"
   statement.

   On the other hand, the statement "from spam.ham import eggs,
   sausage as saus" results in

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

   Here, the "spam.ham" module is returned from "__import__()".  From
   this object, the names to import are retrieved and assigned to
   their respective names.

   If you simply want to import a module (potentially within a
   package) by name, use "importlib.import_module()".

   在 3.3 版的變更: Negative values for *level* are no longer
   supported (which also changes the default value to 0).

   在 3.9 版的變更: When the command line options "-E" or "-I" are
   being used, the environment variable "PYTHONCASEOK" is now ignored.

-[ 註解 ]-

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