术语表

>>>

交互式解释器的默认 Python 提示符。通常用于可以在解释器中交互执行的代码示例。

...

可以指

  • 当进入缩进代码块的代码、在匹配的左、右分隔符（圆括号、方括号、花括号或三引号）内，或在指定装饰器后，交互式解释器在输入代码时的默认 Python 提示符。

  • 内置常量 Ellipsis。

2to3

一个工具，尝试通过处理大多数可以通过解析源代码并遍历解析树来检测到的不兼容性，将 Python 2.x 代码转换为 Python 3.x 代码。

2to3 在标准库中可用，名为 lib2to3；一个独立的入口点作为 Tools/scripts/2to3 提供。参见 2to3 — 自动 Python 2 到 3 代码转换.

抽象基类

抽象基类补充了 鸭子类型，通过提供一种在其他技术（如 hasattr()）笨拙或微妙地错误（例如使用 魔术方法）时定义接口的方法。ABC 引入了虚拟子类，这些子类不继承自任何类，但仍然被 isinstance() 和 issubclass() 识别；参见 abc 模块文档。Python 带有许多用于数据结构（在 collections.abc 模块中）、数字（在 numbers 模块中）、流（在 io 模块中）、导入查找器和加载器（在 importlib.abc 模块中）的内置 ABC。可以使用 abc 模块创建自己的 ABC。

注解

与变量、类属性或函数参数或返回值关联的标签，按照惯例用作 类型提示。

局部变量的注解在运行时无法访问，但全局变量、类属性和函数的注解分别存储在模块、类和函数的 __annotations__ 特殊属性中。

参见 变量注解、函数注解、PEP 484 和 PEP 526，这些文档描述了此功能。另请参见 注解最佳实践，了解有关使用注解的最佳实践。

参数

在调用函数时传递给 函数（或 方法）的值。参数有两种类型

  • 关键字参数：在函数调用中，以标识符（例如 name=）为前缀的参数，或者作为以 ** 为前缀的字典中的值传递。例如，在以下对 complex() 的调用中，3 和 5 都是关键字参数

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

  • 位置参数：不是关键字参数的参数。位置参数可以出现在参数列表的开头，也可以作为以 * 为前缀的 可迭代对象 的元素传递。例如，在以下调用中，3 和 5 都是位置参数

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

参数被分配给函数体中的命名局部变量。有关此分配规则，请参见 调用 部分。从语法上讲，任何表达式都可以用来表示参数；计算后的值被分配给局部变量。

另请参见 参数 词汇表条目、关于 参数和参数之间的区别 的常见问题解答，以及 PEP 362。

异步上下文管理器

通过定义 __aenter__() 和 __aexit__() 方法，控制在 async with 语句中看到的环境。由 PEP 492 引入。

异步生成器

返回 异步生成器迭代器 的函数。它看起来像一个用 async def 定义的协程函数，只是它包含 yield 表达式，用于生成一系列可用于 async for 循环的值。

通常指的是异步生成器函数，但在某些情况下也可能指的是异步生成器迭代器。在含义不明确的情况下，使用完整的术语可以避免歧义。

异步生成器函数可能包含 await 表达式，以及 async for 和 async with 语句。

异步生成器迭代器

由 异步生成器 函数创建的对象。

这是一个 异步迭代器，当使用 __anext__() 方法调用时，它会返回一个可等待对象，该对象将执行异步生成器函数的主体，直到下一个 yield 表达式。

每个 yield 会暂时挂起处理，记住执行状态的位置（包括局部变量和待处理的 try 语句）。当异步生成器迭代器使用 __anext__() 返回的另一个可等待对象有效地恢复时，它会从它停止的地方继续执行。参见 PEP 492 和 PEP 525。

异步可迭代对象

一个可以在 async for 语句中使用的对象。必须从其 __aiter__() 方法返回一个 异步迭代器。由 PEP 492 引入。

异步迭代器

一个实现了 __aiter__() 和 __anext__() 方法的对象。 __anext__() 必须返回一个 可等待对象。 async for 会解析异步迭代器的 __anext__() 方法返回的可等待对象，直到它引发一个 StopAsyncIteration 异常。由 PEP 492 引入。

属性

与对象关联的值，通常使用点表达式按名称引用。例如，如果一个对象o有一个属性a，它将被引用为o.a。

可以给对象一个属性，其名称不是由 标识符和关键字 定义的标识符，例如使用 setattr()，如果对象允许的话。这样的属性将无法使用点表达式访问，而需要使用 getattr() 获取。

可等待对象

