Skip to main content

词汇表

>>>

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

...

在输入缩进代码块或一对匹配的左右分隔符（括号，方括号或花括号）代码时，交互式shell的默认Python提示。

2to3

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

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

抽象基类

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

论据

调用函数时传递给 function （或 method）的值。有两种参数：

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

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

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

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

参数被分配给函数体中指定的局部变量。有关此任务的规则，请参阅 呼叫 部分。在语法上，任何表达式都可以用来表示参数；将评估值分配给局部变量。

另见 parameter 术语表条目，参数和参数之间的差异 的常见问题和 PEP 362。

异步上下文管理器

通过定义 __aenter__() 和 __aexit__() 方法来控制在 async with 语句中看到的环境的对象。由 PEP 492 介绍。

异步发电机

返回 asynchronous generator iterator 的函数。它看起来像用 async def 定义的协程函数，除了它包含用于产生在 async for 循环中可用的一系列值的 yield 表达式。

通常指异步生成器函数，但在一些上下文中可以指代 异步生成器迭代器。在预期意义不清楚的情况下，使用完整术语避免歧义。

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

异步生成器迭代器

由 asynchronous generator 函数创建的对象。

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

每个 yield 临时挂起处理，记住位置执行状态（包括局部变量和待处理的try语句）。当 异步生成器迭代器 有效地恢复与 __anext__() 返回的另一个等待时，它拾取在它离开的地方。参见 PEP 492 和 PEP 525。

异步迭代

一个对象，可以在 async for 语句中使用。必须从其 __aiter__() 方法返回 asynchronous iterator。由 PEP 492 介绍。

异步迭代器

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

属性

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

等待

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

BDFL

善良的Dictator For Life，a.k.a. Guido van Rossum，Python的创作者。

二进制文件

file object 能够读写 字节状对象。

参见

text file 读取和写入 str 对象。

字节状对象

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

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

字节码

Python源代码被编译成字节码，在CPython解释器中的Python程序的内部表示。字节码也缓存在 .pyc 和 .pyo 文件中，以便第二次执行相同的文件更快（可以避免从源码到字节码的重新编译）。这种“中间语言”被称为运行在执行对应于每个字节码的机器码的 virtual machine 上。请注意，字节码不能在不同的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连续，则它被认为是连续的。零维缓冲区是C和Fortran连续的。在一维数组中，项必须按照从零开始增加的索引的顺序布置在彼此相邻的存储器中。在多维C连续数组中，当按照存储器地址的顺序访问项目时，最后的索引以最快的速度变化。然而，在Fortran连续数组中，第一个索引变化最快。

协同

协程是子程序的更一般化形式。子程序在一个点输入，在另一个点退出。协程可以在许多不同的点进入，退出和恢复。它们可以用 async def 语句实现。参见 PEP 492。

协同功能

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

CPython

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

装饰

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

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

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

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

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

描述符

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

有关描述符方法的更多信息，请参阅 实现描述符。

字典

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

字典视图

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

docstring

一个字符串文字，在类，函数或模块中作为第一个表达式出现。当套件被执行时被忽略，它被编译器识别并放入封闭类，函数或模块的 __doc__ 属性。因为它是通过内省可用的，它是对象的文档的规范的地方。

鸭式

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

EAFP

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

表达

一段语法，可以评估一些值。换句话说，表达式是诸如文字，名称，属性访问，操作符或函数调用等表达式元素的累加，所有这些都返回一个值。与许多其他语言相反，并非所有的语言结构都是表达式。还有一些不能用作表达式的 statement，例如 if。赋值也是语句，而不是表达式。

扩展模块

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

文件对象

将面向文件的API（使用 read() 或 write() 等方法）暴露给底层资源的对象。根据其被创建的方式，文件对象可以调解对真实磁盘文件或另一类型的存储或通信设备（例如标准输入/输出，内存缓冲器，插座，管道等）的访问， 。文件对象也称为 file-like objects 或 streams。

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

文件状对象

file object 的同义词。

发现者

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

从Python 3.3开始，有两种类型的finder：元路径查找器 用于 sys.meta_path，路径条目查找器 用于 sys.path_hooks。

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

地板划分

向下舍入到最接近的整数的数学除法。分区操作员是 //。例如，与由float true除法返回的 2.75 相比，表达式 11 // 4 评估为 2。注意，(-11) // 4 是 -3，因为它是 -2.75 圆形 downward。见 PEP 238。

功能

一系列对调用者返回一些值的语句。它也可以传递零个或多个 参数，可以在主体的执行中使用。参见 parameter，method 和 函数定义 部分。

