术语表

>>>

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

...

可以指

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

• Ellipsis 对象的三点形式。

抽象基类

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

注解函数

一个可以被调用以检索对象注解的函数。此函数可以通过函数、类和模块的__annotate__属性访问。注解函数是求值函数的一个子集。

注解

与变量、类属性或函数参数或返回值相关联的标签，根据约定用作类型提示。

局部变量的注解在运行时无法访问，但全局变量、类属性和函数的注解可以通过分别在模块、类和函数上调用annotationlib.get_annotations()来检索。

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

实参

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

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

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

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

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

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

另请参阅形参词汇表条目、FAQ 中关于实参和形参之间区别的问题，以及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引入。

附加线程状态

当前操作系统线程活动的线程状态。

当一个线程状态被附加时，操作系统线程可以访问完整的 Python C API 并可以安全地调用字节码解释器。

除非函数明确注明，否则在没有附加线程状态的情况下尝试调用 C API 将导致致命错误或未定义行为。线程状态可以通过 C API 由用户显式附加和分离，或由运行时隐式附加，包括在阻塞 C 调用期间和字节码解释器在调用之间。

在大多数 Python 构建中，拥有附加线程状态意味着调用者持有当前解释器的 GIL，因此在给定时刻只有一个操作系统线程可以拥有附加线程状态。在 自由线程 Python 构建中，线程可以并发持有附加线程状态，从而实现字节码解释器的真正并行化。

属性

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

如果对象允许，可以使用setattr()等方法给对象一个名称不是名称（标识符和关键字）定义的标识符的属性。这样的属性不能通过点表达式访问，而需要使用getattr()来检索。

可等待对象

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

BDFL

终身仁慈独裁者（Benevolent Dictator For Life），即 Python 的创建者Guido van Rossum。

二进制文件

能够读写字节类对象的文件对象。二进制文件的示例包括以二进制模式（'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和bytearray的memoryview。其他操作要求二进制数据存储在不可变对象中（“只读字节类对象”）；这些示例包括bytes和bytes对象的memoryview。

字节码

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

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

可调用对象

一个可以被调用的对象，可能带有一组实参（参见实参），其语法如下：

callable(argument1, argument2, argumentN)

函数，以及方法，是可调用对象。实现了__call__()方法的类的实例也是可调用对象。

回调函数

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

类

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

类变量

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

闭包变量

从嵌套作用域引用的自由变量，它定义在外部作用域中，而不是在运行时从全局或内置命名空间解析。可以使用nonlocal关键字显式定义以允许写入访问，或者如果变量仅被读取则隐式定义。

例如，在以下代码中的inner函数中，x和print都是自由变量，但只有x是_闭包变量_

def outer():
    x = 0
    def inner():
        nonlocal x
        x += 1
        print(x)
    return inner

由于codeobject.co_freevars属性（尽管其名称，它只包含闭包变量的名称，而不是列出所有引用的自由变量），更通用的自由变量术语有时也被使用，即使其预期含义是特指闭包变量。

复数

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

上下文

这个术语根据其使用地点和方式有不同的含义。一些常见含义：

• 通过上下文管理器通过with语句建立的临时状态或环境。

• 与特定contextvars.Context对象关联并通过ContextVar对象访问的键值绑定集合。另请参见上下文变量。

• 一个contextvars.Context对象。另请参见当前上下文。

上下文管理协议

由with语句调用的__enter__()和__exit__()方法。参见PEP 343。

上下文管理器

一个实现上下文管理协议并控制with语句中环境的对象。参见PEP 343。

上下文变量

其值取决于哪个上下文是当前上下文的变量。值通过contextvars.ContextVar对象访问。上下文变量主要用于隔离并发异步任务之间的状态。

连续

如果缓冲区是_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”。

当前上下文

上下文（contextvars.Context对象），当前被ContextVar对象用于访问（获取或设置）上下文变量的值。每个线程都有自己的当前上下文。用于执行异步任务的框架（参见asyncio）将每个任务与一个上下文关联起来，当任务开始或恢复执行时，该上下文就成为当前上下文。

循环隔离

一个或多个对象的子组，它们之间相互引用形成引用循环，但不受组外对象的引用。循环垃圾收集器的目标是识别这些组并打破引用循环，以便回收内存。

装饰器

一个返回另一个函数的函数，通常使用@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编程。

双下划线

“double underscore”的非正式简称，用于谈论特殊方法时。例如，__init__通常读作“dunder init”。

EAFP

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

求值函数

可以调用以评估对象惰性求值属性的函数，例如使用type语句创建的类型别名的值。

表达式

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

扩展模块

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

f-字符串

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。

自由线程

一种线程模型，允许多个线程在同一个解释器内同时运行 Python 字节码。这与全局解释器锁形成对比，全局解释器锁只允许一个线程一次执行 Python 字节码。参见PEP 703。

自由变量