一个可以在 await 表达式中使用的对象。可以是 协程 或具有 __await__() 方法的对象。另见 PEP 492。

BDFL

终身仁慈独裁者，又称 Guido van Rossum，Python 的创造者。

二进制文件

一个能够读取和写入字节类对象的文件对象。二进制文件的例子包括以二进制模式打开的文件（'rb'、'wb'或'rb+'）、sys.stdin.buffer、sys.stdout.buffer，以及io.BytesIO和gzip.GzipFile的实例。

另请参见文本文件，它是一个能够读取和写入str对象的文件对象。

借用引用

在 Python 的 C API 中，借用引用是指对对象的引用，其中使用该对象的代码不拥有该引用。如果对象被销毁，它将变成一个悬空指针。例如，垃圾回收可以删除对对象的最后一个强引用，从而销毁它。

建议在借用引用上调用Py_INCREF()，将其就地转换为强引用，除非对象在借用引用最后一次使用之前不能被销毁。可以使用Py_NewRef()函数创建一个新的强引用。

字节类对象

支持缓冲区协议并可以导出 C-连续缓冲区的对象。这包括所有bytes、bytearray和array.array对象，以及许多常见的memoryview对象。字节类对象可用于各种处理二进制数据的操作；这些操作包括压缩、保存到二进制文件以及通过套接字发送。

某些操作需要二进制数据可变。文档中通常将这些操作称为“读写字节类对象”。可变缓冲区对象的例子包括bytearray和memoryview（bytearray）。其他操作需要将二进制数据存储在不可变对象中（“只读字节类对象”）；这些对象的例子包括bytes和memoryview（bytes对象）。

字节码

Python 源代码被编译成字节码，这是 CPython 解释器中 Python 程序的内部表示。字节码也被缓存到 .pyc 文件中，以便第二次执行同一个文件更快（可以避免从源代码到字节码的重新编译）。这种“中间语言”据说运行在一个 虚拟机 上，该虚拟机执行与每个字节码相对应的机器代码。请注意，字节码不应在不同的 Python 虚拟机之间工作，也不应在 Python 版本之间保持稳定。

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

可调用对象

可调用对象是可以调用的对象，可能带有一组参数（参见 参数），使用以下语法

callable(argument1, argument2, argumentN)

一个 函数，以及扩展的 方法，都是可调用对象。实现 __call__() 方法的类的实例也是可调用对象。

回调函数

作为参数传递的子例程函数，将在将来的某个时间点执行。

类

用于创建用户定义对象的模板。类定义通常包含方法定义，这些方法定义对类的实例进行操作。

类变量

在类中定义的变量，旨在仅在类级别（即不在类的实例中）修改。

复数

对熟悉的实数系统的扩展，其中所有数字都表示为实部和虚部的总和。虚数是虚数单位（-1 的平方根）的实数倍数，通常在数学中写为 i，在工程中写为 j。Python 内置支持复数，这些复数使用后一种表示法编写；虚部用 j 后缀编写，例如 3+1j。要访问 math 模块的复数等效项，请使用 cmath。复数的使用是一个相当高级的数学特性。如果你没有意识到需要它们，你几乎可以肯定可以安全地忽略它们。

上下文管理器

一个对象，它通过定义 __enter__() 和 __exit__() 方法来控制在 with 语句中看到的环境。参见 PEP 343.

上下文变量

一个根据其上下文可能具有不同值的变量。这类似于线程局部存储，其中每个执行线程可能对一个变量具有不同的值。但是，对于上下文变量，一个执行线程中可能存在多个上下文，上下文变量的主要用途是跟踪并发异步任务中的变量。请参阅 contextvars。

连续的

如果缓冲区是C 连续或Fortran 连续，则认为它是连续的。零维缓冲区是 C 和 Fortran 连续的。在一维数组中，项目必须按内存地址顺序排列，从零开始按递增索引排列。在多维 C 连续数组中，最后一个索引在按内存地址顺序访问项目时变化最快。但是，在 Fortran 连续数组中，第一个索引变化最快。

协程

协程是子例程的更通用形式。子例程从一个点进入，从另一个点退出。协程可以在许多不同的点进入、退出和恢复。它们可以使用 async def 语句实现。另请参阅 PEP 492。

协程函数

返回一个 协程 对象的函数。协程函数可以使用 async def 语句定义，并且可能包含 await、async for 和 async with 关键字。这些是由 PEP 492 引入的。

CPython

Python 编程语言的规范实现，如 python.org 上发布的。当需要区分此实现与其他实现（如 Jython 或 IronPython）时，使用术语“CPython”。

