术语对照表
**********

">>>"
   The default Python prompt of the interactive shell.  Often seen for
   code examples which can be executed interactively in the
   interpreter.

"..."
   具有以下含义：

   * The default Python prompt of the interactive shell when entering
     the code for an indented code block, when within a pair of
     matching left and right delimiters (parentheses, square brackets,
     curly braces or triple quotes), or after specifying a decorator.

   * "Ellipsis" 内置常量。

2to3
   A tool that tries to convert Python 2.x code to Python 3.x code by
   handling most of the incompatibilities which can be detected by
   parsing the source and traversing the parse tree.

   2to3 is available in the standard library as "lib2to3"; a
   standalone entry point is provided as "Tools/scripts/2to3".  See
   2to3 --- 自动化的 Python 2 到 3 代码转写.

abstract base class -- 抽象基类
   抽象基类简称 ABC，是对 *duck-typing* 的补充，它提供了一种定义接口的
   新方式，相比之下其他技巧例如 "hasattr()" 显得过于笨拙或有微妙错误（
   例如使用 魔术方法）。ABC 引入了虚拟子类，这种类并非继承自其他类，但
   却仍能被 "isinstance()" 和 "issubclass()" 所认可；详见 "abc" 模块文
   档。Python 自带许多内置的 ABC 用于实现数据结构（在
   "collections.abc" 模块中）、数字（在 "numbers" 模块中）、流（在
   "io" 模块中）、导入查找器和加载器（在 "importlib.abc" 模块中）。你
   可以使用 "abc" 模块来创建自己的 ABC。

annotation -- 标注
   关联到某个变量、类属性、函数形参或返回值的标签，被约定作为 *类型注
   解* 来使用。

   局部变量的标注在运行时不可访问，但全局变量、类属性和函数的标注会分
   别存放模块、类和函数的 "__annotations__" 特殊属性中。

   参见 *variable annotation*, *function annotation*, **PEP 484** 和
   **PEP 526**，对此功能均有介绍。 另请参见 注解最佳实践 了解使用标注
   的最佳实践。

argument -- 参数
   在调用函数时传给 *function* （或 *method* ）的值。参数分为两种：

   * *关键字参数*: 在函数调用中前面带有标识符（例如 "name="）或者作为
     包含在前面带有 "**" 的字典里的值传入。举例来说，"3" 和 "5" 在以下
     对 "complex()" 的调用中均属于关键字参数:

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

   * *位置参数*: 不属于关键字参数的参数。位置参数可出现于参数列表的开
     头以及/或者作为前面带有 "*" 的 *iterable* 里的元素被传入。举例来
     说，"3" 和 "5" 在以下调用中均属于位置参数:

        complex(3, 5)
        complex(*(3, 5))

   参数会被赋值给函数体中对应的局部变量。有关赋值规则参见 调用 一节。
   根据语法，任何表达式都可用来表示一个参数；最终算出的值会被赋给对应
   的局部变量。

   另参见 *parameter* 术语表条目，常见问题中 参数与形参的区别 以及
   **PEP 362**。

asynchronous context manager -- 异步上下文管理器
   此种对象通过定义 "__aenter__()" 和 "__aexit__()" 方法来对 "async
   with" 语句中的环境进行控制。 由 **PEP 492** 引入。

asynchronous generator -- 异步生成器
   返回值为 *asynchronous generator iterator* 的函数。它与使用 "async
   def" 定义的协程函数很相似，不同之处在于它包含 "yield" 表达式以产生
   一系列可在 "async for" 循环中使用的值。

   此术语通常是指异步生成器函数，但在某些情况下则可能是指 *异步生成器
   迭代器*。如果需要清楚表达具体含义，请使用全称以避免歧义。

   一个异步生成器函数可能包含 "await" 表达式或者 "async for" 以及
   "async with" 语句。

asynchronous generator iterator -- 异步生成器迭代器
   *asynchronous generator* 函数所创建的对象。

   此对象属于 *asynchronous iterator*，当使用 "__anext__()" 方法调用时
   会返回一个可等待对象来执行异步生成器函数的函数体直到下一个 "yield"
   表达式。

   每个 "yield" 会临时暂停处理，记住当前位置执行状态（包括局部变量和挂
   起的 try 语句）。 当该 *异步生成器迭代器* 通过 "__anext__()" 所返回
   的其他可等待对象有效恢复时，它会从离开位置继续执行。 参见 **PEP
   492** 和 **PEP 525**。

asynchronous iterable -- 异步可迭代对象
   一个可以在 "async for" 语句中使用的对象。 必须通过它的
   "__aiter__()" 方法返回一个 *asynchronous iterator*。 由 **PEP 492**
   引入。

asynchronous iterator -- 异步迭代器
   一个实现了 "__aiter__()" 和 "__anext__()" 方法的对象。
   "__anext__()" 必须返回一个 *awaitable* 对象。 "async for" 会处理异
   步迭代器的 "__anext__()" 方法所返回的可等待对象直到其引发一个
   "StopAsyncIteration" 异常。 由 **PEP 492** 引入。

attribute -- 属性
   关联到一个对象的值，通常使用点号表达式按名称来引用。 举例来说，如果
   对象 *o* 具有属性 *a* 则可以用 *o.a* 来引用它。

   如果对象允许，将未被定义为 标识符和关键字 的非标识名称用作一个对象
   的属性也是可以的，例如使用 "setattr()"。 这样的属性将无法使用点号表
   达式来访问，而是必须通过 "getattr()" 来获取。

awaitable -- 可等待对象
   一个可在 "await" 表达式中使用的对象。 可以是 *coroutine* 或是具有
   "__await__()" 方法的对象。 参见 **PEP 492**。

BDFL
   “终身仁慈独裁者”的英文缩写，即 Guido van Rossum，Python 的创造者。

binary file -- 二进制文件
   *file object* 能够读写 *字节型对象*。 二进制文件的例子包括以二进制
   模式 ("'rb'", "'wb'" 或 "'rb+'") 打开的文件、"sys.stdin.buffer"、
   "sys.stdout.buffer" 以及 "io.BytesIO" 和 "gzip.GzipFile" 的实例。

   另请参见 *text file* 了解能够读写 "str" 对象的文件对象。

