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

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

+---------------------------+-------------------------+-------------------------+---------------------------+
| 內建函式                                                                                                  |
|===========================|=========================|=========================|===========================|
| **A** "abs()" "aiter()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "any()" "anext()" | "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)

   返回  *asynchronous iterable* 的 *asynchronous iterator* 。相当于调
   用 "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[, default])

   当进入 await 状态时，从给定 *asynchronous iterator* 返回下一数据项
   ，迭代完毕则返回 *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([x])

   回傳一個布林值，即 "True" 或者 "False"。*x* 使用標準的真值測試程序
   來轉換。如果 *x* 為假或者被省略，則回傳 "False"；其他情況回傳
   "True"。"bool" class（類別）是 "int" 的 subclass（子類別）（參見 数
   字类型 --- int, float, complex），其他 class 不能繼承自它。它只有
   "False" 和 "True" 兩個實例（參見 布尔值）。

   3.7 版更變: *x* 现在只能作为位置参数。

breakpoint(*args, **kws)

   This function drops you into the debugger at the call site.
   Specifically, it calls "sys.breakpointhook()", passing "args" and
   "kws" straight through.  By default, "sys.breakpointhook()" calls
   "pdb.set_trace()" expecting no arguments.  In this case, it is
   purely a convenience function so you don't have to explicitly
   import "pdb" or type as much code to enter the debugger.  However,
   "sys.breakpointhook()" can be set to some other function and
   "breakpoint()" will automatically call that, allowing you to drop
   into the debugger of choice. If "sys.breakpointhook()" is not
   accessible, this function will raise "RuntimeError".

   引发一个 审计事件 "builtins.breakpoint" 并附带参数 "breakpointhook"
   。

   3.7 版新加入.

class bytearray([source[, encoding[, errors]]])

   回傳一個新的 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 的陣列。

   可參考 二进制序列类型 --- bytes, bytearray, memoryview 和 bytearray
   对象。

class bytes([source[, encoding[, errors]]])

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

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

   Bytes 物件還可以用文字建立，參見 字符串与字节串字面值。

   可參考 二进制序列类型 --- bytes, bytearray, memoryview、bytes 对象
   和 bytes 和 bytearray 操作。

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 版更變: 类方法现在可以包装其他 *描述器* 例如 "property()"。

   3.10 版更變: 类方法现在继承了方法的属性（"__module__"、"__name__"、
   "__qualname__"、"__doc__" 和 "__annotations__"），并拥有一个新的
   ``__wrapped__`` 属性。

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

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

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

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

   可选参数 *flags* 和 *dont_inherit* 控制应当激活哪个 编译器选项 以及
   应当允许哪个 future 特性。 如果两者都未提供 (或都为零) 则代码会应用
   与调用 "compile()" 的代码相同的旗标来编译。 如果给出了 *flags* 参数
   而未给出 *dont_inherit* (或者为零) 则会在无论如何都将被使用的旗标之
   外还会额外使用 *flags* 参数所指定的编译器选项和 future 语句。 如果
   *dont_inherit* 为非零整数，则只使用 *flags* 参数 -- 外围代码中的旗
   标 (future 特性和编译器选项) 会被忽略。

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

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

   如果編譯的原始碼無效，此函式會觸發 "SyntaxError"，如果原始碼包含
   null bytes，則會觸發 "ValueError"。

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

   引发一个 审计事件 "compile" 附带参数 "source", "filename"。

   備註:

     在 "'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([real[, imag]])

   回傳值為 *real* + *imag**1j 的複數，或將字串、數字轉換為複數。如果
   第一個引數是字串，則它被視為一個複數，並且函式呼叫時不得有第二個引
   數。第二個引數絕對不能是字串。每個引數都可以是任意的數值型別（包括
   複數）。如果省略了 *imag*，則預設值為零，建構函式會像 "int" 和
   "float" 一樣進行數值轉換。如果兩個引數都省略，則回傳 "0j"。

   对于一个普通 Python 对象 "x"，"complex(x)" 会委托给
   "x.__complex__()"。  如果 "__complex__()" 未定义则将回退至
   "__float__()"。 如果 "__float__()" 未定义则将回退至 "__index__()"。

   備註:

     當轉換自一字串時，字串在 "+" 或 "-" 運算子的周圍必須不能有空格。
     例如 "complex('1+2j')" 是有效的，但 "complex('1 + 2j')" 會觸發
     "ValueError"。

   複數型別在 数字类型 --- int, float, complex 中有相關描述。

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

   3.8 版更變: 如果 "__complex__()" 和 "__float__()" 未定义则回退至
   "__index__()"。

delattr(object, name)

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

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

   建立一個新的 dictionary（字典）。"dict" 物件是一個 dictionary class
   。參見 "dict" 和 映射类型 --- dict 來瞭解這個 class。

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

dir([object])

   如果沒有引數，則回傳當前本地作用域中的名稱列表。如果有引數，它會嘗
   試回傳該物件的有效屬性列表。

   如果物件有一個名為 "__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(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