装饰器

一个返回另一个函数的函数，通常用作使用 @wrapper 语法的函数转换。装饰器的常见示例是 classmethod() 和 staticmethod()。

装饰器语法仅仅是语法糖，以下两个函数定义在语义上是等效的

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

@staticmethod
def f(arg):
    ...

类也存在相同的概念，但那里不太常用。有关装饰器的更多信息，请参阅 函数定义 和 类定义 的文档。

描述符

任何定义了方法 __get__()、__set__() 或 __delete__() 的对象。当类属性是描述符时，其特殊的绑定行为会在属性查找时触发。通常，使用 a.b 来获取、设置或删除属性会在 a 的类字典中查找名为 b 的对象，但如果 b 是描述符，则会调用相应的描述符方法。理解描述符是深入理解 Python 的关键，因为它们是许多功能的基础，包括函数、方法、属性、类方法、静态方法以及对超类的引用。

有关描述符方法的更多信息，请参阅 实现描述符 或 描述符操作指南。

字典

一种关联数组，其中任意键映射到值。键可以是任何具有 __hash__() 和 __eq__() 方法的对象。在 Perl 中称为哈希。

字典推导

一种紧凑的方式来处理可迭代对象中的所有或部分元素，并返回包含结果的字典。 results = {n: n ** 2 for n in range(10)} 生成一个字典，其中键 n 映射到值 n ** 2。参见 列表、集合和字典的显示。

字典视图

从 dict.keys()、dict.values() 和 dict.items() 返回的对象称为字典视图。它们提供了对字典条目的动态视图，这意味着当字典发生变化时，视图会反映这些变化。要强制字典视图变为完整的列表，请使用 list(dictview)。参见 字典视图对象。

文档字符串

出现在类、函数或模块中第一个表达式中的字符串字面量。虽然在执行套件时被忽略，但它会被编译器识别并放入封闭类、函数或模块的 __doc__ 属性中。由于它可以通过内省获得，因此它是对象文档的规范位置。

鸭子类型

一种编程风格，不查看对象的类型来确定它是否具有正确的接口；相反，方法或属性只是被调用或使用（“如果它看起来像鸭子，叫起来也像鸭子，它一定就是鸭子。”）。通过强调接口而不是特定类型，设计良好的代码通过允许多态替换来提高其灵活性。鸭子类型避免使用 type() 或 isinstance() 进行测试。（但是，请注意，鸭子类型可以与 抽象基类 相辅相成。）相反，它通常使用 hasattr() 测试或 EAFP 编程。

EAFP

请求原谅比获得许可更容易。这种常见的 Python 编码风格假设存在有效的键或属性，并在假设被证明是错误时捕获异常。这种简洁快速的风格的特点是存在许多 try 和 except 语句。这种技术与许多其他语言（如 C）中常见的 LBYL 风格形成对比。

表达式

可以计算为某个值的语法片段。换句话说，表达式是表达式元素（如字面量、名称、属性访问、运算符或函数调用）的累积，这些元素都返回一个值。与许多其他语言相比，并非所有语言结构都是表达式。还有一些 语句 不能用作表达式，例如 while。赋值也是语句，而不是表达式。

扩展模块

用 C 或 C++ 编写的模块，使用 Python 的 C API 与核心和用户代码进行交互。

f-字符串

以 'f' 或 'F' 为前缀的字符串字面量通常被称为“f-字符串”，它是 格式化字符串字面量 的简称。另请参见 PEP 498.

文件对象

一个对象，它向底层资源公开面向文件的 API（具有 read() 或 write() 等方法）。根据其创建方式，文件对象可以介导对真实磁盘文件的访问，也可以介导对其他类型的存储或通信设备的访问（例如标准输入/输出、内存缓冲区、套接字、管道等）。文件对象也称为 类文件对象 或 流。

实际上，文件对象有三种类别：原始 二进制文件、缓冲 二进制文件 和 文本文件。它们的接口在 io 模块中定义。创建文件对象的规范方法是使用 open() 函数。

类文件对象

是 文件对象 的同义词。

文件系统编码和错误处理程序

Python 用于从操作系统解码字节并向操作系统编码 Unicode 的编码和错误处理程序。

文件系统编码必须保证成功解码所有小于 128 的字节。如果文件系统编码无法提供此保证，API 函数可能会引发 UnicodeError。

sys.getfilesystemencoding() 和 sys.getfilesystemencodeerrors() 函数可用于获取文件系统编码和错误处理程序。