borrowed reference -- 借入引用
   在 Python 的 C API 中，借用引用是指一种对象引用，使用该对象的代码并
   不持有该引用。 如果对象被销毁则它就会变成一个悬空指针。 例如，垃圾
   回收器可以移除对象的最后一个 *strong reference* 来销毁它。

   推荐在 *borrowed reference* 上调用 "Py_INCREF()" 以将其原地转换为
   *strong reference*，除非是当该对象无法在借入引用的最后一次使用之前
   被销毁。 "Py_NewRef()" 函数可以被用来创建一个新的 *strong
   reference*。

bytes-like object -- 字节型对象
   支持 缓冲协议 并且能导出 C-*contiguous* 缓冲的对象。这包括所有
   "bytes"、"bytearray" 和 "array.array" 对象，以及许多普通
   "memoryview" 对象。 字节型对象可在多种二进制数据操作中使用；这些操
   作包括压缩、保存为二进制文件以及通过套接字发送等。

   某些操作需要可变的二进制数据。这种对象在文档中常被称为“可读写字节类
   对象”。可变缓冲对象的例子包括 "bytearray" 以及 "bytearray" 的
   "memoryview"。其他操作要求二进制数据存放于不可变对象 ("只读字节类对
   象")；这种对象的例子包括 "bytes" 以及 "bytes" 对象的 "memoryview"。

bytecode -- 字节码
   Python 源代码会被编译为字节码，即 CPython 解释器中表示 Python 程序
   的内部代码。字节码还会缓存在 ".pyc" 文件中，这样第二次执行同一文件
   时速度更快（可以免去将源码重新编译为字节码）。这种 "中间语言" 运行
   在根据字节码执行相应机器码的 *virtual machine* 之上。请注意不同
   Python 虚拟机上的字节码不一定通用，也不一定能在不同 Python 版本上兼
   容。

   字节码指令列表可以在 dis 模块 的文档中查看。

callable -- 可调用对象
   可调用对象就是可以执行调用运算的对象，并可能附带一组参数 (参见
   *argument*)，使用以下语法:

      callable(argument1, argument2, argumentN)

   *function*，还可扩展到 *method* 等，就属于可调用对象。 实现了
   "__call__()" 方法的类的实例也属于可调用对象。

callback -- 回调
   一个作为参数被传入以用以在未来的某个时刻被调用的子例程函数。

class
   用来创建用户定义对象的模板。类定义通常包含对该类的实例进行操作的方
   法定义。

class variable -- 类变量
   在类中定义的变量，并且仅限在类的层级上修改 (而不是在类的实例中修改)
   。

complex number -- 复数
   对普通实数系统的扩展，其中所有数字都被表示为一个实部和一个虚部的和
   。虚数是虚数单位（"-1" 的平方根）的实倍数，通常在数学中写为 "i"，在
   工程学中写为 "j"。Python 内置了对复数的支持，采用工程学标记方式；虚
   部带有一个 "j" 后缀，例如 "3+1j"。如果需要 "math" 模块内对象的对应
   复数版本，请使用 "cmath"，复数的使用是一个比较高级的数学特性。如果
   你感觉没有必要，忽略它们也几乎不会有任何问题。

context manager -- 上下文管理器
   在 "with" 语句中通过定义 "__enter__()" 和 "__exit__()" 方法来控制环
   境状态的对象。 参见 **PEP 343**。

context variable -- 上下文变量
   一种根据其所属的上下文可以具有不同的值的变量。 这类似于在线程局部存
   储中每个执行线程可以具有不同的变量值。 不过，对于上下文变量来说，一
   个执行线程中可能会有多个上下文，而上下文变量的主要用途是对并发异步
   任务中变量进行追踪。 参见 "contextvars"。

contiguous -- 连续
   一个缓冲如果是 *C 连续* 或 *Fortran 连续* 就会被认为是连续的。零维
   缓冲是 C 和 Fortran 连续的。在一维数组中，所有条目必须在内存中彼此
   相邻地排列，采用从零开始的递增索引顺序。在多维 C-连续数组中，当按内
   存地址排列时用最后一个索引访问条目时速度最快。但是在 Fortran 连续数
   组中则是用第一个索引最快。

coroutine -- 协程
   协程是子例程的更一般形式。  子例程可以在某一点进入并在另一点退出。
   协程则可以在许多不同的点上进入、退出和恢复。 它们可通过 "async def"
   语句来实现。 参见 **PEP 492**。

coroutine function -- 协程函数
   返回一个 *coroutine* 对象的函数。协程函数可通过 "async def" 语句来
   定义，并可能包含 "await"、"async for" 和 "async with" 关键字。这些
   特性是由 **PEP 492** 引入的。

CPython
   Python 编程语言的规范实现，在 python.org 上发布。"CPython" 一词用于
   在必要时将此实现与其他实现例如 Jython 或 IronPython 相区别。

decorator -- 装饰器
   返回值为另一个函数的函数，通常使用 "@wrapper" 语法形式来进行函数变
   换。 装饰器的常见例子包括 "classmethod()" 和 "staticmethod()"。

   装饰器语法只是一种语法糖，以下两个函数定义在语义上完全等价:

      def f(arg):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(arg):
          ...

   同样的概念也适用于类，但通常较少这样使用。有关装饰器的详情可参见 函
   数定义 和 类定义 的文档。

descriptor -- 描述器
   任何定义了 "__get__()", "__set__()" 或 "__delete__()" 方法的对象。
   当一个类属性为描述器时，它的特殊绑定行为就会在属性查找时被触发。 通
   常情况下，使用 *a.b* 来获取、设置或删除一个属性时会在 *a* 类的字典
   中查找名称为 *b* 的对象，但如果 *b* 是一个描述器，则会调用对应的描
   述器方法。 理解描述器的概念是更深层次理解 Python 的关键，因为这是许
   多重要特性的基础，包括函数、方法、特征属性、类方法、静态方法以及对
   超类的引用等等。

   有关描述器的方法的更多信息，请参阅 实现描述器 或 描述器使用指南。

dictionary -- 字典
   一个关联数组，其中的任意键都映射到相应的值。 键可以是任何具有
   "__hash__()" 和 "__eq__()" 方法的对象。 在 Perl 中称为 hash。

dictionary comprehension -- 字典推导式
   处理一个可迭代对象中的所有或部分元素并返回结果字典的一种紧凑写法。
   "results = {n: n ** 2 for n in range(10)}" 将生成一个由键 "n" 到值
   "n ** 2" 的映射构成的字典。 参见 列表、集合与字典的显示。

dictionary view -- 字典视图
   从 "dict.keys()", "dict.values()" 和 "dict.items()" 返回的对象被称
   为字典视图。它们提供了字典条目的一个动态视图，这意味着当字典改变时
   ，视图也会相应改变。要将字典视图强制转换为真正的列表，可使用
   "list(dictview)"。参见 字典视图对象。

docstring -- 文档字符串
   作为类、函数或模块之内的第一个表达式出现的字符串字面值。 它在代码被
   执行时会被忽略，但会被编译器识别并放入所在类、函数或模块的
   "__doc__" 属性中。 由于它可用于代码内省，因此是存放对象的文档的规范
   位置。

duck-typing -- 鸭子类型
   指一种编程风格，它并不依靠查找对象类型来确定其是否具有正确的接口，
   而是直接调用或使用其方法或属性（“看起来像鸭子，叫起来也像鸭子，那么
   肯定就是鸭子。”）由于强调接口而非特定类型，设计良好的代码可通过允许
   多态替代来提升灵活性。鸭子类型避免使用 "type()" 或 "isinstance()"
   检测。(但要注意鸭子类型可以使用 *抽象基类* 作为补充。)  而往往会采
   用 "hasattr()" 检测或是 *EAFP* 编程。

EAFP
   “求原谅比求许可更容易”的英文缩写。这种 Python 常用代码编写风格会假
   定所需的键或属性存在，并在假定错误时捕获异常。这种简洁快速风格的特
   点就是大量运用 "try" 和 "except" 语句。于其相对的则是所谓 *LBYL* 风
   格，常见于 C 等许多其他语言。

expression -- 表达式
   可以求出某个值的语法单元。 换句话说，一个表达式就是表达元素例如字面
   值、名称、属性访问、运算符或函数调用的汇总，它们最终都会返回一个值
   。 与许多其他语言不同，并非所有语言构件都是表达式。 还存在不能被用
   作表达式的 *statement*，例如 "while"。 赋值也是属于语句而非表达式。

extension module -- 扩展模块
   以 C 或 C++ 编写的模块，使用 Python 的 C API 来与语言核心以及用户代
   码进行交互。

f-string -- f-字符串
   带有 "'f'" 或 "'F'" 前缀的字符串字面值通常被称为“f-字符串”即 格式化
   字符串字面值 的简写。参见 **PEP 498**。

file object -- 文件对象
   对外公开面向文件的 API（带有 "read()" 或 "write()" 等方法）以使用下
   层资源的对象。 根据其创建方式的不同，文件对象可以处理对真实磁盘文件
   、其他类型的存储或通信设备的访问（例如标准输入/输出、内存缓冲区、套
   接字、管道等）。 文件对象也被称为 *文件型对象* 或 *流*。

   实际上共有三种类别的文件对象: 原始 *二进制文件*, 缓冲 *二进制文件*
   以及 *文本文件*。它们的接口定义均在 "io" 模块中。 创建文件对象的规
   范方式是使用 "open()" 函数。

file-like object -- 文件型对象
   *file object* 的同义词。

filesystem encoding and error handler  -- 文件系统编码格式与错误处理器
   Python 用来从操作系统解码字节串和向操作系统编码 Unicode 的编码格式
   与错误处理器。

   文件系统编码格式必须保证能成功解码长度在 128 以下的所有字节串。 如
   果文件系统编码格式无法提供此保证，则 API 函数可能会引发
   "UnicodeError"。

   "sys.getfilesystemencoding()" 和 "sys.getfilesystemencodeerrors()"
   函数可被用来获取文件系统编码格式与错误处理器。

   *filesystem encoding and error handler* 是在 Python 启动时通过
   "PyConfig_Read()" 函数来配置的：请参阅 "PyConfig" 的
   "filesystem_encoding" 和 "filesystem_errors" 等成员。

   另请参见 *locale encoding*。

finder -- 查找器
   一种会尝试查找被导入模块的 *loader* 的对象。

   There are two types of finder: *meta path finders* for use with
   "sys.meta_path", and *path entry finders* for use with
   "sys.path_hooks".

   See 导入系统 and "importlib" for much more detail.

floor division -- 向下取整除法
   向下舍入到最接近的整数的数学除法。向下取整除法的运算符是 "//" 。例
   如，表达式 "11 // 4" 的计算结果是 "2" ，而与之相反的是浮点数的真正
   除法返回 "2.75" 。注意 "(-11) // 4" 会返回 "-3" 因为这是 "-2.75" *
   向下* 舍入得到的结果。见 **PEP 238** 。

function -- 函数
   可以向调用者返回某个值的一组语句。还可以向其传入零个或多个 *参数*
   并在函数体执行中被使用。另见 *parameter*, *method* 和 函数定义 等节
   。

function annotation -- 函数标注
   即针对函数形参或返回值的 *annotation* 。

   函数标注通常用于 *类型提示*：例如以下函数预期接受两个 "int" 参数并
   预期返回一个 "int" 值:

      def sum_two_numbers(a: int, b: int) -> int:
         return a + b

   函数标注语法的详解见 函数定义 一节。

   参见 *variable annotation* 和 **PEP 484**，其中描述了此功能。 另请
   参阅 注解最佳实践 以了解使用标的最佳实践。

__future__
   future 语句, "from __future__ import <feature>" 指示编译器使用将在
   未来的 Python 发布版中成为标准的语法和语义来编译当前模块。
   "__future__" 模块文档记录了可能 的 *feature* 取值。 通过导入此模块
   并对其变量求值，你可以看到每项新特性在何时被首次加入到该语言中以及
   它将（或已）在何时成为默认:

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection -- 垃圾回收
   释放不再被使用的内存空间的过程。Python 是通过引用计数和一个能够检测
   和打破循环引用的循环垃圾回收器来执行垃圾回收的。可以使用 "gc" 模块
   来控制垃圾回收器。

generator -- 生成器
   返回一个 *generator iterator* 的函数。它看起来很像普通函数，不同点
   在于其包含 "yield" 表达式以便产生一系列值供给 for-循环使用或是通过
   "next()" 函数逐一获取。

   通常是指生成器函数，但在某些情况下也可能是指 *生成器迭代器*。如果需
   要清楚表达具体含义，请使用全称以避免歧义。

generator iterator -- 生成器迭代器
   *generator* 函数所创建的对象。

   每个 "yield" 会临时暂停处理，记住当前位置执行状态（包括局部变量和挂
   起的 try 语句）。当该 *生成器迭代器* 恢复时，它会从离开位置继续执行
   （这与每次调用都从新开始的普通函数差别很大）。

generator expression -- 生成器表达式
   An expression that returns an iterator.  It looks like a normal
   expression followed by a "for" clause defining a loop variable,
   range, and an optional "if" clause.  The combined expression
   generates values for an enclosing function:

      >>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
      285

generic function -- 泛型函数
   为不同的类型实现相同操作的多个函数所组成的函数。在调用时会由调度算
   法来确定应该使用哪个实现。

   另请参见 *single dispatch* 术语表条目、"functools.singledispatch()"
   装饰器以及 **PEP 443**。

generic type -- 泛型
   可参数化的 *type*；通常为 "list" 或 "dict" 这样的 容器类。用于 *类
   型提示* 和 *注解*。

   更多细节参见 泛型别名类型、**PEP 483**、**PEP 484**、**PEP 585** 和
   "typing" 模块。

GIL
   参见 *global interpreter lock*。

global interpreter lock -- 全局解释器锁
   *CPython* 解释器所采用的一种机制，它确保同一时刻只有一个线程在执行
   Python *bytecode*。此机制通过设置对象模型（包括 "dict" 等重要内置类
   型）针对并发访问的隐式安全简化了 CPython 实现。给整个解释器加锁使得
   解释器多线程运行更方便，其代价则是牺牲了在多处理器上的并行性。

   不过，某些标准库或第三方库的扩展模块被设计为在执行计算密集型任务如
   压缩或哈希时释放 GIL。 此外，在执行 I/O 操作时也总是会释放 GIL。

   Past efforts to create a "free-threaded" interpreter (one which
   locks shared data at a much finer granularity) have not been
   successful because performance suffered in the common single-
   processor case. It is believed that overcoming this performance
   issue would make the implementation much more complicated and
   therefore costlier to maintain.

hash-based pyc -- 基于哈希的 pyc
   使用对应源文件的哈希值而非最后修改时间来确定其有效性的字节码缓存文
   件。 参见 已缓存字节码的失效。

hashable -- 可哈希
   一个对象如果具有在其生命期内绝不改变的哈希值（它需要有 "__hash__()"
   方法），并可以同其他对象进行比较（它需要有 "__eq__()" 方法）就被称
   为 *可哈希* 对象。 可哈希对象必须具有相同的哈希值比较结果才会相等。

   可哈希性使得对象能够作为字典键或集合成员使用，因为这些数据结构要在
   内部使用哈希值。

   大多数 Python 中的不可变内置对象都是可哈希的；可变容器（例如列表或
   字典）都不可哈希；不可变容器（例如元组和 frozenset）仅当它们的元素
   均为可哈希时才是可哈希的。 用户定义类的实例对象默认是可哈希的。 它
   们在比较时一定不相同（除非是与自己比较），它们的哈希值的生成是基于
   它们的 "id()"。

IDLE
   Python 的集成开发与学习环境。 IDLE 是 Python 标准发行版附带的基本编
   辑器和解释器环境。

immutable -- 不可变对象
   具有固定值的对象。不可变对象包括数字、字符串和元组。这样的对象不能
   被改变。如果必须存储一个不同的值，则必须创建新的对象。它们在需要常
   量哈希值的地方起着重要作用，例如作为字典中的键。

import path -- 导入路径
   由多个位置（或 *路径条目*）组成的列表，会被模块的 *path based
   finder* 用来查找导入目标。在导入时，此位置列表通常来自 "sys.path"，
   但对次级包来说也可能来自上级包的 "__path__" 属性。

importing -- 导入
   令一个模块中的 Python 代码能为另一个模块中的 Python 代码所使用的过
   程。

importer -- 导入器
   查找并加载模块的对象；此对象既属于 *finder* 又属于 *loader*。

interactive -- 交互
   Python has an interactive interpreter which means you can enter
   statements and expressions at the interpreter prompt, immediately
   execute them and see their results.  Just launch "python" with no
   arguments (possibly by selecting it from your computer's main
   menu). It is a very powerful way to test out new ideas or inspect
   modules and packages (remember "help(x)").

interpreted -- 解释型
   Python 一是种解释型语言，与之相对的是编译型语言，虽然两者的区别由于
   字节码编译器的存在而会有所模糊。这意味着源文件可以直接运行而不必显
   式地创建可执行文件再运行。解释型语言通常具有比编译型语言更短的开发/
   调试周期，但是其程序往往运行得更慢。参见 *interactive*。

interpreter shutdown -- 解释器关闭
   当被要求关闭时，Python 解释器将进入一个特殊运行阶段并逐步释放所有已
   分配资源，例如模块和各种关键内部结构等。它还会多次调用 *垃圾回收器*
   。这会触发用户定义析构器或弱引用回调中的代码执行。在关闭阶段执行的
   代码可能会遇到各种异常，因为其所依赖的资源已不再有效（常见的例子有
   库模块或警告机制等）。

   解释器需要关闭的主要原因有 "__main__" 模块或所运行的脚本已完成执行
   。

iterable -- 可迭代对象
   一种能够逐个返回其成员项的对象。 可迭代对象的例子包括所有序列类型（
   如 "list", "str" 和 "tuple" 等）以及某些非序列类型如 "dict", *文件
   对象* 以及任何定义了 "__iter__()" 方法或实现了 *sequence* 语义的
   "__getitem__()" 方法的自定义类的对象。

   可迭代对象可被用于 "for" 循环以及许多其他需要一个序列的地方
   ("zip()", "map()", ...)。 当一个可迭代对象作为参数被传给内置函数
   "iter()" 时，它会返回该对象的迭代器。 这种迭代器适用于对值集合的一
   次性遍历。 在使用可迭代对象时，你通常不需要调用 "iter()" 或者自己处
   理迭代器对象。 "for" 语句会自动为你处理那些操作，创建一个临时的未命
   名变量用来在循环期间保存迭代器。 参见 *iterator*, *sequence* 和
   *generator*。

iterator -- 迭代器
   用来表示一连串数据流的对象。 重复调用迭代器的 "__next__()" 方法 (或
   将其传给内置函数 "next()") 将逐个返回流中的项。 当没有数据可用时则
   将引发 "StopIteration" 异常。 到这时迭代器对象中的数据项已耗尽，继
   续调用其 "__next__()" 方法只会再次引发 "StopIteration"。 迭代器必须
   具有 "__iter__()" 方法用来返回该迭代器对象自身，因此迭代器必定也是
   可迭代对象，可被用于其他可迭代对象适用的大部分场合。 一个显著的例外
   是那些会多次重复访问迭代项的代码。 容器对象 (例如 "list") 在你每次
   将其传入 "iter()" 函数或是在 "for" 循环中使用时都会产生一个新的迭代
   器。 如果在此情况下你尝试用迭代器则会返回在之前迭代过程中被耗尽的同
   一迭代器对象，使其看起来就像是一个空容器。

   更多信息可查看 迭代器类型。

   **CPython 实现细节：** CPython 没有统一应用迭代器定义 "__iter__()"
   的要求。

key function -- 键函数
   键函数或称整理函数，是能够返回用于排序或排位的值的可调用对象。例如
   ，"locale.strxfrm()" 可用于生成一个符合特定区域排序约定的排序键。

   Python 中有许多工具都允许用键函数来控制元素的排位或分组方式。其中包
   括 "min()", "max()", "sorted()", "list.sort()", "heapq.merge()",
   "heapq.nsmallest()", "heapq.nlargest()" 以及 "itertools.groupby()"
   。

   有多种方式可以创建一个键函数。 例如，"str.lower()" 方法可以用作忽略
   大小写排序的键函数。 或者，键函数也可通过 "lambda" 表达式来创建例如
   "lambda r: (r[0], r[2])"。 此外，"operator.attrgetter()",
   "operator.itemgetter()" 和 "operator.methodcaller()" 是键函数的三个
   构造器。 请查看 排序指引 来获取创建和使用键函数的示例。

keyword argument -- 关键字参数
   参见 *argument*。

lambda
   由一个单独 *expression* 构成的匿名内联函数，表达式会在调用时被求值
   。创建 lambda 函数的句法为 "lambda [parameters]: expression"

LBYL
   “先查看后跳跃”的英文缩写。这种代码编写风格会在进行调用或查找之前显
   式地检查前提条件。此风格与 *EAFP* 方式恰成对比，其特点是大量使用
   "if" 语句。

   在多线程环境中，LBYL 方式会导致“查看”和“跳跃”之间发生条件竞争风险。
   例如，以下代码 "if key in mapping: return mapping[key]" 可能由于在
   检查操作之后其他线程从 *mapping* 中移除了 *key* 而出错。这种问题可
   通过加锁或使用 EAFP 方式来解决。

list
   一种 Python 内置 *sequence*。 虽然名为列表，但它更类似于其他语言中
   的数组而非链表，因为访问元素的时间复杂度为 *O*(1)。

list comprehension -- 列表推导式
   处理一个序列中的所有或部分元素并返回结果列表的一种紧凑写法。"result
   = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]" 将生成一
   个 0 到 255 范围内的十六进制偶数对应字符串（0x..）的列表。其中 "if"
   子句是可选的，如果省略则 "range(256)" 中的所有元素都会被处理。