正式地，正如语言执行模型中所定义，自由变量是命名空间中未作为局部变量使用的任何变量。有关示例，请参阅闭包变量。实际上，由于codeobject.co_freevars属性的名称，该术语有时也用作闭包变量的同义词。

函数

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

函数注解

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

函数注解通常用于类型提示：例如，这个函数预计接受两个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语句）。当_生成器迭代器_恢复时，它会从上次中断的地方继续（与每次调用都重新开始的函数不同）。

生成器表达式

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

>>> 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 总是会被释放。

自 Python 3.13 起，可以使用--disable-gil构建配置禁用 GIL。使用此选项构建 Python 后，必须使用-X gil=0或在设置PYTHON_GIL=0环境变量后运行代码。此功能可提高多线程应用程序的性能，并更容易高效地使用多核 CPU。有关更多详细信息，请参阅PEP 703。

在 Python C API 的早期版本中，函数可能会声明它需要持有 GIL 才能使用它。这指的是具有附加线程状态。

基于哈希的 pyc

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

可哈希 (hashable)

如果一个对象在其生命周期内哈希值永不改变（它需要一个 __hash__() 方法），并且可以与其他对象进行比较（它需要一个 __eq__() 方法），则称其为 可哈希的。比较结果相等的哈希对象必须具有相同的哈希值。

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

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

IDLE

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

不朽的 (immortal)

不朽对象 是 PEP 683 中引入的 CPython 实现细节。

如果一个对象是不朽的，它的 引用计数 永远不会被修改，因此在解释器运行期间它永远不会被释放。例如，True 和 None 在 CPython 中是不朽的。

不朽对象可以通过 sys._is_immortal() 或 C API 中的 PyUnstable_IsImmortal() 来识别。

不可变 (immutable)

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

导入路径 (import path)

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

导入 (importing)

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

导入器 (importer)

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

交互式 (interactive)

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

解释型 (interpreted)

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

解释器关闭 (interpreter shutdown)

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

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

可迭代的 (iterable)

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

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

迭代器 (iterator)

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

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

CPython 实现细节： CPython 不会始终如一地应用迭代器必须定义 __iter__() 的要求。另请注意，自由线程 CPython 不保证迭代器操作的线程安全。

键函数 (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)

请参阅 参数。

lambda

一个匿名的内联函数，由一个在函数调用时求值的单个 表达式 组成。创建 lambda 函数的语法是 lambda [参数]: 表达式

LBYL

先看后跳 (Look Before You Leap)。这种编码风格在进行调用或查找之前显式测试前置条件。这种风格与 EAFP 方法形成对比，其特点是存在许多 if 语句。

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

词法分析器 (lexical analyzer)

tokenizer 的正式名称；参见 令牌。

列表 (list)

一个内置的 Python 序列。尽管其名称如此，但它更像其他语言中的数组，而不是链表，因为对元素的访问是 O(1)。

列表推导式 (list comprehension)

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

加载器 (loader)

加载模块的对象。它必须定义 exec_module() 和 create_module() 方法以实现 Loader 接口。加载器通常由 查找器 返回。另请参阅

• 查找器和加载器

• importlib.abc.Loader

• PEP 302

区域编码 (locale encoding)

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

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

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

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

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

魔法方法 (magic method)

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

映射 (mapping)

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

元路径查找器 (meta path finder)

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

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

元类 (metaclass)

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

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

方法 (method)

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

方法解析顺序 (method resolution order)

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

模块 (module)

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

另请参阅 包。

模块规范 (module spec)

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

另请参阅 模块规范。

MRO

请参阅 方法解析顺序。

可变 (mutable)

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

命名元组 (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)

一个仅用作子包容器的 包。命名空间包可能没有物理表示，并且特别与 常规包 不同，因为它们没有 __init__.py 文件。

命名空间包允许多个独立安装的包拥有一个共同的父包。否则，建议使用 常规包。

欲了解更多信息，请参阅 PEP 420 和 命名空间包。

另请参阅 模块。

嵌套作用域 (nested scope)

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

新式类 (new-style class)

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

对象 (object)

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

优化作用域 (optimized scope)

当代码编译时，目标局部变量名可靠地为编译器所知的范围，从而允许优化对这些名称的读写访问。函数、生成器、协程、推导式和生成器表达式的局部命名空间都以这种方式进行优化。注意：大多数解释器优化都应用于所有范围，只有那些依赖于已知局部和非局部变量名集的优化才限于优化范围。

包 (package)

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

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

参数 (parameter)

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

• 位置或关键字：指定可以按位置或作为关键字参数传递的参数。这是默认的参数类型，例如以下代码中的 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。

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

另请参阅 argument 术语表条目，关于 参数与形参的区别 的常见问题，inspect.Parameter 类，函数定义 部分，以及 PEP 362。

路径条目 (path entry)

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

路径条目查找器 (path entry finder)

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

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

路径条目钩子 (path entry hook)

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

基于路径的查找器 (path based finder)

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