文件系统编码和错误处理程序 在 Python 启动时由 PyConfig_Read() 函数配置：请参阅 filesystem_encoding 和 filesystem_errors 成员 PyConfig。

另请参阅 区域设置编码。

查找器

一个尝试查找正在导入的模块的 加载器 的对象。

查找器有两种类型：用于 sys.meta_path 的 元路径查找器 和用于 sys.path_hooks 的 路径条目查找器。

有关更多详细信息，请参阅 导入系统 和 importlib。

向下取整除法

向下取整到最接近的整数的数学除法。向下取整除法运算符为 //。例如，表达式 11 // 4 计算结果为 2，与浮点数真除法返回的 2.75 相反。请注意，(-11) // 4 为 -3，因为这是 -2.75 向下取整的结果。请参阅 PEP 238。

函数

一系列语句，这些语句会向调用者返回某个值。它还可以传递零个或多个 参数，这些参数可能在执行主体时使用。另请参阅 参数、方法 以及 函数定义 部分。

函数注解

函数参数或返回值的 注解。

函数注解通常用于 类型提示：例如，此函数预计将接受两个 int 参数，并且还预计将具有 int 返回值

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

函数注解语法在 函数定义 部分进行了说明。

请参阅 变量注解 和 PEP 484，它们描述了此功能。另请参阅 注解最佳实践，以了解有关使用注解的最佳实践。

__future__

一个 未来语句，from __future__ import <feature>，指示编译器使用将在未来版本的 Python 中成为标准的语法或语义来编译当前模块。 __future__ 模块记录了 feature 的可能值。通过导入此模块并评估其变量，您可以查看新功能何时首次添加到语言中以及何时将（或已）成为默认值。

>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
垃圾回收

当内存不再使用时释放内存的过程。Python 通过引用计数和能够检测和打破引用循环的循环垃圾收集器来执行垃圾回收。可以使用 gc 模块控制垃圾收集器。

生成器

返回一个 生成器迭代器 的函数。它看起来像一个普通的函数，除了它包含 yield 表达式来生成一系列值，这些值可以在 for 循环中使用，或者可以使用 next() 函数一次检索一个值。

通常指生成器函数，但在某些情况下可能指 生成器迭代器。在含义不明确的情况下，使用完整术语可以避免歧义。

生成器迭代器

由 生成器 函数创建的对象。

每个 yield 会暂时暂停处理，记住执行状态的位置（包括局部变量和挂起的 try 语句）。当 生成器迭代器 恢复时，它会从它停止的地方继续（与每次调用都从头开始的函数形成对比）。

生成器表达式

返回迭代器的表达式。它看起来像一个普通的表达式，后面跟着一个 for 子句，定义一个循环变量、范围和一个可选的 if 子句。组合表达式为封闭函数生成值。

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

由多个函数组成的函数，这些函数对不同类型执行相同的操作。在调用期间应使用哪个实现由调度算法确定。

另请参阅 单分派 词汇表条目、functools.singledispatch() 装饰器和 PEP 443。

泛型类型

可以参数化的 类型；通常是 容器类，例如 list 或 dict。用于 类型提示 和 注释。

有关更多详细信息，请参阅 泛型别名类型、PEP 483、PEP 484、PEP 585 以及 typing 模块。

GIL

参见 全局解释器锁.

全局解释器锁

由 CPython 解释器使用的机制，以确保一次只有一个线程执行 Python 字节码。这通过使对象模型（包括关键的内置类型，如 dict）隐式地安全地防止并发访问，从而简化了 CPython 的实现。锁定整个解释器使得解释器更容易实现多线程，但代价是牺牲了多处理器机器所能提供的许多并行性。

但是，一些扩展模块（无论是标准模块还是第三方模块）的设计目的是在执行诸如压缩或哈希之类的计算密集型任务时释放 GIL。此外，在执行 I/O 时始终会释放 GIL。

过去创建“无线程”解释器（一种以更细粒度锁定共享数据的解释器）的努力一直没有成功，因为在常见的单处理器情况下性能会下降。人们认为，克服这种性能问题将使实现变得更加复杂，因此维护成本更高。

基于哈希的 pyc

一种字节码缓存文件，它使用哈希而不是相应源文件的最后修改时间来确定其有效性。参见 缓存的字节码失效.

可哈希的

如果一个对象具有在它的一生中永远不会改变的哈希值（它需要一个 __hash__() 方法），并且可以与其他对象进行比较（它需要一个 __eq__() 方法），那么它就是可哈希的。比较相等的哈希对象必须具有相同的哈希值。

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