loader -- 加载器
   负责加载模块的对象。它必须定义名为 "load_module()" 的方法。加载器通
   常由一个 *finder* 返回。详情参见 **PEP 302**，对于 *abstract base
   class* 可参见 "importlib.abc.Loader"。

locale encoding -- 语言区域编码格式
   在 Unix 上，它是 LC_CTYPE 语言区域的编码格式。 它可以通过
   "locale.setlocale(locale.LC_CTYPE, new_locale)" 来设置。

   在 Windows 上，它是 ANSI 代码页 (如: ""cp1252"")。

   在 Android 和 VxWorks 上，Python 使用 ""utf-8"" 作为语言区域编码格
   式。

   "locale.getencoding()" 可被用来获取语言区域编码格式。

   另请参阅 *filesystem encoding and error handler*。

magic method -- 魔术方法
   *special method* 的非正式同义词 。

mapping -- 映射
   一种支持任意键查找并实现了 "collections.abc.Mapping" 或
   "collections.abc.MutableMapping" 抽象基类 所规定方法的容器对象。 此
   类对象的例子包括 "dict", "collections.defaultdict",
   "collections.OrderedDict" 以及 "collections.Counter"。

meta path finder -- 元路径查找器
   "sys.meta_path" 的搜索所返回的 *finder*。元路径查找器与 *path entry
   finders* 存在关联但并不相同。

   请查看 "importlib.abc.MetaPathFinder" 了解元路径查找器所实现的方法
   。