eval(expression[, globals[, locals]])

   引數是一個字串，以及選擇性的 globals 和 locals。如果有提供選擇性引
   數，*globals* 必須是一個 dictionary。*locals* 可以是任何映射
   (mapping) 物件。

   *expression* 引數被剖析並執行成 Python 運算式（技術上而言，是條件列
   表），*globals* 和 *locals* dictionaries 分別用作全域性和本地命名空
   間。如果 *globals* dictionary 存在但缺少 "__builtins__" 的鍵值，那
   *expression* 被剖析之前，將為該鍵插入對內建 "builtins" module
   dictionary 的引用。這麼一來，在將 *__builtins__`* 傳入 "eval()" 之
   前，你可以透過將它插入 *globals* 來控制你需要哪些內建函數。如果
   *locals* 被省略，那它的預設值是 *globals* dictionary。如果兩個
   dictionary 變數都被省略，則在 "eval()" 被呼叫的環境中執行運算式。請
   注意，*eval()* 在封閉環境中無法存取*巢狀域* (non-locals)。

   返回值就是表达式的求值结果。 语法错误将作为异常被报告。 例如：

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

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

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

   如果给出的源数据是个字符串，那么其前后的空格和制表符将被剔除。

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

   引发一个 审计事件 "exec" 附带参数 "code_object"。

exec(object[, globals[, locals]])

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

   無論哪種情況，如果省略了選擇性引數，程式碼將在當前作用域內執行。如
   果只提供了 *globals* 引數，就必須是 dictionary 型別，而且會被用作全
   域性和本地變數。如果同時提供了 *globals* 和 *locals* 引數，它們分別
   被用作全域性和本地變數。如果提供了 *locals* 引數，則它可以是任何映
   射物件。請記住在 module 層級中全域性和本地變數是相同的 dictionary。
   如果 exec 有兩個不同的 *globals* 和 *locals* 物件，程式碼就像嵌入在
   class 定義中一樣執行。

   如果 *globals* dictionary 不包含 "__builtins__" 鍵值，則將為該鍵插
   入對內建 "builtins" module dictionary 的引用。因此，在將執行的程式
   碼傳遞給 "exec()" 之前，可以通過將自己的 "__builtins__" dictionary
   插入到 *globals* 中來控制可以使用哪些內建程式碼。

   引发一个 审计事件 "exec" 附带参数 "code_object"。

   備註:

     內建 "globals()" 和 "locals()" 函式各自回傳當前的全域性和本地
     dictionary，因此可以將它們傳遞給 "exec()" 的第二個和第三個引數。

   備註:

     預設情況下，*locals* 的行為如下面 "locals()" 函式描述的一樣：不要
     試圖改變預設的 *locals* dictionary。如果您想在 "exec()" 函式回傳
     時知道程式碼對 *locals* 的變動，請明確地傳遞 *locals* dictionary
     。

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

   回傳從數字或字串 *x* 生成的浮點數。

   If the argument is a string, it should contain a decimal number,
   optionally preceded by a sign, and optionally embedded in
   whitespace.  The optional sign may be "'+'" or "'-'"; a "'+'" sign
   has no effect on the value produced.  The argument may also be a
   string representing a NaN (not-a-number), or positive or negative
   infinity.  More precisely, the input must conform to the
   "floatvalue" production rule in the following grammar, after
   leading and trailing whitespace characters are removed:

      sign        ::= "+" | "-"
      infinity    ::= "Infinity" | "inf"
      nan         ::= "nan"
      digitpart   ::= digit (["_"] digit)*
      number      ::= [digitpart] "." digitpart | digitpart ["."]
      exponent    ::= ("e" | "E") ["+" | "-"] digitpart
      floatnumber ::= number [exponent]
      floatvalue  ::= [sign] (floatnumber | infinity | nan)

   Here "digit" is a Unicode decimal digit (character in the Unicode
   general category "Nd"). Case is not significant, so, for example,
   "inf", "Inf", "INFINITY", and "iNfINity" are all acceptable
   spellings for positive infinity.

   否則，如果引數是整數或浮點數，則回傳具有相同值（在 Python 浮點精度
   範圍內）的浮點數。如果引數在 Python 浮點精度範圍外，則會觸發
   "OverflowError"。

   對於一般的 Python 物件 "x"，"float(x)" 指派給 "x.__float__()"。如果
   未定義 "__float__()" 則使用 "__index__()"。

   如果沒有引數，則回傳 "0.0"。

   例如：

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

   数字类型 --- int, float, complex 描述了浮點數型別。

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

   3.7 版更變: *x* 现在只能作为位置参数。

   3.8 版更變: 如果 "__float__()" 未定义则回退至 "__index__()"。

format(value[, format_spec])

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

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

   呼叫 "format(value, format_spec)" 會轉換成
   "type(value).__format__(value, format_spec)"，當搜尋 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, frozenset。

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

getattr(object, name[, default])

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

   備註:

     由于 私有名称混合 发生在编译时，因此必须 手动混合私有属性（以两个
     下划线打头的属性）名称以使使用 "getattr()" 来提取它。

globals()

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

hasattr(object, name)

   該引數是一個物件和一個字串。如果字串是物件屬性之一的名稱，則回傳
   "True"，否則回傳 "False"。（此功能是通過呼叫 "getattr(object,
   name)" 看是否有 "AttributeError" 來實現的。）

hash(object)

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

   備註:

     請注意，如果物件實現了自己的 "__hash__()" method，"hash()" 根據執
     行機器的位元長度來擷取回傳值。另請參閱 "__hash__()"。

help([object])

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

   请注意，如果在调用 "help()" 时，目标函数的形参列表中存在斜杠（/），
   则意味着斜杠之前的参数只能是位置参数。详情请参阅 有关仅限位置形参的
   FAQ 条目。

   該函式透過 "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 實作細節：** This is the address of the object in memory.

   引发一个 审计事件 "builtins.id"，附带参数 "id"。

input([prompt])

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

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

   如果載入了 "readline" module，"input()" 將使用它來提供複雜的行編輯
   和歷史記錄功能。

   引发一个 审计事件 "builtins.input" 附带参数 "prompt"。

   在成功读取输入之后引发一个 审计事件 "builtins.input/result" 附带结
   果。

class int([x])
class int(x, base=10)

   回傳一個使用數字或字串 *x* 建構的整數物件，或者在沒有引數時回傳 "0"
   。如果 *x* 定義了 "__int__()"，"int(x)" 回傳 "x.__int__()"。如果
   *x* 定義了 "__index__()" 則回傳 "x.__index__()"。如果 *x* 定義了
   "__trunc__()" 則回傳 "x.__trunc__()"。對於浮點數則向零舍入。

   If *x* is not a number or if *base* is given, then *x* must be a
   string, "bytes", or "bytearray" instance representing an integer in
   radix *base*.  Optionally, the string can be preceded by "+" or "-"
   (with no space in between), have leading zeros, be surrounded by
   whitespace, and have single underscores interspersed between
   digits.

   A base-n integer string contains digits, each representing a value
   from 0 to n-1. The values 0--9 can be represented by any Unicode
   decimal digit. The values 10--35 can be represented by "a" to "z"
   (or "A" to "Z"). The default *base* is 10. The allowed bases are 0
   and 2--36. Base-2, -8, and -16 strings can be optionally prefixed
   with "0b"/"0B", "0o"/"0O", or "0x"/"0X", as with integer literals
   in code.  For base 0, the string is interpreted in a similar way to
   an integer literal in code, in that the actual base is 2, 8, 10, or
   16 as determined by the prefix. Base 0 also disallows leading
   zeros: "int('010', 0)" is not legal, while "int('010')" and
   "int('010', 8)" are.

   整數型別定義請參閱 数字类型 --- int, float, complex。

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

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

   3.7 版更變: *x* 现在只能作为位置参数。

   3.8 版更變: 如果 "__int__()" 未定义则回退至 "__index__()"。

   3.10.7 版更變: "int" string inputs and string representations can
   be limited to help avoid denial of service attacks. A "ValueError"
   is raised when the limit is exceeded while converting a string *x*
   to an "int" or when converting an "int" into a string would exceed
   the limit. See the integer string conversion length limitation
   documentation.

isinstance(object, classinfo)

   如果 *object* 引數是 *classinfo* 引數的實例，或者是（直接、間接或
   *virtual*）subclass 的實例，則回傳 "True"。如果 *object* 不是給定型
   別的物件，函式始終回傳 "False"。如果 *classinfo* 是包含物件型別的
   tuple（或多個遞迴 tuple）或一個包含多種型別的 union 类型，若
   *object* 是其中的任何一個物件的實例則回傳 "True"。如果 *classinfo*
   既不是型別，也不是型別 tuple 或型別的遞迴 tuple，那麼會觸發
   "TypeError" 異常。

   3.10 版更變: *classinfo* 可以是一个 union 类型。

issubclass(class, classinfo)

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

   3.10 版更變: *classinfo* 可以是一个 union 类型。

iter(object[, sentinel])

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

   另請參閱 迭代器类型。

   适合 "iter()" 的第二种形式的应用之一是构建块读取器。 例如，从二进制
   数据库文件中读取固定宽度的块，直至到达文件的末尾:

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(s)

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

   **CPython 實作細節：** "len" 对于大于 "sys.maxsize" 的长度如
   "range(2 ** 100)" 会引发 "OverflowError"。

class list([iterable])

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

locals()

   更新並回傳表示當前本地符號表的 dictionary。在函式區塊而不是 class
   區塊中呼叫 "locals()" 時會回傳自由變數。請注意，在 module 階層中，
   "locals()" 和 "globals()" 是相同的 dictionary。

   備註:

     此 dictionary 的內容不應該被更動；更改可能不會影響直譯器使用的本
     地變數或自由變數的值。

map(function, iterable, ...)

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

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

   回傳 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" 物件。有關詳細資訊，請參閱 内
   存视图。

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

   回傳 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[, default])

   通過呼叫 *iterator* 的 "__next__()" method 獲取下一個元素。如果
   iterator 耗盡，則回傳給定的預設值 *default*，如果沒有預設值則觸發
   "StopIteration"。

class object

   回傳一個沒有特徵的新物件。"object" 是所有 class 的基礎，它具有所有
   Python class 實例的通用 method。這個函式不接受任何引數。

   備註:

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

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* 並回傳對應的 *file object*。如果該檔案不能開啟，則觸發
   "OSError"。關於使用此函式的更多方法請參閱讀寫檔案。

   *file* 是一個 *path-like object*，是將被開啟之檔案的路徑（絕對路徑
   或者當前工作目錄的相當路徑），或是被封裝的整數檔案描述器 (file
   descriptor)。（如果有提供檔案描述器，它會隨著回傳的 I/O 物件關閉而
   關閉，除非 *closefd* 被設為 "False"。）

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

   +-----------+-----------------------------------------------------------------+
   | 字元      | 意義                                                            |
   |===========|=================================================================|
   | "'r'"     | 讀取（預設）                                                    |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | 写入，并先截断文件                                              |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | 唯一性創建，如果文件已存在則會失敗                              |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | 寫入，如果文件存在則在末尾追加寫入內容                          |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | 二進制模式                                                      |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | 文字模式（預設）                                                |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | 更新（讀取並寫入）                                              |
   +-----------+-----------------------------------------------------------------+

   預設的模式是 "'r'"（開啟並讀取文字，同 "'rt'"）。對於二進位制寫入，
   "'w+b'" 模式開啟並把檔案內容變成 0 bytes，"'r+b'" 則不會捨棄原始內
   容。

   正如在 總覽 中提到的，Python区分二进制和文本I/O。以二进制模式打开的
   文件（包括 *mode* 参数中的 "'b'" ）返回的内容为 "bytes" 对象，不进
   行任何解码。在文本模式下（默认情况下，或者在 *mode* 参数中包含
   "'t'" ）时，文件内容返回为 "str" ，首先使用指定的 *encoding* （如果
   给定）或者使用平台默认的的字节编码解码。

   另外还有一种模式字符 "'U'" 可用，不过它已失效，并视作弃用。以前它会
   在文本模式中启用 *universal newlines*，这在 Python 3.0 已成为默认行
   为。详情请参阅 newline 形参的文档。

   備註:

     Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完
     成，因此与平台无关。

   *buffering* 是一个可选的整数，用于设置缓冲策略。 传入 0 来关闭缓冲
   （只允许在二进制模式下），传入 1 来选择行缓冲（只在文本模式下可用）
   ，传入一个整数 > 1 来表示固定大小的块缓冲区的字节大小。注意，这样指
   定缓冲区的大小适用于二进制缓冲的 I/O ，但 "TextIOWrapper" （即用
   "mode='r+'" 打开的文件）会有另一种缓冲。要禁用在 "TextIOWrapper" 缓
   冲，考虑使用 "io.TextIOWrapper.reconfigure()" 的 "write_through" 标
   志来。当没有给出 *buffering* 参数时，默认的缓冲策略工作如下。

   * 二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小
     ，尝试确定底层设备的“块大小”或使用 "io.DEFAULT_BUFFER_SIZE"。在许
     多系统上，缓冲区的长度通常为4096或8192字节。

   * “交互式”文本文件（ "isatty()" 返回 "True" 的文件）使用行缓冲。其
     他文本文件使用上述策略用于二进制文件。

   *encoding* 是用于解码或编码文件的编码的名称。这应该只在文本模式下使
   用。默认编码是依赖于平台的（不 管 "locale.getpreferredencoding()"
   返回何值），但可以使用任何Python支持的 *text encoding* 。有关支持的
   编码列表，请参阅 "codecs" 模块。

   *errors* 是一个可选的字符串参数，用于指定如何处理编码和解码错误 -
   这不能在二进制模式下使用。可以使用各种标准错误处理程序（列在 错误处
   理方案 ），但是使用 "codecs.register_error()" 注册的任何错误处理名
   称也是有效的。标准名称包括:

   * 如果存在编码错误，"'strict'" 会引发 "ValueError" 异常。 默认值
     "None" 具有相同的效果。

   * "'ignore'" 忽略错误。请注意，忽略编码错误可能会导致数据丢失。

   * "'replace'" 会将替换标记（例如 "'?'" ）插入有错误数据的地方。

   * "'surrogateescape'" 将把任何不正确的字节表示为 U+DC80 至 U+DCFF
     范围内的下方替代码位。 当在写入数据时使用 "surrogateescape" 错误
     处理句柄时这些替代码位会被转回到相同的字节。 这适用于处理具有未知
     编码格式的文件。

   * 只有在写入文件时才支持 "'xmlcharrefreplace'"。编码不支持的字符将
     替换为相应的XML字符引用 "&#nnn;"。

   * "'backslashreplace'" 用Python的反向转义序列替换格式错误的数据。

   * "'namereplace'" （也只在编写时支持）用 "\N{...}" 转义序列替换不支
     持的字符。

   *newline* determines how to parse newline characters from the
   stream. It can be "None", "''", "'\n'", "'\r'", and "'\r\n'".  It
   works as follows:

   * 从流中读取输入时，如果 *newline* 为 "None"，则启用通用换行模式。
     输入中的行可以以 "'\n'"，"'\r'" 或 "'\r\n'" 结尾，这些行被翻译成
     "'\n'" 在返回呼叫者之前。如果它是 "''"，则启用通用换行模式，但行
     结尾将返回给调用者未翻译。如果它具有任何其他合法值，则输入行仅由
     给定字符串终止，并且行结尾将返回给未调用的调用者。

   * 将输出写入流时，如果 *newline* 为 "None"，则写入的任何 "'\n'" 字
     符都将转换为系统默认行分隔符 "os.linesep"。如果 *newline* 是 "''"
     或 "'\n'"，则不进行翻译。如果 *newline* 是任何其他合法值，则写入
     的任何 "'\n'" 字符将被转换为给定的字符串。

   如果 *closefd* 为 "False" 且给出的不是文件名而是文件描述符，那么当
   文件关闭时，底层文件描述符将保持打开状态。如果给出的是文件名，则
   *closefd* 必须为 "True" （默认值），否则将触发错误。

   可以通过传递可调用的 *opener* 来使用自定义开启器。然后通过使用参数
   （ *file*，*flags* ）调用 *opener* 获得文件对象的基础文件描述符。
   *opener* 必须返回一个打开的文件描述符（使用 "os.open" as *opener*
   时与传递 "None" 的效果相同）。

   新建立的檔案是不可繼承的。

   下面的範例使用 "os.open()" 函式回傳值當作 dir_fd 的參數，從給定的目
   錄中用相對路徑開啟檔案：

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   "open()" 函数所返回的 *file object* 类型取决于所用模式。 当使用
   "open()" 以文本模式 ("'w'", "'r'", "'wt'", "'rt'" 等) 打开文件时，
   它将返回 "io.TextIOBase" (具体为 "io.TextIOWrapper") 的一个子类。
   当使用缓冲以二进制模式打开文件时，返回的类是 "io.BufferedIOBase" 的
   一个子类。 具体的类会有多种：在只读的二进制模式下，它将返回
   "io.BufferedReader"；在写入二进制和追加二进制模式下，它将返回
   "io.BufferedWriter"，而在读/写模式下，它将返回 "io.BufferedRandom"
   。 当禁用缓冲时，则会返回原始流，即 "io.RawIOBase" 的一个子类
   "io.FileIO"。

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

   引发一个 审计事件 "open" 附带参数 "file", "mode", "flags"。

   "mode" 与 "flags" 参数可以在原始调用的基础上被修改或传递。

      3.3 版更變:

      * 增加了 *opener* 參數。

      * 增加了 "'x'" 模式。

      * 過去觸發的 "IOError"，現在是 "OSError" 的別名。

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

      3.4 版更變:

      * 檔案在當前版本開始禁止繼承。

   自從版本 3.4 後不推薦使用，已從版本 3.10 中移除。: "'U'" 模式。

      3.5 版更變:

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

      * 增加了 "'namereplace'" 錯誤處理程式。

      3.6 版更變:

      * 增加對實現了 "os.PathLike" 物件的支援。

      * 在 Windows 上，開啟一個控制臺緩衝區可能會回傳 "io.RawIOBase"
        的 subclass，而不是 "io.FileIO"。

ord(c)

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

pow(base, exp[, mod])

   回傳 *base* 的 *exp* 次方；如果 *mod* 存在，則回傳 *base* 的 *exp*
   次方對 *mod* 取餘數（比直接呼叫 "pow(base, exp) % mod" 計算更高效）
   。兩個引數形式的 "pow(exp, exp)" 等價於次方運算子："base**exp"。

   参数必须为数值类型。 对于混用的操作数类型，则适用二元算术运算符的类
   型强制转换规则。 对于 "int" 操作数，结果具有与操作数相同的类型（转
   换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点
   数并输出浮点数结果。 例如，"pow(10, 2)" 返回 "100"，但 "pow(10,
   -2)" 返回 "0.01"。 对于 "int" 或 "float" 类型的负基和一个非整数的指
   数，会产生一个复杂的结果。 例如， "pow(-9, 0.5)" 返回一个接近于
   "3j" 的值。

   对于 "int" 操作数 *base* 和 *exp*，如果给出 *mod*，则 *mod* 必须为
   整数类型并且 *mod* 必须不为零。 如果给出 *mod* 并且 *exp* 为负值，
   则 *base* 必须相对于 *mod* 不可整除。 在这种情况下，将会返回
   "pow(inv_base, -exp, mod)"，其中 *inv_base* 为 *base* 的倒数对
   *mod* 取余。

   下面的例子是 "38" 的倒数对 "97" 取余:

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

   3.8 版更變: 对于 "int" 操作数，三参数形式的 "pow" 现在允许第二个参
   数为负值，即可以计算倒数的余数。

   3.8 版更變: 允许关键字参数。 之前只支持位置参数。

print(*objects, sep=' ', end='\n', file=None, flush=False)

   将 *objects* 打印输出至 *file* 指定的文本流，以 *sep* 分隔并在末尾
   加上 *end*。 *sep* 、 *end* 、 *file* 和 *flush* 必须以关键字参数的
   形式给出。

   所有非关键字参数都会被转换为字符串，就像是执行了 "str()" 一样，并会
   被写入到流，以 *sep* 且在末尾加上 *end*。 *sep* 和 *end* 都必须为字
   符串；它们也可以为 "None"，这意味着使用默认值。 如果没有给出
   *objects*，则 "print()" 将只写入 *end*。

   *file* 参数必须是一个具有 "write(string)" 方法的对象；如果参数不存
   在或为 "None"，则将使用 "sys.stdout"。 由于要打印的参数会被转换为文
   本字符串，因此 "print()" 不能用于二进制模式的文件对象。 对于这些对
   象，应改用 "file.write(...)"。

   Output buffering is usually determined by *file*. However, if
   *flush* is true, the stream is forcibly flushed.

   3.3 版更變: 增加了 *flush* 關鍵字引數。

class property(fget=None, fset=None, fdel=None, doc=None)

   回傳 property 屬性。

   *fget* 是获取属性值的函数。 *fset* 是用于设置属性值的函数。 *fdel*
   是用于删除属性值的函数。并且 *doc* 为属性对象创建文档字符串。

   一个典型的用法是定义一个托管属性 "x":

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

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

   如果 *c* 为 *C* 的实例，"c.x" 将调用 getter，"c.x = value" 将调用
   setter， "del c.x" 将调用 deleter。

   如果给出，*doc* 将成为该 property 属性的文档字符串。 否则该
   property 将拷贝 *fget* 的文档字符串（如果存在）。 这令使用
   "property()" 作为 *decorator* 来创建只读的特征属性可以很容易地实现:

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

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

   以上 "@property" 装饰器会将 "voltage()" 方法转化为一个具有相同名称
   的只读属性的 "getter"，并将 *voltage* 的文档字符串设置为 "Get the
   current voltage."

   特征属性对象具有 "getter", "setter" 以及 "deleter" 方法，它们可用作
   装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。
   这最好是用一个例子来解释:

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

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

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

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

   上述代码与第一个例子完全等价。 注意一定要给附加函数与原始的特征属性
   相同的名称 (在本例中为 "x"。)

   返回的特征属性对象同样具有与构造器参数相对应的属性 "fget", "fset"
   和 "fdel"。

   3.5 版更變: 特征属性对象的文档字符串现在是可写的。

class range(stop)
class range(start, stop[, step])

   虽然被称为函数，但 "range" 实际上是一个不可变的序列类型，参见在
   range 对象 与 序列类型 --- list, tuple, range 中的文档说明。

repr(object)

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

reversed(seq)

   返回一个反向的 *iterator*。 *seq* 必须是一个具有 "__reversed__()"
   方法的对象或者是支持该序列协议（具有从 "0" 开始的整数类型参数的
   "__len__()" 方法和 "__getitem__()" 方法）。

round(number[, ndigits])

   返回 *number* 舍入到小数点后 *ndigits* 位精度的值。 如果 *ndigits*
   被省略或为 "None"，则返回最接近输入值的整数。

   对于支持 "round()" 方法的内置类型，结果值会舍入至最接近的 10 的负
   *ndigits* 次幂的倍数；如果与两个倍数同样接近，则选用偶数。因此，
   "round(0.5)" 和 "round(-0.5)" 均得出 "0" 而 "round(1.5)" 则为 "2"。
   *ndigits* 可为任意整数值（正数、零或负数）。如果省略了 *ndigits* 或
   为 "None" ，则返回值将为整数。否则返回值与 *number* 的类型相同。

   对于一般的 Python 对象 "number", "round" 将委托给
   "number.__round__"。

   備註:

     对浮点数执行 "round()" 的行为可能会令人惊讶：例如，"round(2.675,
     2)" 将给出 "2.67" 而不是期望的 "2.68"。 这不算是程序错误：这一结
     果是由于大多数十进制小数实际上都不能以浮点数精确地表示。 请参阅
     浮點數運算：問題與限制 了解更多信息。

class set([iterable])

   返回一个新的 "set" 对象，可以选择带有从 *iterable* 获取的元素。
   "set" 是一个内置类型。 请查看 "set" 和 集合类型 --- set, frozenset
   获取关于这个类的文档。

   有关其他容器请参看内置的 "frozenset", "list", "tuple" 和 "dict" 类
   ，以及 "collections" 模块。

setattr(object, name, value)

   本函数与 "getattr()" 相对应。其参数为一个对象、一个字符串和一个任意
   值。字符串可以为某现有属性的名称，或为新属性。只要对象允许，函数会
   将值赋给属性。如 "setattr(x, 'foobar', 123)" 等价于 "x.foobar =
   123"。

   *name* need not be a Python identifier as defined in 标识符和关键字
   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..

   備註:

     由于 私有名称混合 发生在编译时，因此必须手动混合私有属性（以两个
     下划线打头的属性）名称以便使用 "setattr()" 来设置它。

class slice(stop)
class slice(start, stop[, step])

   返回一个 *slice* 对象，代表由 "range(start, stop, step)" 指定索引集
   的切片。 其中参数 *start* 和 *step* 的默认值为 "None"。切片对象具有
   只读数据属性 "start" 、"stop" 和 "step"，只是返回对应的参数值（或默
   认值）。这几个属性没有其他明确的功能；不过 NumPy 和其他第三方扩展会
   用到。在使用扩展索引语法时，也会生成切片对象。例如：
   "a[start:stop:step]" 或 "a[start:stop, i]"。 另一种方案是返回迭代器
   对象，可参阅 "itertools.islice()" 。

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

   根据 *iterable* 中的项返回一个新的已排序列表。

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

   *key* 指定带有单个参数的函数，用于从 *iterable* 的每个元素中提取用
   于比较的键 (例如 "key=str.lower")。 默认值为 "None" (直接比较元素)
   。

   *reverse* 为一个布尔值。 如果设为 "True"，则每个列表元素将按反向顺
   序比较进行排序。

   使用 "functools.cmp_to_key()" 可将老式的 *cmp* 函数转换为 *key* 函
   数。

   内置的 "sorted()" 确保是稳定的。 如果一个排序确保不会改变比较结果相
   等的元素的相对顺序就称其为稳定的 --- 这有利于进行多重排序（例如先按
   部门、再按薪级排序）。

   排序算法只使用 "<" 在项目之间比较。 虽然定义一个 "__lt__()" 方法就
   足以进行排序，但 **PEP 8** 建议实现所有六个 富比较 。 这将有助于避
   免在与其他排序工具（如 "max()" ）使用相同的数据时出现错误，这些工具
   依赖于不同的底层方法。实现所有六个比较也有助于避免混合类型比较的混
   乱，因为混合类型比较可以调用反射到 "__gt__()" 的方法。

   有关排序示例和简要排序教程，请参阅 如何排序 。

@staticmethod

   将方法转换为静态方法。

   静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

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

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

   静态方法既可以由类中调用（如 "C.f()"），也可以由实例中调用（如
   ```C().f()``）。此外，还可以作为普通的函数进行调用（如``f()``）。

   Python 的静态方法与 Java 或 C++ 类似。另请参阅 "classmethod()" ，可
   用于创建另一种类构造函数。

   像所有装饰器一样，也可以像常规函数一样调用 "staticmethod" ，并对其
   结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免
   自动转换为实例方法。对于这些情况，请使用此语法:

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

   關於 static method 的更多資訊，請參考 标准类型层级结构。

   3.10 版更變: 静态方法继承了方法的多个属性（"__module__"、"__name__"
   、"__qualname__"、"__doc__" 和 "__annotations__"），还拥有一个新的
   ``__wrapped__`` 属性，并且现在还可以作为普通函数进行调用。

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

   返回一个 "str" 版本的 *object* 。有关详细信息，请参阅 "str()" 。

   "str" 是内置字符串 *class* 。更多关于字符串的信息查看 文本序列类型
   --- str。