类路径对象 (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)

请参阅 参数。

临时 API (provisional API)

临时 API 是指已被特意排除在标准库向后兼容性保证之外的 API。虽然预计此类接口不会发生重大更改，但只要它们被标记为临时，如果核心开发人员认为有必要，可能会发生向后不兼容的更改（包括但不限于删除接口）。此类更改不会无故进行——只有在发现 API 包含之前遗漏的严重根本缺陷时才会发生。

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

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

临时包 (provisional package)

请参阅 临时 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)

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

在 CPython 中，引用计数不被认为是稳定或明确的值；一个对象的引用数量以及该数量如何受 Python 代码影响，在不同版本之间可能会有所不同。

常规包 (regular package)

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

另请参阅 命名空间包。

REPL

“read–eval–print loop”的首字母缩写，是 交互式 解释器 shell 的另一个名称。

__slots__

类内部的声明，通过预先声明实例属性的空间并消除实例字典来节省内存。尽管很流行，但这种技术有点难以正确使用，最好保留在内存关键型应用程序中存在大量实例的罕见情况下。

序列 (sequence)

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

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)

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

切片 (slice)

一个通常包含 序列 一部分的 对象。切片使用下标表示法 [] 创建，当给出多个数字时，它们之间用冒号分隔，例如 variable_name[1:3:5]。方括号（下标）表示法在内部使用 slice 对象。

软废弃 (soft deprecated)

软废弃的 API 不应在新代码中使用，但对于现有代码使用它是安全的。该 API 仍然有文档和测试，但不会进一步增强。

软废弃与普通废弃不同，不计划移除 API，也不会发出警告。

请参阅 PEP 387: Soft Deprecation。

特殊方法 (special method)

由 Python 隐式调用的方法，用于在类型上执行特定操作，例如加法。此类方法的名称以双下划线开头和结尾。特殊方法在 特殊方法名 中有文档说明。

标准库 (standard library)

作为官方 Python 解释器包的一部分分发的 包、模块 和 扩展模块 的集合。该集合的确切成员可能因平台、可用系统库或其他标准而异。文档可在 Python 标准库 中找到。

另请参阅 sys.stdlib_module_names 以获取所有可能的标准库模块名称列表。

语句 (statement)

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

静态类型检查器 (static type checker)

一个外部工具，用于读取 Python 代码并对其进行分析，寻找不正确的类型等问题。另请参阅 类型提示 和 typing 模块。

stdlib

标准库 的缩写。

强引用 (strong reference)

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

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

另请参阅 借用引用。

t-字符串 (t-string)

t-字符串 (t-strings)

以 t 或 T 为前缀的字符串字面量通常被称为“t-字符串”，它是 模板字符串字面量 的缩写。

文本编码 (text encoding)

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

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

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

文本文件 (text file)

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

另请参阅 二进制文件，它是一种能够读写 类字节对象 的文件对象。

线程状态 (thread state)

CPython 运行时用于在操作系统线程中运行的信息。例如，这包括当前的异常（如果有）和字节码解释器的状态。

每个线程状态绑定到单个操作系统线程，但线程可能拥有许多可用的线程状态。最多只有一个可以同时处于 附加状态。

调用大多数 Python C API 需要一个 附加线程状态，除非函数明确另有说明。字节码解释器仅在附加线程状态下运行。

每个线程状态属于一个解释器，但每个解释器可能拥有许多线程状态，包括同一个操作系统线程的多个线程状态。来自多个解释器的线程状态可以绑定到同一个线程，但任何给定时刻只能有一个处于 附加状态。

有关更多信息，请参阅 线程状态和全局解释器锁。

令牌 (token)

由 词法分析器（也称为 分词器）生成的源代码的小单元。名称、数字、字符串、运算符、换行符等都由令牌表示。

tokenize 模块公开了 Python 的词法分析器。token 模块包含有关各种令牌类型的信息。

三引号字符串 (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)

一种 注解，用于指定变量、类属性或函数参数或返回值的预期类型。

类型提示是可选的，不受 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)

变量或类属性的 注解。

当注解变量或类属性时，赋值是可选的

class C:
    field: 'annotation'

变量注解通常用于 类型提示：例如，这个变量期望接收 int 值

count: int = 0

变量注解的语法在 带注解的赋值语句 一节中解释。

请参阅 函数注解、PEP 484 和 PEP 526，它们描述了此功能。另请参阅 注解最佳实践，以获取使用注解的最佳实践。

虚拟环境 (virtual environment)

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

另请参阅 venv。

虚拟机 (virtual machine)

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

海象运算符 (walrus operator)

一种轻松地指代 赋值表达式 运算符 := 的方式，因为它看起来有点像海象，如果你把头侧过来。

Python 之禅 (Zen of Python)

一份有助于理解和使用该语言的 Python 设计原则和理念的清单。通过在交互式提示符下键入“import this”即可找到该清单。