metaclass -- 元类
   一种用于创建类的类。类定义包含类名、类字典和基类列表。元类负责接受
   上述三个参数并创建相应的类。大部分面向对象的编程语言都会提供一个默
   认实现。Python 的特别之处在于可以创建自定义元类。大部分用户永远不需
   要这个工具，但当需要出现时，元类可提供强大而优雅的解决方案。它们已
   被用于记录属性访问日志、添加线程安全性、跟踪对象创建、实现单例，以
   及其他许多任务。

   更多详情参见 元类。

method -- 方法
   在类内部定义的函数。如果作为该类的实例的一个属性来调用，方法将会获
   取实例对象作为其第一个 *argument* (通常命名为 "self")。参见
   *function* 和 *nested scope*。

method resolution order -- 方法解析顺序
   方法解析顺序就是在查找成员时搜索基类的顺序。 请参阅 Python 2.3 方法
   解析顺序 了解自 2.3 发布版起 Python 解释器所使用算法的详情。

module
   此对象是 Python 代码的一种组织单位。各模块具有独立的命名空间，可包
   含任意 Python 对象。模块可通过 *importing* 操作被加载到 Python 中。

   另见 *package*。

module spec -- 模块规格
   一个命名空间，其中包含用于加载模块的相关导入信息。是
   "importlib.machinery.ModuleSpec" 的实例。