sum(iterable, /, start=0)

   从 *start* 开始自左向右对 *iterable* 的项求和并返回总计值。
   *iterable* 的项通常为数字，而 start 值则不允许为字符串。

   对某些用例来说，存在 "sum()" 的更好替代。 拼接字符串序列的更好更快
   方式是调用 "''.join(sequence)"。 要以扩展精度对浮点值求和，请参阅
   "math.fsum()"。 要拼接一系列可迭代对象，请考虑使用
   "itertools.chain()"。

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

class super([type[, object-or-type]])

   返回一个代理对象，它会将方法调用委托给 *type* 的父类或兄弟类。 这对
   于访问已在类中被重载的继承方法很有用。

   *object-or-type* 确定用于搜索的 *method resolution order*。 搜索会
   从 *type* 之后的类开始。

   举例来说，如果 *object-or-type* 的 "__mro__" 为 "D -> B -> C -> A
   -> object" 并且 *type* 的值为 "B"，则 "super()" 将会搜索 "C -> A ->
   object"。

   *object-or-type* 的 "__mro__" 属性列出了 "getattr()" 和 "super()"
   所共同使用的方法解析搜索顺序。 该属性是动态的，可以在任何继承层级结
   构发生更新的时候被改变。

   如果省略第二个参数，则返回的超类对象是未绑定的。 如果第二个参数为一
   个对象，则 "isinstance(obj, type)" 必须为真值。 如果第二个参数为一
   个类型，则 "issubclass(type2, type)" 必须为真值（这适用于类方法）。

   *super* 有两个典型用例。 在具有单继承的类层级结构中，*super* 可用来
   引用父类而不必显式地指定它们的名称，从而令代码更易维护。 这种用法与
   其他编程语言中 *super* 的用法非常相似。

   第二个用例是在动态执行环境中支持协作多重继承。 此用例为 Python 所独
   有而不存在于静态编码语言或仅支持单继承的语言当中。 这使用实现“菱形
   图”成为可能，即有多个基类实现相同的方法。 好的设计强制要求这样的方
   法在每个情况下都具有相同的调用签名（因为调用顺序是在运行时确定的，
   也因为这个顺序要适应类层级结构的更改，还因为这个顺序可能包括在运行
   时之前未知的兄弟类）。

   对于以上两个用例，典型的超类调用看起来是这样的:

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

   除了方法查找之外，"super()" 也可用于属性查找。 一个可能的应用场合是
   在上级或同级类中调用 *描述器*。

   请注意 "super()" 是作为显式加点属性查找的绑定过程的一部分来实现的，
   例如 "super().__getitem__(name)"。 它做到这一点是通过实现自己的
   "__getattribute__()" 方法，这样就能以可预测的顺序搜索类，并且支持协
   作多重继承。 对应地，"super()" 在像 "super()[name]" 这样使用语句或
   操作符进行隐式查找时则未被定义。

   还要注意的是，除了零个参数的形式以外，"super()" 并不限于在方法内部
   使用。 两个参数的形式明确指定参数并进行相应的引用。 零个参数的形式
   仅适用于类定义内部，因为编译器需要填入必要的细节以正确地检索到被定
   义的类，还需要让普通方法访问当前实例。

   对于有关如何使用 "super()" 来如何设计协作类的实用建议，请参阅 使用
   super() 的指南。