Python 的大多数不可变内置对象都是可哈希的；可变容器（如列表或字典）不是；不可变容器（如元组和冻结集）只有在它们的元素可哈希的情况下才是可哈希的。用户定义类的实例对象默认情况下是可哈希的。它们都进行不相等比较（除了与自身比较），并且它们的哈希值是从它们的 id() 派生的。

IDLE

Python 的集成开发和学习环境。 IDLE 是一个基本的编辑器和解释器环境，随 Python 的标准发行版一起提供。

不可变的

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

导入路径

由 基于路径的查找器 搜索要导入的模块的多个位置（或 路径条目）的列表。在导入过程中，此位置列表通常来自 sys.path，但对于子包，它也可能来自父包的 __path__ 属性。

导入

将一个模块中的 Python 代码提供给另一个模块中的 Python 代码的过程。

导入器

一个既能找到又能加载模块的对象；既是 查找器 又是 加载器 对象。

交互式

Python 拥有一个交互式解释器，这意味着您可以在解释器提示符处输入语句和表达式，立即执行它们并查看结果。只需启动 python 而不带任何参数（可能通过从计算机的主菜单中选择它）。这是一种非常强大的方法来测试新想法或检查模块和包（记住 help(x)）。

解释型

Python 是一种解释型语言，而不是编译型语言，尽管由于字节码编译器的存在，这种区别可能很模糊。这意味着源文件可以直接运行，而无需显式创建可执行文件，然后运行。解释型语言通常比编译型语言具有更短的开发/调试周期，尽管它们的程序通常运行速度也更慢。另请参见 交互式。

解释器关闭

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

解释器关闭的主要原因是 __main__ 模块或正在运行的脚本已完成执行。

可迭代的

能够一次返回一个成员的对象。可迭代对象的示例包括所有序列类型（例如 list、str 和 tuple）以及一些非序列类型，如 dict、文件对象 以及您定义的具有 __iter__() 方法或具有实现 序列 语义的 __getitem__() 方法的任何类的对象。

可迭代对象可以在 for 循环中使用，以及在需要序列的许多其他地方使用（zip()、map()，…）。当可迭代对象作为参数传递给内置函数 iter() 时，它会返回该对象的迭代器。此迭代器适用于对值集进行一次遍历。在使用可迭代对象时，通常不需要调用 iter() 或自己处理迭代器对象。 for 语句会自动为您执行此操作，创建一个临时未命名的变量来保存循环持续时间内的迭代器。另请参见 迭代器、序列 和 生成器。

迭代器

表示数据流的对象。重复调用迭代器的 __next__() 方法（或将其传递给内置函数 next()）将返回流中的后续项。当没有更多数据可用时，将引发 StopIteration 异常。此时，迭代器对象已耗尽，任何进一步对其 __next__() 方法的调用都会再次引发 StopIteration。迭代器需要具有 __iter__() 方法，该方法返回迭代器对象本身，因此每个迭代器也是可迭代的，并且可以在大多数接受其他可迭代对象的地方使用。一个值得注意的例外是尝试多次迭代传递的代码。容器对象（例如 list）每次将它传递给 iter() 函数或在 for 循环中使用它时，都会生成一个新的迭代器。尝试对迭代器执行此操作只会返回在先前迭代传递中使用的相同已耗尽的迭代器对象，使其看起来像一个空容器。

可以在 迭代器类型 中找到更多信息。

CPython 实现细节：CPython 并不始终如一地应用迭代器定义 __iter__() 的要求。

键函数

键函数或排序函数是一个可调用对象，它返回用于排序或排序的值。例如，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() 是三个关键函数构造器。有关如何创建和使用关键函数的示例，请参阅 排序 HOW TO。

关键字参数

参见 参数。

lambda

一个匿名内联函数，它包含一个单一的 表达式，该表达式在函数被调用时进行评估。创建 lambda 函数的语法是 lambda [parameters]: expression

LBYL

三思而后行。这种编码风格在进行调用或查找之前显式地测试先决条件。这种风格与 EAFP 方法形成对比，其特征是存在许多 if 语句。

在多线程环境中，LBYL 方法可能会在“查看”和“跳跃”之间引入竞争条件。例如，代码 if key in mapping: return mapping[key] 可能会在测试之后但查找之前，如果另一个线程从 mapping 中删除了 key，则会失败。这个问题可以通过锁或使用 EAFP 方法来解决。

列表

一个内置的 Python 序列。尽管它的名字，它更类似于其他语言中的数组，而不是链接列表，因为对元素的访问是 O(1)。

列表推导