MRO
   参见 *method resolution order*。

mutable -- 可变对象
   可变对象可以在其 "id()" 保持固定的情况下改变其取值。另请参见
   *immutable*。

named tuple -- 具名元组
   术语“具名元组”可用于任何继承自元组，并且其中的可索引元素还能使用名
   称属性来访问的类型或类。 这样的类型或类还可能拥有其他特性。

   有些内置类型属于具名元组，包括 "time.localtime()" 和 "os.stat()" 的
   返回值。 另一个例子是 "sys.float_info":

      >>> sys.float_info[1]                   # indexed access
      1024
      >>> sys.float_info.max_exp              # named field access
      1024
      >>> isinstance(sys.float_info, tuple)   # kind of tuple
      True

   有些具名元组是内置类型（比如上面的例子）。 此外，具名元组还可通过常
   规类定义从 "tuple" 继承并定义指定名称的字段的方式来创建。 这样的类
   可以手工编号，或者也可以通过继承 "typing.NamedTuple"，或者使用工厂
   函数 "collections.namedtuple()" 来创建。 后一种方式还会添加一些手工
   编写或内置的具名元组所没有的额外方法。

namespace -- 命名空间
   命名空间是存放变量的场所。命名空间有局部、全局和内置的，还有对象中
   的嵌套命名空间（在方法之内）。命名空间通过防止命名冲突来支持模块化
   。例如，函数 "builtins.open" 与 "os.open()" 可通过各自的命名空间来
   区分。命名空间还通过明确哪个模块实现那个函数来帮助提高可读性和可维
   护性。例如，"random.seed()" 或 "itertools.islice()" 这种写法明确了
   这些函数是由 "random" 与 "itertools" 模块分别实现的。