class tuple([iterable])

   虽然被称为函数，但 "tuple" 实际上是一个不可变的序列类型，参见在 元
   组 与 序列类型 --- list, tuple, range 中的文档说明。

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

   传入一个参数时，返回 *object* 的类型。 返回值是一个 type 对象，通常
   与 "object.__class__" 所返回的对象相同。

   推荐使用 "isinstance()" 内置函数来检测对象的类型，因为它会考虑子类
   的情况。

   传入三个参数时，返回一个新的 type 对象。 这在本质上是 "class" 语句
   的一种动态形式，*name* 字符串即类名并会成为 "__name__" 属性；
   *bases* 元组包含基类并会成为 "__bases__" 属性；如果为空则会添加所有
   类的终极基类 "object"。 *dict* 字典包含类主体的属性和方法定义；它在
   成为 "__dict__" 属性之前可能会被拷贝或包装。 下面两条语句会创建相同
   的 "type" 对象:

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

   另請參閱 类型对象。

   提供给三参数形式的关键字参数会被传递给适当的元类机制 (通常为
   "__init_subclass__()")，相当于类定义中关键字 (除了 *metaclass*) 的
   行为方式。

   另請參閱 自定义类创建。

   3.6 版更變: "type" 的子类如果未重载 "type.__new__"，将不再能使用一
   个参数的形式来获取对象的类型。

