词汇表 — Python 文档

词汇表

>>>

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

...

可以参考：

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

• Ellipsis 内置常量。

2对3

一种尝试通过处理大部分不兼容性来将 Python 2.x 代码转换为 Python 3.x 代码的工具，这些不兼容性可以通过解析源代码和遍历解析树来检测。

2to3 在标准库中作为 lib2to3 可用； 一个独立的入口点作为 Tools/scripts/2to3 提供。 请参阅 2to3 - 自动 Python 2 到 3 代码翻译。

抽象基类

抽象基类通过提供一种定义接口的方法来补充 duck-typing，当其他技术如 hasattr() 会笨拙或微妙错误时（例如使用 magic methods ]）。 ABCs 引入了虚子类，它们是不从类继承但仍被 isinstance() 和 issubclass() 识别的类； 请参阅 abc 模块文档。 Python 带有许多用于数据结构（在 collections.abc 模块中）、数字（在 numbers 模块中）、流（在 io 模块中）的内置 ABC ] 模块），导入查找器和加载器（在 importlib.abc 模块中）。 您可以使用 abc 模块创建自己的 ABC。

注解

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

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

见变量注解、函数注解、PEP 484和PEP 526、描述这个功能。

争论

调用函数时传递给 函数 （或 方法 ）的值。 有两种说法：

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

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

• 位置参数：不是关键字参数的参数。 位置参数可以出现在参数列表的开头和/或作为 iterable 前面有 * 的元素传递。 例如，3 和 5 都是以下调用中的位置参数：

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

参数被分配给函数体中的命名局部变量。 有关管理此分配的规则，请参阅 Calls 部分。 从语法上讲，任何表达式都可以用来表示一个参数； 评估值分配给局部变量。

另请参阅 参数 词汇表条目、关于 参数和参数之间的区别 和 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__ 必须返回一个 awaitable 对象。 async for 解析异步迭代器的 __anext__() 方法返回的等待对象，直到它引发 StopAsyncIteration 异常。 由 PEP 492 引入。

属性

与使用虚线表达式按名称引用的对象关联的值。 例如，如果对象 o 具有属性 a，它将被引用为 oa。

等待的

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

BDFL

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

二进制文件

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

另请参阅 文本文件 以获取能够读取和写入 str 对象的文件对象。

类字节对象

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

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

字节码

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

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

打回来

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

班级

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

类变量

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

强迫

在涉及相同类型的两个参数的操作期间将一种类型的实例隐式转换为另一种类型。 例如，int(3.15) 将浮点数转换为整数 3，但在 3+4.5 中，每个参数都是不同的类型（一个 int，一个 float），并且两者都是在添加它们之前必须转换为相同的类型，否则会引发 TypeError。 如果没有强制，即使兼容类型的所有参数都必须由程序员规范化为相同的值，例如，float(3)+4.5 而不仅仅是 3+4.5。

复数

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

上下文管理器

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

上下文变量

根据上下文可以具有不同值的变量。 这类似于线程本地存储，其中每个执行线程可能具有不同的变量值。 然而，对于上下文变量，一个执行线程中可能有多个上下文，上下文变量的主要用途是跟踪并发异步任务中的变量。 参见 上下文变量 。

连续的

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

协程

协程是一种更通用的子程序形式。 子程序在某一点进入并在另一点退出。 协程可以在许多不同的点进入、退出和恢复。 它们可以用 async def 语句实现。 另见 PEP 492。

协程函数

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

CPython

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

装饰师

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

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

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

@staticmethod
def f(...):
    ...

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

描述符

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

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

字典

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

字典理解

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

字典视图

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

文档字符串

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

鸭子打字

一种不通过查看对象的类型来确定它是否具有正确接口的编程风格； 相反，方法或属性被简单地调用或使用（“如果它看起来像一只鸭子并且叫起来像一只鸭子，它一定是一只鸭子。”）通过强调接口而不是特定类型，精心设计的代码通过允许多态取代。 Duck-typing 避免了使用 type() 或 isinstance() 的测试。 （但是请注意，鸭子类型可以用 抽象基类 来补充。）相反，它通常使用 hasattr() 测试或 EAFP 编程。

EAFP

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

表达

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

扩展模块

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

字符串

以 'f' 或 'F' 为前缀的字符串字面量通常称为“f-strings”，它是 格式的字符串字面量 的缩写。 另见 PEP 498。

文件对象

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

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

类文件对象

文件对象 的同义词。

发现者

试图为正在导入的模块查找 loader 的对象。

从 Python 3.3 开始，有两种类型的查找器：meta path finders 与 sys.meta_path 一起使用，以及 path entry finders 与 sys 一起使用.path_hooks。