函数注释

与函数参数或返回值相关联的任意元数据值。其语法在 函数定义 一节中解释。注释可以通过函数对象的 __annotations__ 特殊属性来访问。

Python本身不会为函数注释指定任何特定的含义。它们旨在由第三方库或工具解释。见 PEP 3107，它描述了它们的一些潜在用途。

__未来__

一个伪模块，程序员可以使用它来启用与当前解释器不兼容的新语言特性。

通过导入 __future__ 模块并评估其变量，您可以看到新功能首次添加到语言的时间以及何时成为默认值:

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

当不再使用时释放内存的过程。 Python通过引用计数和能够检测和中断参考周期的循环垃圾收集器执行垃圾收集。

发电机

返回 generator iterator 的函数。它看起来像一个普通函数，除了它包含 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。

GIL

见 global interpreter lock。

全局解释器锁

CPython 解释器使用的机制，以确保一次只有一个线程执行Python bytecode。这通过使对象模型（包括诸如 dict 的关键内置类型）对并发访问隐式安全来简化CPython实现。锁定整个解释器使得解释器更易于多线程化，同时牺牲多处理器机器提供的许多并行性。

然而，一些扩展模块，无论是标准还是第三方，被设计为在进行计算密集型任务（例如压缩或散列）时释放GIL。此外，当执行I/O时，GIL总是释放。

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

哈希

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

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

所有Python的不变的内置对象都是hashable的，而没有可变容器（如列表或字典）。默认情况下，作为用户定义类的实例的对象是哈希的；它们都比较不相等（除了自己），并且它们的哈希值从它们的 id() 导出。

闲

Python的集成开发环境。 IDLE是一个基本的编辑器和解释器环境，附带Python的标准分发。

不可变

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

导入路径

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

输入

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

进口商

既找到又加载模块的对象； finder 和 loader 对象。

互动

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

解释

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

解释器关闭

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

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

可迭代

能够一次返回其成员一个对象。迭代的示例包括所有序列类型（例如 list，str 和 tuple）和一些非序列类型（如 dict，文件对象）以及您使用 __iter__() 或 __getitem__() 方法定义的任何类的对象。 Iterables可以在 for 循环中使用，在许多其他需要序列的地方（zip()，map()，...）。当可迭代对象作为参数传递给内置函数 iter() 时，它会返回对象的迭代器。这个迭代器对于一组值的一次传递是有益的。当使用iterables时，通常不需要调用 iter() 或自己处理iterator对象。 for 语句会自动为您创建一个临时未命名变量，以便在循环期间保存迭代器。参见 iterator，sequence 和 generator。

迭代器

表示数据流的对象。重复调用迭代器的 __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 r: (r[0], r[2]) 的 lambda 表达式构建关键函数。此外，operator 模块提供三个关键功能构造函数：attrgetter()，itemgetter() 和 methodcaller()。有关如何创建和使用键功能的示例，请参阅 排序如何。

关键字参数

见 argument。

lambda

一个由单个 expression 组成的匿名内联函数，在调用函数时进行评估。创建lambda函数的语法是 lambda [arguments]: expression

LBYL

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

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

列表

内置的Python sequence。尽管它的名称，它更像是一个数组在其他语言，而不是一个链表，因为访问元素是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；有关 abstract base class，请参阅 importlib.abc.Loader。

映射

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

元路径查找器

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

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

元类

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

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

方法

一个在类体内定义的函数。如果调用作为该类的实例的属性，该方法将获得实例对象作为其第一个 argument （通常称为 self）。参见 function 和 nested scope。

方法解析顺序

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

模块

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

参见 package。

模块规格

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

MRO

见 method resolution order。

可变

可变对象可以改变其值，但保留其 id()。参见 immutable。

命名元组

任何类似元组的类，其可索引元素也可以使用命名属性访问（例如，time.localtime() 返回一个类似于tuple的对象，其中 year 可以通过索引例如 t[0] 或像 t.tm_year 一样的命名属性来访问）。

命名的元组可以是内置类型，例如 time.struct_time，或者可以使用常规类定义创建。还可以使用工厂函数 collections.namedtuple() 创建功能齐全的命名元组。后一种方法自动提供额外的特征，例如像 Employee(name='jones', title='programmer') 的自记录表示。

命名空间

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

命名空间包

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

参见 module。

嵌套范围

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

新式类

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

目的

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

包

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

参见 regular package 和 namespace package。