vars([object])

   返回模块、类、实例或任何其它具有 "__dict__" 属性的对象的 "__dict__"
   属性。

   模块和实例这样的对象具有可更新的 "__dict__" 属性；但是，其它对象的
   "__dict__" 属性可能会设为限制写入（例如，类会使用
   "types.MappingProxyType" 来防止直接更新字典）。

   不带参数时，"vars()" 的行为类似 "locals()"。 请注意，locals 字典仅
   对于读取起作用，因为对 locals 字典的更新会被忽略。

   如果指定了一个对象但它没有 "__dict__" 属性（例如，当它所属的类定义
   了 "__slots__" 属性时）则会引发 "TypeError" 异常。

zip(*iterables, strict=False)

   在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。

   例如：

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

   更正式的说法： "zip()" 返回元组的迭代器，其中第 *i* 个元组包含的是
   每个参数迭代器的第 *i* 个元素。

   不妨换一种方式认识 "zip()" ：它会把行变成列，把列变成行。这类似于
   矩阵转置 。

   "zip()" 是延迟执行的：直至迭代时才会对元素进行处理，比如 "for" 循环
   或放入 "list" 中。

   值得考虑的是，传给 "zip()" 的可迭代对象可能长度不同；有时是有意为之
   ，有时是因为准备这些对象的代码存在错误。Python 提供了三种不同的处理
   方案：

   * 默认情况下，"zip()" 在最短的迭代完成后停止。较长可迭代对象中的剩
     余项将被忽略，结果会裁切至最短可迭代对象的长度：

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

   * 通常 "zip()" 用于可迭代对象等长的情况下。这时建议用 "strict=True"
     的选项。输出与普通的 "zip()" 相同：。

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

     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

     如果未指定 "strict=True" 参数，所有导致可迭代对象长度不同的错误都
     会被抑制，这可能会在程序的其他地方表现为难以发现的错误。

   * 为了让所有的可迭代对象具有相同的长度，长度较短的可用常量进行填充
     。这可由 "itertools.zip_longest()" 来完成。

   极端例子是只有一个可迭代对象参数，"zip()" 会返回一个一元组的迭代器
   。如果未给出参数，则返回一个空的迭代器。

   小技巧：

   * 可确保迭代器的求值顺序是从左到右的。这样就能用 "zip(*[iter(s)]*n,
     strict=True)" 将数据列表按长度 n 进行分组。这将重复 *相同* 的迭代
     器 "n" 次，输出的每个元组都包含 "n" 次调用迭代器的结果。这样做的
     效果是把输入拆分为长度为 n 的块。

   * "zip()" 与 "*" 运算符相结合可以用来拆解一个列表:

        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> list(zip(x, y))
        [(1, 4), (2, 5), (3, 6)]
        >>> x2, y2 = zip(*zip(x, y))
        >>> x == list(x2) and y == list(y2)
        True

   3.10 版更變: 增加了 "strict" 引數。