有关更多详细信息，请参阅 PEP 302、PEP 420 和 PEP 451。

楼层划分

向下舍入到最接近的整数的数学除法。 楼层划分算子是//。 例如，与 float true 除法返回的 2.75 相比，表达式 11 // 4 的计算结果为 2。 请注意，(-11) // 4 是 -3，因为它是 -2.75 向下舍入 '。 参见 PEP 238。

功能

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

函数注释

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

函数注解通常用于 类型提示：例如，该函数需要两个 int 参数，并且还需要一个 int 返回值：

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

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

请参阅 变量注释 和 PEP 484，它们描述了此功能。

__未来__

future statement, 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() 一次检索一个值功能。

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

生成器迭代器

由 generator 函数创建的对象。

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

生成器表达式

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

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

通用函数

由多个函数组成的函数，对不同类型实现相同的操作。 调用期间应该使用哪种实现由调度算法决定。

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

泛型

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

有关更多详细信息，请参阅 通用别名类型 、PEP 483、PEP 484、 ]PEP 585 和 typing 模块。

吉尔吉斯斯坦

参见 全局解释器锁 。

全局解释器锁

CPython 解释器使用的机制来确保一次只有一个线程执行 Python bytecode。 这通过使对象模型（包括关键的内置类型，如 dict）隐式地防止并发访问来简化 CPython 实现。 锁定整个解释器使解释器更容易成为多线程，但代价是多处理器机器提供的大部分并行性。

但是，一些扩展模块，无论是标准的还是第三方的，都被设计为在执行压缩或散列等计算密集型任务时释放 GIL。 此外，在执行 I/O 时始终会释放 GIL。

过去创建“自由线程”解释器（以更精细的粒度锁定共享数据的解释器）的努力并未成功，因为在常见的单处理器情况下性能会受到影响。 相信克服这个性能问题会使实现更加复杂，因此维护成本更高。

基于哈希的pyc

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

可散列的

一个对象是 hashable，如果它的哈希值在其生命周期内永远不会改变（它需要一个 __hash__() 方法），并且可以与其他对象进行比较（它需要一个 [ X179X] 方法）。 比较相等的可散列对象必须具有相同的散列值。

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

大多数 Python 的不可变内置对象都是可散列的； 可变容器（例如列表或字典）不是； 不可变容器（例如元组和frozensets）只有在它们的元素是可散列的情况下才是可散列的。 默认情况下，作为用户定义类实例的对象是可散列的。 它们都比较不相等（除了它们自己），它们的哈希值来自它们的 id()。

空闲

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

不可变的

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

导入路径

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

输入

一个模块中的 Python 代码可用于另一个模块中的 Python 代码的过程。

进口商

一个既可以查找又可以加载模块的对象； finder 和 loader 对象。

交互的

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

解释的

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

解释器关闭

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

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

可迭代的

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

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

迭代器

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

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

按键功能

键函数或排序函数是可调用的，它返回用于排序或排序的值。 例如， 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()、itemgetter() 和 methodcaller()。 有关如何创建和使用关键函数的示例，请参阅 Sorting HOW TO。

关键字参数

请参阅 参数 。

拉姆达

由单个 表达式 组成的匿名内联函数，该函数在调用函数时进行计算。 创建 lambda 函数的语法是 lambda [parameters]: expression

LBYL

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

在多线程环境中，LBYL 方法可能会在“寻找”和“跳跃”之间引入竞争条件。 例如，如果另一个线程在测试之后但在查找之前从 mapping 中删除 key，则代码 if key in mapping: return 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() 的方法。 加载程序通常由 finder 返回。 有关详细信息，请参阅 PEP 302，有关 抽象基类 ，请参阅 importlib.abc.Loader。

魔法方法

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

映射

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

元路径查找器

通过搜索 sys.meta_path 返回的 finder。 元路径查找器与 路径条目查找器 相关但又不同。

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

元类

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

更多信息可以在 元类 中找到。

方法

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

方法解析顺序

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

模块

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

另见 包 。

模块规格

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

维修保养办公室

参见方法解析顺序。

可变的

可变对象可以改变它们的值，但保持它们的 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 并定义命名字段的常规类定义创建命名元组。 这样的类可以手工编写，也可以使用工厂函数 collections.namedtuple() 创建。 后一种技术还添加了一些在手写或内置命名元组中可能找不到的额外方法。

命名空间

存储变量的地方。 命名空间被实现为字典。 在对象中（在方法中）有本地、全局和内置命名空间以及嵌套命名空间。 命名空间通过防止命名冲突来支持模块化。 例如，函数 builtins.open 和 os.open() 通过它们的命名空间来区分。 命名空间还通过明确哪个模块实现功能来提高可读性和可维护性。 例如，写 random.seed() 或 itertools.islice() 清楚地表明这些函数是由 random 和 itertools[ X168X] 模块。