一种紧凑的方式来处理序列中的所有或部分元素，并返回一个包含结果的列表。 result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] 生成一个字符串列表，其中包含范围从 0 到 255 的偶数十六进制数 (0x..)。if 子句是可选的。如果省略，则处理 range(256) 中的所有元素。

加载器

加载模块的对象。它必须定义一个名为 load_module() 的方法。加载器通常由 查找器 返回。有关详细信息，请参阅 PEP 302，有关 抽象基类，请参阅 importlib.abc.Loader。

区域设置编码

在 Unix 上，它是 LC_CTYPE 区域设置的编码。可以使用 locale.setlocale(locale.LC_CTYPE, new_locale) 设置它。

在 Windows 上，它是 ANSI 代码页（例如："cp1252"）。

在 Android 和 VxWorks 上，Python 使用 "utf-8" 作为区域设置编码。

locale.getencoding() 可用于获取区域设置编码。

另请参阅 文件系统编码和错误处理程序。

魔术方法

特殊方法 的非正式同义词。

映射

支持任意键查找并实现 collections.abc.Mapping 或 collections.abc.MutableMapping 抽象基类 中指定方法的容器对象。示例包括 dict、collections.defaultdict、collections.OrderedDict 和 collections.Counter。

元路径查找器

由 sys.meta_path 搜索返回的 查找器。元路径查找器与 路径条目查找器 相关，但不同。

有关元路径查找器实现的方法，请参阅 importlib.abc.MetaPathFinder。

元类

类的类。类定义创建类名、类字典和基类列表。元类负责获取这三个参数并创建类。大多数面向对象编程语言都提供默认实现。Python 的特殊之处在于可以创建自定义元类。大多数用户永远不需要此工具，但当需要时，元类可以提供强大而优雅的解决方案。它们已用于记录属性访问、添加线程安全性、跟踪对象创建、实现单例以及许多其他任务。

有关更多信息，请参阅 元类。

方法

在类主体内部定义的函数。如果作为该类实例的属性调用，该方法将获取实例对象作为其第一个 参数（通常称为 self）。请参阅 函数 和 嵌套范围。

方法解析顺序

方法解析顺序是在查找期间搜索基类的顺序。有关 Python 解释器自 2.3 版本以来使用的算法的详细信息，请参阅 Python 2.3 方法解析顺序。

模块

用作 Python 代码组织单元的对象。模块具有包含任意 Python 对象的命名空间。模块通过 导入 过程加载到 Python 中。

另请参阅 包。

模块规范

包含用于加载模块的导入相关信息的命名空间。 importlib.machinery.ModuleSpec 的实例。

MRO

参见 方法解析顺序。

可变的

可变对象可以改变其值，但保留其 id()。另请参阅 不可变。

具名元组

术语“具名元组”适用于任何继承自元组且其可索引元素也可以使用具名属性访问的类型或类。该类型或类也可能具有其他功能。

几个内置类型是具名元组，包括由 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() 来创建。后一种技术还添加了一些在手工编写或内置具名元组中可能找不到的额外方法。

命名空间

存储变量的位置。命名空间以字典的形式实现。有局部、全局和内置命名空间，以及对象（在方法中）中的嵌套命名空间。命名空间通过防止命名冲突来支持模块化。例如，函数 builtins.open 和 os.open() 通过其命名空间区分。命名空间还有助于可读性和可维护性，因为它清楚地表明哪个模块实现了某个函数。例如，编写 random.seed() 或 itertools.islice() 清楚地表明这些函数分别由 random 和 itertools 模块实现。

命名空间包

一个 PEP 420 包，它仅用作子包的容器。命名空间包可能没有物理表示，特别是它们不像 常规包 那样，因为它们没有 __init__.py 文件。

另请参阅 模块。

嵌套作用域

在封闭定义中引用变量的能力。例如，在另一个函数内部定义的函数可以引用外部函数中的变量。请注意，默认情况下，嵌套作用域仅适用于引用，而不适用于赋值。局部变量在最内层作用域中进行读写。同样，全局变量读写全局命名空间。使用 nonlocal 可以写入外部作用域。

新式类

现在所有类对象都使用的类类型的旧名称。在早期的 Python 版本中，只有新式类可以使用 Python 的更新、更通用的功能，例如 __slots__、描述符、属性、__getattribute__()、类方法和静态方法。

对象

任何具有状态（属性或值）和定义行为（方法）的数据。也是任何 新式类 的最终基类。

包

一个 Python 模块，它可以包含子模块或递归地包含子包。从技术上讲，包是一个具有 __path__ 属性的 Python 模块。