namespace package -- 命名空间包
   **PEP 420** 所引入的一种仅被用作子包的容器的 *package*，命名空间包
   可以没有实体表示物，其描述方式与 *regular package* 不同，因为它们没
   有 "__init__.py" 文件。

   另可参见 *module*。

nested scope -- 嵌套作用域
   在一个定义范围内引用变量的能力。例如，在另一函数之内定义的函数可以
   引用前者的变量。请注意嵌套作用域默认只对引用有效而对赋值无效。局部
   变量的读写都受限于最内层作用域。类似的，全局变量的读写则作用于全局
   命名空间。通过 "nonlocal" 关键字可允许写入外层作用域。

new-style class -- 新式类
   对目前已被应用于所有类对象的类形式的旧称谓。 在较早的 Python 版本中
   ，只有新式类能够使用 Python 新增的更灵活我，如 "__slots__"、描述器
   、特征属性、"__getattribute__()"、类方法和静态方法等。

object -- 对象
   任何具有状态（属性或值）以及预定义行为（方法）的数据。object 也是任
   何 *new-style class* 的最顶层基类名。

包
   一种可包含子模块或递归地包含子包的 Python *module*。 从技术上说，包
   是具有 "__path__" 属性的 Python 模块。

   另参见 *regular package* 和 *namespace package*。

parameter -- 形参
   *function* （或方法）定义中的命名实体，它指定函数可以接受的一个
   *argument* （或在某些情况下，多个实参）。有五种形参：

   * *positional-or-keyword*：位置或关键字，指定一个可以作为 *位置参数
     * 传入也可以作为 *关键字参数* 传入的实参。这是默认的形参类型，例
     如下面的 *foo* 和 *bar*:

        def func(foo, bar=None): ...

   * *positional-only*：仅限位置，指定一个只能通过位置传入的参数。 仅
     限位置形参可通过在函数定义的形参列表中它们之后包含一个 "/" 字符来
     定义，例如下面的 *posonly1* 和 *posonly2*:

        def func(posonly1, posonly2, /, positional_or_keyword): ...

   * *keyword-only*：仅限关键字，指定一个只能通过关键字传入的参数。仅
     限关键字形参可通过在函数定义的形参列表中包含单个可变位置形参或者
     在多个可变位置形参之前放一个 "*" 来定义，例如下面的 *kw_only1* 和
     *kw_only2*:

        def func(arg, *, kw_only1, kw_only2): ...

   * *var-positional*：可变位置，指定可以提供由一个任意数量的位置参数
     构成的序列（附加在其他形参已接受的位置参数之后）。这种形参可通过
     在形参名称前加缀 "*" 来定义，例如下面的 *args*:

        def func(*args, **kwargs): ...

   * *var-keyword*：可变关键字，指定可以提供任意数量的关键字参数（附加
     在其他形参已接受的关键字参数之后）。这种形参可通过在形参名称前加
     缀 "**" 来定义，例如上面的 *kwargs*。

   形参可以同时指定可选和必选参数，也可以为某些可选参数指定默认值。

   另参见 *argument* 术语表条目、参数与形参的区别 中的常见问题、
   "inspect.Parameter" 类、函数定义 一节以及 **PEP 362**。