命名空间包

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

另见 模块 。

嵌套作用域

在封闭定义中引用变量的能力。 例如，定义在另一个函数内部的函数可以引用外部函数中的变量。 请注意，默认情况下嵌套范围仅用于参考而不用于分配。 局部变量在最里面的作用域中读取和写入。 同样，全局变量读写全局命名空间。 nonlocal 允许写入外部作用域。

新式班

现在用于所有类对象的类风格的旧名称。 在早期的 Python 版本中，只有新样式的类才能使用 Python 更新的、通用的特性，如 __slots__、描述符、属性、__getattribute__()、类方法和静态方法。

目的

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

包裹

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

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

范围

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

• positional-or-keyword：指定可以通过 positionally 或作为 keyword 参数 传递的参数。 这是默认的参数类型，例如下面的 foo 和 bar：

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

• positional-only：指定只能由位置提供的参数。 可以通过在函数定义的参数列表中包含一个 / 字符来定义仅位置参数，例如下面的 posonly1 和 posonly2：

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

• keyword-only：指定只能由关键字提供的参数。 可以通过在它们之前的函数定义的参数列表中包含单个 var-positional 参数或裸 * 来定义仅关键字参数，例如 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。

路径入口

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

路径入口查找器

finder 由 sys.path_hooks 上的可调用对象返回（即 一个 路径条目钩子 )，它知道如何定位给定 路径条目 的模块。

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

路径入口钩子

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

基于路径的查找器

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

类路径对象

表示文件系统路径的对象。 类路径对象是表示路径的 str 或 bytes 对象，或者是实现 os.PathLike 协议的对象。 支持 os.PathLike 协议的对象可以通过调用 os.fspath()[ 转换为 str 或 bytes 文件系统路径X158X]功能； os.fsdecode() 和 os.fsencode() 可用于分别保证 str 或 bytes 结果。 由 PEP 519 引入。

政治公众人物

Python 增强建议。 PEP 是为 Python 社区提供信息或描述 Python 或其进程或环境的新功能的设计文档。 PEP 应提供简明的技术规范和建议功能的基本原理。

PEP 旨在成为提出主要新功能、收集社区对某个问题的意见以及记录已进入 Python 的设计决策的主要机制。 PEP 作者负责在社区内建立共识并记录不同意见。

参见 PEP 1。

部分

如 PEP 420 中定义的，单个目录中的一组文件（可能存储在一个 zip 文件中），这些文件有助于命名空间包。

位置论证

请参阅 参数 。

临时API

临时 API 是故意从标准库的向后兼容性保证中排除的 API。 虽然预计不会对此类接口进行重大更改，但只要将它们标记为临时，如果核心开发人员认为有必要，则可能会发生向后不兼容的更改（直至并包括删除接口）。 此类更改不会无缘无故进行 - 只有在发现 API 包含之前遗漏的严重基本缺陷时才会发生。

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

这个过程允许标准库随着时间的推移不断发展，而不会长时间锁定有问题的设计错误。 有关更多详细信息，请参阅 PEP 411。

临时配套

请参阅 临时 API 。

蟒蛇 3000

Python 3.x 发布系列的昵称（很久以前创造的，当时版本 3 的发布是在遥远的未来。）这也缩写为“Py3k”。

蟒蛇式

紧跟 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 文件的目录。

另见 命名空间包 。

__插槽__

类内部的声明，通过预先声明实例属性的空间和消除实例字典来节省内存。 虽然很流行，但该技术很难正确使用，最好保留用于内存关键应用程序中存在大量实例的极少数情况。

顺序

一个 iterable 支持通过 __getitem__() 特殊方法使用整数索引进行有效元素访问，并定义了一个返回序列长度的 __len__() 方法。 一些内置序列类型是 list、str、tuple 和 bytes。 请注意，dict 也支持 [X38X] 和 __len__()，但被视为映射而不是序列，因为查找使用任意 immutable 键而不是整数.

collections.abc.Sequence 抽象基类定义了一个更丰富的接口，它超越了 __getitem__() 和 __len__()，添加了 count()、[ X159X]、__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。

文本编码

将 Unicode 字符串编码为字节的编解码器。

文本文件

文件对象 能够读写 str 对象。 通常，文本文件实际上访问面向字节的数据流并自动处理 文本编码 。 文本文件的示例是以文本模式打开的文件（'r' 或 'w'）、sys.stdin、sys.stdout 和 [ X137X]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 约定 [ X211X]。 请参阅 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”来找到该列表。