__import__(name, globals=None, locals=None, fromlist=(), level=0)

   備註:

     与 "importlib.import_module()" 不同，这是一个日常 Python 编程中不
     需要用到的高级函数。

   此函数会由 "import" 语句发起调用。 它可以被替换 (通过导入
   "builtins" 模块并赋值给 "builtins.__import__") 以便修改 "import" 语
   句的语义，但是 **强烈** 不建议这样做，因为使用导入钩子 (参见 **PEP
   302**) 通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码
   都会假定所用的是默认实现。 同样也不建议直接使用 "__import__()" 而应
   该用 "importlib.import_module()"。

   本函数会导入模块 *name*，利用 *globals* 和 *locals* 来决定如何在包
   的上下文中解释该名称。*fromlist* 给出了应从 *name* 模块中导入的对象
   或子模块的名称。标准的实现代码完全不会用到 *locals* 参数，只用到了
   *globals* 用于确定 "import" 语句所在的包上下文。

   *level* 指定是使用绝对还是相对导入。 "0" (默认值) 意味着仅执行绝对
   导入。 *level* 为正数值表示相对于模块调用 "__import__()" 的目录，将
   要搜索的父目录层数 (详情参见 **PEP 328**)。

   当 *name* 变量的形式为 "package.module" 时，通常将会返回最高层级的
   包（第一个点号之前的名称），而 *不是* 以 *name* 命名的模块。 但是，
   当给出了非空的 *fromlist* 参数时，则将返回以 *name* 命名的模块。

   例如，语句 "import spam" 的结果将为与以下代码作用相同的字节码:

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

   语句 "import spam.ham" 的结果将为以下调用:

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

   请注意在这里 "__import__()" 是如何返回顶层模块的，因为这是通过
   "import" 语句被绑定到特定名称的对象。

   另一方面，语句 "from spam.ham import eggs, sausage as saus" 的结果
   将为

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

   在这里， "spam.ham" 模块会由 "__import__()" 返回。 要导入的对象将从
   此对象中提取并赋值给它们对应的名称。

   如果您只想按名称导入模块（可能在包中），请使用
   "importlib.import_module()"

   3.3 版更變: *level* 的值不再支持负数（默认值也修改为0）。

   3.9 版更變: 当使用了命令行参数 "-E" 或 "-I" 时，环境变量
   "PYTHONCASEOK" 现在将被忽略。

-[ 註解 ]-

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