path entry -- 路径入口
   *import path* 中的一个单独位置，会被 *path based finder* 用来查找要
   导入的模块。

path entry finder -- 路径入口查找器
   任一可调用对象使用 "sys.path_hooks" (即 *path entry hook*) 返回的
   *finder*，此种对象能通过 *path entry* 来定位模块。

   请参看 "importlib.abc.PathEntryFinder" 以了解路径入口查找器所实现的
   各个方法。

path entry hook -- 路径入口钩子
   一种可调用对象，它在知道如何查找特定 *path entry* 中的模块的情况下
   能够使用 "sys.path_hooks" 列表返回一个 *path entry finder*。

path based finder -- 基于路径的查找器
   默认的一种 *元路径查找器*，可在一个 *import path* 中查找模块。

path-like object -- 路径类对象
   代表一个文件系统路径的对象。路径类对象可以是一个表示路径的 "str" 或
   者 "bytes" 对象，还可以是一个实现了 "os.PathLike" 协议的对象。一个
   支持 "os.PathLike" 协议的对象可通过调用 "os.fspath()" 函数转换为
   "str" 或者 "bytes" 类型的文件系统路径；"os.fsdecode()" 和
   "os.fsencode()" 可被分别用来确保获得 "str" 或 "bytes" 类型的结果。
   此对象是由 **PEP 519** 引入的。

PEP
   “Python 增强提议”的英文缩写。一个 PEP 就是一份设计文档，用来向
   Python 社区提供信息，或描述一个 Python 的新增特性及其进度或环境。
   PEP 应当提供精确的技术规格和所提议特性的原理说明。

   PEP 应被作为提出主要新特性建议、收集社区对特定问题反馈以及为必须加
   入 Python 的设计决策编写文档的首选机制。PEP 的作者有责任在社区内部
   建立共识，并应将不同意见也记入文档。

   参见 **PEP 1**。

portion -- 部分
   构成一个命名空间包的单个目录内文件集合（也可能存放于一个 zip 文件内
   ），具体定义见 **PEP 420**。

positional argument -- 位置参数
   参见 *argument*。

provisional API -- 暂定 API
   暂定 API 是指被有意排除在标准库的向后兼容性保证之外的应用编程接口。
   虽然此类接口通常不会再有重大改变，但只要其被标记为暂定，就可能在核
   心开发者确定有必要的情况下进行向后不兼容的更改（甚至包括移除该接口
   ）。此种更改并不会随意进行 -- 仅在 API 被加入之前未考虑到的严重基础
   性缺陷被发现时才可能会这样做。

   即便是对暂定 API 来说，向后不兼容的更改也会被视为“最后的解决方案”
   —— 任何问题被确认时都会尽可能先尝试找到一种向后兼容的解决方案。

   这种处理过程允许标准库持续不断地演进，不至于被有问题的长期性设计缺
   陷所困。详情见 **PEP 411**。

provisional package -- 暂定包
   参见 *provisional API*。

Python 3000
   Python 3.x 发布路线的昵称（这个名字在版本 3 的发布还遥遥无期的时候
   就已出现了）。有时也被缩写为“Py3k”。

Pythonic
   指一个思路或一段代码紧密遵循了 Python 语言最常用的风格和理念，而不
   是使用其他语言中通用的概念来实现代码。例如，Python 的常用风格是使用
   "for" 语句循环来遍历一个可迭代对象中的所有元素。许多其他语言没有这
   样的结构，因此不熟悉 Python 的人有时会选择使用一个数字计数器:

      for i in range(len(food)):
          print(food[i])

   而相应的更简洁更 Pythonic 的方法是这样的:

      for piece in food:
          print(piece)

qualified name -- 限定名称
   一个以点号分隔的名称，显示从模块的全局作用域到该模块中定义的某个类
   、函数或方法的“路径”，相关定义见 **PEP 3155**。对于最高层级的函数和
   类，限定名称与对象名称一致:

      >>> class C:
      ...     class D:
      ...         def meth(self):
      ...             pass
      ...
      >>> C.__qualname__
      'C'
      >>> C.D.__qualname__
      'C.D'
      >>> C.D.meth.__qualname__
      'C.D.meth'

   当被用于引用模块时，*完整限定名称* 意为标示该模块的以点号分隔的整个
   路径，其中包含其所有的父包，例如 "email.mime.text":

      >>> import email.mime.text
      >>> email.mime.text.__name__
      'email.mime.text'

reference count -- 引用计数
   The number of references to an object.  When the reference count of
   an object drops to zero, it is deallocated.  Some objects are
   "immortal" and have reference counts that are never modified, and
   therefore the objects are never deallocated.  Reference counting is
   generally not visible to Python code, but it is a key element of
   the *CPython* implementation.  Programmers can call the
   "sys.getrefcount()" function to return the reference count for a
   particular object.

regular package -- 常规包
   传统型的 *package*，例如包含有一个 "__init__.py" 文件的目录。

   另参见 *namespace package*。

__slots__
   一种写在类内部的声明，通过预先声明实例属性等对象并移除实例字典来节
   省内存。虽然这种技巧很流行，但想要用好却并不容易，最好是只保留在少
   数情况下采用，例如极耗内存的应用程序，并且其中包含大量实例。

sequence
   一种 *iterable*，它支持通过 "__getitem__()" 特殊方法来使用整数索引
   进行高效的元素访问，并定义了一个返回序列长度的 "__len__()" 方法。
   内置的序列类型有 "list", "str", "tuple" 和 "bytes" 等。 请注意虽然
   "dict" 也支持 "__getitem__()" 和 "__len__()"，但它被归类为映射而非
   序列，因为它使用任意 *immutable* 键而不是整数来查找元素。

   "collections.abc.Sequence" 抽象基类定义了一个更丰富的接口，它在
   "__getitem__()" 和 "__len__()" 之外，还添加了 "count()", "index()",
   "__contains__()" 和 "__reversed__()"。 实现此扩展接口的类型可以使用
   "register()" 来显式地注册。 要获取有关通用序列方法的更多文档，请参
   阅 通用序列操作。