另请参见 常规包 和 命名空间包。

参数

在 函数（或方法）定义中，指定函数可以接受的 参数（或在某些情况下，参数）的命名实体。参数有五种类型

  • 位置或关键字：指定可以按 位置 或作为 关键字参数 传递的参数。这是默认的参数类型，例如以下示例中的 foo 和 bar

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

  • 仅位置：指定只能按位置提供的参数。仅位置参数可以通过在函数定义的参数列表中，它们之后包含一个 / 字符来定义，例如以下示例中的 posonly1 和 posonly2

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

  • 仅关键字：指定只能通过关键字提供的参数。仅关键字参数可以通过在函数定义的参数列表中，它们之前包含一个单个变长位置参数或裸 * 来定义，例如以下示例中的 kw_only1 和 kw_only2

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

  • 变长位置：指定可以提供任意数量的位置参数序列（除了其他参数已经接受的任何位置参数之外）。可以通过在参数名称前加上 * 来定义此类参数，例如以下示例中的 args

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

  • 变长关键字：指定可以提供任意数量的关键字参数（除了其他参数已经接受的任何关键字参数之外）。可以通过在参数名称前加上 ** 来定义此类参数，例如上面示例中的 kwargs。

参数可以指定可选参数和必需参数，以及某些可选参数的默认值。

另请参见 参数 词汇表条目、关于 参数和参数之间的区别 的常见问题解答、inspect.Parameter 类、函数定义 部分以及 PEP 362。

路径条目

在导入路径上的单个位置，基于路径的查找器会查询该位置以查找要导入的模块。

路径条目查找器

一个由sys.path_hooks（即路径条目钩子）上的可调用对象返回的查找器，它知道如何在给定路径条目的情况下定位模块。

有关路径条目查找器实现的方法，请参见importlib.abc.PathEntryFinder。

路径条目钩子

sys.path_hooks列表上的可调用对象，如果它知道如何在特定路径条目上查找模块，则返回一个路径条目查找器。

基于路径的查找器

默认元路径查找器之一，它在导入路径中搜索模块。

路径类对象

表示文件系统路径的对象。路径类对象是表示路径的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。

部分

一组位于单个目录中的文件（可能存储在 zip 文件中），它们为命名空间包做出贡献，如 PEP 420 中所定义。

位置参数

参见 参数。

临时 API

临时 API 是指那些有意从标准库的向后兼容性保证中排除的 API。虽然预计对这些接口的重大更改不会发生，但只要它们被标记为临时，如果核心开发人员认为有必要，可能会发生向后不兼容的更改（包括删除接口）。这种更改不会随意进行——只有在发现之前包含 API 时未发现的严重基本缺陷时才会发生。

即使对于临时 API，向后不兼容的更改也被视为“最后的手段”——仍然会尽一切努力找到任何已识别问题的向后兼容解决方案。

此过程允许标准库随着时间的推移继续发展，而不会将有问题的设计错误锁定在很长一段时间内。有关更多详细信息，请参阅 PEP 411。

临时包

参见 临时 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)
限定名称

一个点分隔的名称，显示从模块的全局范围到该模块中定义的类、函数或方法的“路径”，如 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'
引用计数

对对象的引用次数。当对象的引用计数降至零时，它将被释放。一些对象是“永生”的，它们的引用计数永远不会被修改，因此这些对象永远不会被释放。引用计数通常对 Python 代码不可见，但它是 CPython 实现的关键要素。程序员可以调用 sys.getrefcount() 函数来返回特定对象的引用计数。

常规包

传统的 包，例如包含 __init__.py 文件的目录。

另请参见 命名空间包。

__slots__

在类中声明一个 __slots__ 属性，可以预先声明实例属性的空间，并消除实例字典，从而节省内存。虽然这种技术很流行，但要正确使用它却有点棘手，最好只在内存关键型应用程序中实例数量很多的情况下使用。

序列

一个 可迭代对象，它支持使用整数索引通过 __getitem__() 特殊方法进行高效的元素访问，并定义一个 __len__() 方法，该方法返回序列的长度。一些内置的序列类型有 list、str、tuple 和 bytes。请注意，dict 也支持 __getitem__() 和 __len__()，但它被认为是映射而不是序列，因为查找使用的是任意 不可变 键而不是整数。

The collections.abc.Sequence 抽象基类定义了一个更丰富的接口，它不仅仅是 __getitem__() 和 __len__()，还添加了 count()、index()、__contains__() 和 __reversed__()。实现此扩展接口的类型可以使用 register() 显式注册。有关序列方法的一般文档，请参阅 常见序列操作。