参数

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

  • positional-or-keyword：指定可以通过 位置 或 关键字参数 传递的参数。这是默认的参数类型，例如下面的 foo 和 bar:

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

  • positional-only：指定只能通过位置提供的参数。 Python没有用于定义纯位置参数的语法。然而，一些内置函数具有仅位置参数（例如 abs()）。

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

路径条目

import path 上的单个位置，path based finder 咨询以找到要导入的模块。

路径入口查找器

由 sys.path_hooks 上的可呼叫者（即 path entry hook）返回的 finder，其知道如何定位给定 path entry 的模块。

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

路径入口钩子

sys.path_hook 列表上的可调用项，如果它知道如何在特定 path entry 上查找模块，则返回 path entry finder。

基于路径的finder

其中一个默认的 元路径查找器 搜索 import path 模块。

路径样对象

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

一部分

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

位置参数

见 argument。

临时API

临时API是从标准库的向后兼容性保证中故意排除的API。虽然不期望对这样的接口的主要改变，只要它们被标记为临时的，但是如果核心开发者认为必要的话，可能发生向后不兼容的改变（直到并包括接口的移除）。此类更改不会是无意的 - 只有在包含API之前漏掉了严重的基本缺陷，才会发生这种变化。

即使对于临时API，向后不兼容的更改被视为“最后解决方案” - 仍将尝试为任何已识别的问题找到向后兼容的解决方案。

该过程允许标准库随着时间的推移继续演进，而不会在长时间内锁定有问题的设计错误。有关详细信息，请参阅 PEP 411。

临时包

见 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)
合格名称

虚线名称显示从模块的全局范围到该模块中定义的类，函数或方法的“路径”，如 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() 函数，程序员可以调用它来返回特定对象的引用计数。

定期包装

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

参见 namespace package。

__slots__

一个类中的声明，通过预声明实例属性的空间并消除实例字典来节省内存。虽然很受欢迎，但是这种技术有点棘手，最好保留用于在内存关键型应用程序中有大量实例的罕见情况。

序列

iterable，其通过 __getitem__() 特殊方法支持使用整数索引的有效元素访问，并定义返回序列长度的 __len__() 方法。一些内置的序列类型是 list，str，tuple 和 bytes。注意，dict 还支持 __getitem__() 和 __len__()，但被认为是映射而不是序列，因为查找使用任意的 immutable 密钥而不是整数。

collections.abc.Sequence 抽象基类定义了一个更丰富的接口，它超越了 __getitem__() 和 __len__()，添加了 count()，index()，__contains__() 和 __reversed__()。实现此扩展接口的类型可以使用 register() 显式注册。

单调度

generic function 分派的形式，其中基于单个参数的类型选择实现。

片

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

特殊方法

由Python隐式调用以对类型执行特定操作（如加法）的方法。这样的方法具有以双下划线开始和结束的名称。在 特殊方法名称 中记录了特殊方法。

声明

语句是套件的一部分（代码的“块”）。语句是 expression 或具有关键字的若干构造中的一个，例如 if，while 或 for。

结构序列

具有命名元素的元组。 Struct序列暴露了一个类似于 named tuple 的接口，因为元素可以通过索引或作为属性来访问。然而，他们没有任何命名的元组方法，如 _make() 或 _asdict()。结构序列的示例包括 sys.float_info 和 os.stat() 的返回值。

文本编码

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

文本文件

file object 能够读取和写入 str 对象。通常，文本文件实际访问面向字节的数据流并自动处理 text encoding。

参见

binary file 读取和写入 bytes 对象。

三引号字符串

一个字符串，由一个引号（“）或一个撇号（’）的三个实例绑定，虽然它们不提供单引号字符串不能提供的任何功能，但它们有很多原因，您可以在字符串中包括未转义的单引号和双引号，并且它们可以跨越多行而不使用连续字符，这使得在编写docstrings时非常有用。

类型

Python对象的类型决定了它是什么样的对象；每个对象都有一个类型。对象的类型可以作为其 __class__ 属性来访问，或者可以使用 type(obj) 来检索。

通用换行

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

变量注释

与模块全局变量或类属性相关联的类型元数据值。其语法在 带注释的赋值语句 一节中解释。注释存储在类或模块对象的 __annotations__ 特殊属性中，可以使用 typing.get_type_hints() 访问。

Python本身不会为变量注释指定任何特定的含义。它们旨在由第三方库或类型检查工具解释。参见 PEP 526，PEP 484，它们描述了它们的一些潜在用途。

虚拟环境

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

参见 venv。

虚拟机

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

Python的禅

列出有助于理解和使用语言的Python设计原则和哲学。可以通过在交互式提示符处键入“ import this ”找到列表。