set comprehension -- 集合推导式
   处理一个可迭代对象中的所有或部分元素并返回结果集合的一种紧凑写法。
   "results = {c for c in 'abracadabra' if c not in 'abc'}" 将生成字符
   串集合 "{'r', 'd'}"。 参见 列表、集合与字典的显示。

single dispatch -- 单分派
   一种 *generic function* 分派形式，其实现是基于单个参数的类型来选择
   的。

slice -- 切片
   通常只包含了特定 *sequence* 的一部分的对象。切片是通过使用下标标记
   来创建的，在 "[]" 中给出几个以冒号分隔的数字，例如
   "variable_name[1:3:5]"。方括号（下标）标记在内部使用 "slice" 对象。

special method -- 特殊方法
   一种由 Python 隐式调用的方法，用来对某个类型执行特定操作例如相加等
   等。这种方法的名称的首尾都为双下划线。特殊方法的文档参见 特殊方法名
   称。

statement -- 语句
   语句是程序段（一个代码“块”）的组成单位。一条语句可以是一个
   *expression* 或某个带有关键字的结构，例如 "if"、"while" 或 "for"。

static type checker -- 静态类型检查器
   读取 Python 代码并进行分析，以查找问题例如拼写错误的外部工具。 另请
   参阅 *类型提示* 以及 "typing" 模块。

strong reference -- 强引用
   在 Python 的 C API 中，强引用是指为持有引用的代码所拥有的对象的引用
   。 在创建引用时可通过调用 "Py_INCREF()" 来获取强引用而在删除引用时
   可通过 "Py_DECREF()" 来释放它。

   "Py_NewRef()" 函数可被用于创建一个对象的强引用。 通常，必须在退出某
   个强引用的作用域时在该强引用上调用 "Py_DECREF()" 函数，以避免引用的
   泄漏。

   另请参阅 *borrowed reference*。

text encoding -- 文本编码格式
   在Python中，一个字符串是一串 Unicode 代码点（范围为
   "U+0000"--"U+10FFFF"）。 为了存储或传输一个字符串，它需要被序列化为
   一串字节。

   将一个字符串序列化为一个字节序列被称为“编码”，而从字节序列中重新创
   建字符串被称为“解码”。

   有各种不同的文本序列化 编码器 ，它们被统称为 "文本编码格式"。

text file -- 文本文件
   一种能够读写 "str" 对象的 *file object*。通常一个文本文件实际是访问
   一个面向字节的数据流并自动处理 *text encoding*。文本文件的例子包括
   以文本模式（"'r'" 或 "'w'"）打开的文件、"sys.stdin"、"sys.stdout"
   以及 "io.StringIO" 的实例。

   另请参看 *binary file* 了解能够读写 *字节型对象* 的文件对象。

triple-quoted string -- 三引号字符串
   首尾各带三个连续双引号（"）或者单引号（'）的字符串。它们在功能上与
   首尾各用一个引号标注的字符串没有什么不同，但是有多种用处。它们允许
   你在字符串内包含未经转义的单引号和双引号，并且可以跨越多行而无需使
   用连接符，在编写文档字符串时特别好用。

type
   类型决定一个 Python 对象属于什么种类；每个对象都具有一种类型。要知
   道对象的类型，可以访问它的 "__class__" 属性，或是通过 "type(obj)"
   来获取。

type alias -- 类型别名
   一个类型的同义词，创建方式是把类型赋值给特定的标识符。

   类型别名的作用是简化 *类型注解*。例如:

      def remove_gray_shades(
              colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
          pass

   可以这样提高可读性:

      Color = tuple[int, int, int]

      def remove_gray_shades(colors: list[Color]) -> list[Color]:
          pass

   参见 "typing" 和 **PEP 484**，其中有对此功能的详细描述。

type hint -- 类型注解
   *annotation* 为变量、类属性、函数的形参或返回值指定预期的类型。

   类型提示是可选的而不是 Python 的强制要求，但它们对 *静态类型检查器*
   很有用处。 它们还能协助 IDE 实现代码补全与重构。

   全局变量、类属性和函数的类型注解可以使用 "typing.get_type_hints()"
   来访问，但局部变量则不可以。

   参见 "typing" 和 **PEP 484**，其中有对此功能的详细描述。

universal newlines -- 通用换行
   一种解读文本流的方式，将以下所有符号都识别为行结束标志：Unix 的行结
   束约定 "'\n'"、Windows 的约定 "'\r\n'" 以及旧版 Macintosh 的约定
   "'\r'"。参见 **PEP 278** 和 **PEP 3116** 和 "bytes.splitlines()" 了
   解更多用法说明。

variable annotation -- 变量标注
   对变量或类属性的 *annotation*。

   在标注变量或类属性时，还可选择为其赋值:

      class C:
          field: 'annotation'

   变量标注通常被用作 *类型提示*：例如以下变量预期接受 "int" 类型的值:

      count: int = 0

   变量标注语法的详细解释见 带标注的赋值语句 一节。

   参见 *function annotation*, **PEP 484** 和 **PEP 526**，其中描述了
   此功能。 另请参阅 注解最佳实践 以了解使用标注的最佳实践。

virtual environment -- 虚拟环境
   一种采用协作式隔离的运行时环境，允许 Python 用户和应用程序在安装和
   升级 Python 分发包时不会干扰到同一系统上运行的其他 Python 应用程序
   的行为。

   另参见 "venv"。

virtual machine -- 虚拟机
   一台完全通过软件定义的计算机。Python 虚拟机可执行字节码编译器所生成
   的 *bytecode*。

Zen of Python -- Python 之禅
   列出 Python 设计的原则与哲学，有助于理解与使用这种语言。查看其具体
   内容可在交互模式提示符中输入 ""import this""。