集合推导式

一种紧凑的方式来处理可迭代对象中的所有或部分元素，并返回一个包含结果的集合。 results = {c for c in 'abracadabra' if c not in 'abc'} 生成字符串集合 {'r', 'd'}。参见 列表、集合和字典的显示。

单分派

一种 泛型函数 分派形式，其中实现是根据单个参数的类型选择的。

切片

一个通常包含 序列 部分的对象。切片是使用下标符号创建的，[] 在多个数字之间使用冒号，例如在 variable_name[1:3:5] 中。括号（下标）符号在内部使用 slice 对象。

特殊方法

一种由 Python 隐式调用以对类型执行特定操作（例如加法）的方法。此类方法的名称以双下划线开头和结尾。特殊方法在 特殊方法名称 中有记录。

语句

语句是套件（代码“块”）的一部分。语句要么是 表达式，要么是带关键字的几种结构之一，例如 if、while 或 for。

静态类型检查器

一种外部工具，它读取 Python 代码并对其进行分析，查找诸如类型不正确之类的错误。另请参见 类型提示 和 typing 模块。

强引用

在 Python 的 C API 中，强引用是指对由持有引用的代码拥有的对象的引用。强引用是在创建引用时通过调用 Py_INCREF() 获取的，并在删除引用时通过调用 Py_DECREF() 释放。

Py_NewRef() 函数可用于创建对对象的强引用。通常，必须在退出强引用范围之前对强引用调用 Py_DECREF() 函数，以避免泄漏一个引用。

另请参见 借用引用。

文本编码

Python 中的字符串是 Unicode 代码点的序列（范围为 U+0000–U+10FFFF）。要存储或传输字符串，需要将其序列化为字节序列。

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

存在各种不同的文本序列化 编解码器，它们统称为“文本编码”。

文本文件

一个能够读取和写入 文件对象 的 str 对象。通常，文本文件实际上访问的是面向字节的数据流，并自动处理 文本编码。文本文件的示例包括以文本模式打开的文件（'r' 或 'w'）、sys.stdin、sys.stdout 以及 io.StringIO 的实例。

另请参见 二进制文件，它是一个能够读取和写入 类字节对象 的文件对象。

三引号字符串

一个由三个引号（”）或三个撇号（’）包围的字符串。虽然它们没有提供单引号字符串所没有的功能，但它们在许多方面很有用。它们允许你在字符串中包含未转义的单引号和双引号，并且可以跨越多行而无需使用续行符，这使得它们在编写文档字符串时特别有用。

类型

Python 对象的类型决定了它是什么类型的对象；每个对象都有一个类型。对象的类型可以通过其 __class__ 属性访问，也可以通过 type(obj) 获取。

类型别名

类型的同义词，通过将类型分配给标识符来创建。

类型别名对于简化 类型提示 很有用。例如

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，它们描述了此功能。

类型提示

一个 注释，它指定变量、类属性或函数参数或返回值的预期类型。

类型提示是可选的，并且不会被 Python 强制执行，但它们对于 静态类型检查器 很有用。它们还可以帮助 IDE 完成代码并进行重构。

全局变量、类属性和函数的类型提示（但不是局部变量）可以使用 typing.get_type_hints() 访问。

请参见 typing 和 PEP 484，它们描述了此功能。

通用换行符

一种解释文本流的方式，其中以下所有内容都被识别为行结束符：Unix 行结束符约定 '\n'、Windows 约定 '\r\n' 以及旧的 Macintosh 约定 '\r'。请参见 PEP 278 和 PEP 3116，以及 bytes.splitlines() 以了解其他用途。

变量注释

变量或类属性的 注释。

在注释变量或类属性时，赋值是可选的

class C:
    field: 'annotation'

变量注释通常用于 类型提示：例如，此变量预期接受 int 值

count: int = 0

变量注释语法在 带注释的赋值语句 部分进行了说明。

参见 函数注释，PEP 484 和 PEP 526，它们描述了此功能。另请参见 注释最佳实践，了解有关使用注释的最佳实践。

虚拟环境

一个协作隔离的运行时环境，允许 Python 用户和应用程序安装和升级 Python 发行版软件包，而不会干扰同一系统上运行的其他 Python 应用程序的行为。

另请参见 venv。

虚拟机

一个完全用软件定义的计算机。Python 的虚拟机执行由字节码编译器发出的 字节码。

Python 之禅

列出了 Python 设计原则和理念，有助于理解和使用该语言。该列表可以通过在交互式提示符中键入“import this”来找到。