术语表

>>>

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

...

可以指

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

  • 内置常量 Ellipsis。

抽象基类

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

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

另请参见形参术语表条目，关于参数和形参之间的差异的 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 引入。

属性

与对象关联的值，通常使用点表达式通过名称引用。例如，如果对象 *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__() 方法的类的实例也是可调用对象。

回调

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

类

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

类变量

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

闭包变量

一个自由变量，它被嵌套作用域引用，并且该变量是在外部作用域中定义的，而不是在运行时从全局或内置命名空间解析的。可以使用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 语句调用的 __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 上分发的版本。“CPython”一词在必要时用于将此实现与其他实现（如 Jython 或 IronPython）区分开来。

当前上下文

当前被 ContextVar 对象用来访问（获取或设置）上下文变量 的值的上下文（contextvars.Context 对象）。每个线程都有自己的当前上下文。用于执行异步任务的框架（请参阅 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)。请参阅 字典视图对象。

文档字符串 (docstring)

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

鸭子类型 (duck-typing)

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

EAFP

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

表达式 (expression)

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

扩展模块 (extension module)

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

f-字符串 (f-string)

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

文件对象 (file object)

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

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

类文件对象 (file-like object)

文件对象的同义词。

文件系统编码和错误处理程序 (filesystem encoding and error handler)

Python 用于解码来自操作系统的字节并将 Unicode 编码到操作系统的编码和错误处理程序。

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

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

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

另请参阅区域设置编码。

查找器 (finder)

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

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

有关更多详细信息，请参阅 查找器和加载器 和 importlib。

向下取整除法 (floor division)

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

自由线程 (free threading)

一种线程模型，其中多个线程可以在同一解释器内同时运行 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 语句）。当生成器迭代器恢复时，它会从中断的地方继续（与每次调用都重新开始的函数相反）。

生成器表达式

返回迭代器的表达式。它看起来像一个普通表达式，后跟一个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。

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

基于哈希的 pyc

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

可哈希

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

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

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

IDLE

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

不朽

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

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

不可变的

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

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() 是三个键函数构造函数。有关如何创建和使用键函数的示例，请参阅排序 HOW TO。

keyword argument

请参阅参数。

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() 的方法。加载器通常由 查找器 返回。另请参阅

区域设置编码

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

另请参见 命名空间包。

REPL

“读取-求值-打印循环”的缩写，是 交互式 解释器 shell 的另一个名称。

__slots__

类内部的一个声明，它通过预先声明实例属性的空间并消除实例字典来节省内存。尽管很流行，但这项技术有点棘手，最好保留在内存关键型应用程序中存在大量实例的极少数情况下使用。

序列

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

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 对象。

软弃用

软弃用的 API 不应在新代码中使用，但现有代码可以安全地使用它。该 API 仍然有文档记录和测试，但不会进一步增强。

与正常弃用不同，软弃用不计划删除 API，也不会发出警告。

请参见 PEP 387：软弃用。

特殊方法

一种由 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”找到该列表。