Glossary

• >>>

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

• ...

  • 可以参考：

• Importing 缩进代码块的代码时，在Pair匹配的左右定界符(括号，方括号，花括号或三引号)之内，或在指定修饰符后，交互式 Shell 程序的默认 Python 提示符。

• Ellipsis内置常数。

• 2to3

  • pass处理大多数不兼容问题来try将 Python 2.x 代码转换为 Python 3.x 代码的工具，这些不兼容问题可以pass分析源代码并遍历解析树来检测。

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

• 抽象 Base Class

  • 抽象 Base Class pass提供一种定义接口的方式来补充duck-typing，而hasattr()之类的其他技术可能笨拙或微妙地错误(例如magic methods)。 ABC 引入了虚拟子类，这些子类不是从类继承而来的，但仍被isinstance()和issubclass()识别；请参阅abc模块文档。 Python 随附了许多内置的 ABC，用于数据结构(在collections.abc模块中)，数字(在numbers模块中)，流(在io模块中)，导入查找器和加载器(在importlib.abc模块中)。您可以使用abc模块创建自己的 ABC。

• annotation

  • 与变量，类属性或函数参数或返回值关联的标签，按惯例用作type hint。

不能在运行时访问局部变量的 Comments，但是全局变量，类属性和函数的 Comments 分别存储在模块，类和函数的__annotations__特殊属性中。

请参阅variable annotation，function annotation， PEP 484和 PEP 526，它们描述了此Function。

• argument

  • 调用函数时传递给function(或method)的值。有两种说法：
• • keyword arguments *：在函数调用中以标识符(例如name=)开头的参数，或以**开头的字典中的值形式传递的参数。例如，在对complex()的以下调用中，3和5都是关键字参数：

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

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

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

将参数分配给函数体内的命名局部变量。有关 Management 此分配的规则，请参见Calls部分。从语法上讲，任何表达式都可以用来表示参数。评估值分配给局部变量。

另请参见parameter词汇表条目，参数和参数之间的区别和 PEP 362的 FAQ 问题。

• 异步上下文 Management 器

  • pass定义aenter()和aexit()方法来控制在async with语句中看到的环境的对象。由 PEP 492引入。

• asynchronous generator

  • 返回异步生成器迭代器的函数。它看起来像用_定义的协程函数，除了它包含yield表达式以产生可在async for循环中使用的一系列值。

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

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

• 异步生成器迭代器
  • 由asynchronous generator函数创建的对象。

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

每个yield都会暂时停止处理，并记住位置执行状态(包括局部变量和挂起的try语句)。当* asynchronous generator iterator *有效地恢复并返回另一个由anext()返回的 awaitable 时，它将在break处 continue 执行。参见 PEP 492和 PEP 525。

• asynchronous iterable

  • 可以在async for语句中使用的对象。必须从其aiter()方法返回asynchronous iterator。由 PEP 492引入。

• asynchronous iterator

  • 实现aiter()和anext()方法的对象。 __anext__必须返回awaitable对象。 async for解析异步迭代器的anext()方法返回的 await 对象，直到它引发StopAsyncIteration异常。由 PEP 492引入。

• attribute

  • 与对象关联的值，该名称使用点分表达式按名称引用。例如，如果对象* o 具有属性 a ，则将其称为 o.a *。

• awaitable

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

• BDFL

  • 善意的生命独裁者，又名吉多·范·罗苏姆(Guido van Rossum)，Python 的创建者。

• binary file

  • file object能够读写bytes-like objects。二进制文件的示例包括以二进制模式('rb'，'wb'或'rb+')，sys.stdin.buffer，sys.stdout.buffer以及io.BytesIO和gzip.GzipFile的实例打开的文件。

另请参见text file以获取能够读取和写入str对象的文件对象。

• bytes-like object
  • 支持Buffer Protocol并可以导出 C- contiguous缓冲区的对象。这包括所有bytes，bytearray和array.array对象，以及许多常见的memoryview对象。类似字节的对象可用于处理二进制数据的各种操作。其中包括压缩，保存到二进制文件以及pass套接字发送。

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

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

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

• callback

  • 子例程函数，将作为参数传递以在将来的某个 Moment 执行。

• class

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

• class variable

  • 在类中定义且仅在类级别(即不在类的实例中)修改的变量。

• coercion

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

• complex number

  • 熟悉的实数系统的扩展，其中所有数字都表示为实部和虚部的总和。虚数是虚数单位的实数倍(-1的平方根)，通常在 math 中写为i或在工程学中写为j。 Python 内置了对复数的支持，后者使用后一种符号编写；虚部写有j后缀，例如3+1j。要访问math模块的复杂等效项，请使用cmath。使用复数是相当高级的 math Function。如果您不了解它们的需求，那么几乎可以肯定，您可以放心地忽略它们。

• context manager

  • pass定义enter()和exit()方法来控制在with语句中看到的环境的对象。参见 PEP 343。

• context variable

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

• contiguous

  • 如果缓冲区是* C-contiguous 或 Fortran contiguous *，则将其视为连续的。零维缓冲区是 C 和 Fortran 连续的。在一维数组中，项必须彼此相邻地布置在内存中，以便从零开始递增索引。在多维 C 连续数组中，按内存地址 Sequences 访问项目时，最后一个索引变化最快。但是，在 Fortran 连续数组中，第一个索引变化最快。

• coroutine

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

• coroutine function

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

• CPython

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

• decorator

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

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

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

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

类存在相同的概念，但在该类中较少使用。有关装饰器的更多信息，请参见function definitions和class definitions的文档。

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

有关 Descriptors 的方法的更多信息，请参见Implementing Descriptors。

• dictionary

  • 关联数组，其中任意键 Map 到值。键可以是具有hash()和eq()方法的任何对象。在 Perl 中称为哈希。

• dictionary view

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

• docstring

  • 字符串 Literals，显示为类，函数或模块中的第一个表达式。当执行套件时会忽略该套件，但编译器会识别该套件，并将其放入封闭类，函数或模块的__doc__属性中。由于可以pass内省使用，因此它是记录对象的规范位置。

• duck-typing

  • 一种编程样式，它不会查看对象的类型来确定它是否具有正确的接口；而是简单地调用或使用方法或属性(“如果它看起来像鸭子，而象鸭子一样，则一定是鸭子.”)pass强调接口而不是特定类型，精心设计的代码pass允许多态替换。鸭式 Importing 避免使用type()或isinstance()进行测试。 (但是请注意，可以使用抽象 Base Class来补充鸭式 Importing。)相反，它通常采用hasattr()测试或EAFP编程。

• EAFP

  • 寻求宽恕比允许容易。这种通用的 Python 编码风格假定有效键或属性的存在，并在假定被证明为 Pseudo 情况下捕获异常。这种干净快捷的样式的特点是存在许多try和except语句。该技术与许多其他语言(如 C)通用的LBYL风格形成对比。

• expression

  • 可以评估为某种值的一种语法。换句话说，表达式是表达式元素(如 Literals，名称，属性访问，运算符或函数调用)的累积，它们都返回一个值。与许多其他语言相反，并非所有语言构造都是表达式。还有statement不能用作表达式，例如while。分配也是语句，而不是表达式。

• extension module

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

• f-string

  • 带有'f'或'F'前缀的字符串 Literals 通常称为“ f-strings”，它是格式化的字符串 Literals的缩写。另请参见 PEP 498。

• file object

  • 向基础资源公开面向文件的 API(使用诸如read()或write()之类的方法)的对象。根据对象的创建方式，文件对象可以介导对实际磁盘文件或其他类型的存储或通信设备(例如标准 Importing/输出，内存缓冲区，套接字，管道等)的访问。 。文件对象也称为类似文件的对象或流。

实际上，文件对象分为三类：原始binary files，缓冲的binary files和text files。它们的接口在io模块中定义。创建文件对象的标准方法是使用open()函数。

• file-like object

  • file object的同义词。

• finder

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

从 Python 3.3 开始，查找器有两种类型：元路径发现者与sys.meta_path一起使用，和路径条目查找器与sys.path_hooks一起使用。

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

• floor division

  • 四舍五入到最接近的整数的 math 除法。楼层划分运算符是//。例如，与 float true 除法返回的2.75相比，表达式11 // 4的求值为2。请注意，(-11) // 4是-3，因为它是-2.75向下舍入的。参见 PEP 238。

• function

  • 一系列向调用者返回一些值的语句。也可以将其传递给零个或多个arguments，以用于执行正文。另请参见parameter，method和Function definitions部分。

• function annotation

  • 函数参数或返回值的annotation。

函数 Comments 通常用于type hints：例如，此函数应带有两个int参数，并且还应具有int返回值：

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

函数 Comments 语法在Function definitions部分中说明。

请参阅variable annotation和 PEP 484，它们描述了此Function。

• future
  • 伪模块，程序员可以使用其来启用与当前解释器不兼容的新语言Function。

pass导入future模块并评估其变量，您可以看到新Function何时首次添加到语言中以及何时成为默认Function：

>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

• garbage collection

  • 当不再使用内存时释放内存的过程。 Python pass引用计数和能够检测和break引用周期的循环垃圾收集器执行垃圾收集。垃圾收集器可以使用gc模块进行控制。

• generator

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

通常引用生成器函数，但在某些情况下可能引用* generator iterator *。在预期含义不明确的情况下，使用完整术语可以避免歧义。

• generator iterator
  • 由generator函数创建的对象。

每个yield都会暂时停止处理，并记住位置执行状态(包括局部变量和挂起的try语句)。当* generator iterator *恢复时，它从break的地方开始(与在每次调用时重新启动的函数相反)。

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

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

• generic function
  • 由多个Function组成的Function，可针对不同类型执行相同的操作。呼叫期间应使用哪种实现方式由调度算法确定。

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

• GIL

  • See 全局解释器锁.

• 全局解释器锁

  • CPython解释程序用来确保一次只有一个线程执行 Python bytecode的机制。pass使对象模型(包括关键的内置类型，如dict)隐式地安全地防止并发访问，从而简化了 CPython 的实现。锁定整个解释器可以使解释器更容易进行多线程处理，但会牺牲 multiprocessing 器机器提供的许多并行性。

但是，某些扩展模块(标准的或第三方的)被设计为在执行诸如压缩或散列之类的计算密集型任务时释放 GIL。另外，在执行 I/O 时，始终释放 GIL。

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

• hash-based pyc

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

• hashable

  • 如果对象的哈希值在其生命周期内始终不变(需要hash()方法)，并且可以与其他对象进行比较(需要eq()方法)，则该对象是可哈希的。比较相等的可哈希对象必须具有相同的哈希值。

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

Python 的大多数不可变内置对象都是可哈希的；可变容器(例如列表或字典)不是；不可变容器(例如 Tuples 和 Frozensets)仅在其元素可哈希化时才可哈希化。默认情况下，作为用户定义类实例的对象是可哈希的。它们都比较不相等(除了它们自己)，并且其哈希值是从id()派生的。

• IDLE

  • Python 的集成开发环境。 IDLE 是 Python 的标准发行版附带的基本编辑器和解释器环境。

• immutable

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

• import path

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

• importing

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

• importer

  • 查找和加载模块的对象； finder和loader对象。

• interactive

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

• interpreted

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

• interpreter shutdown

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

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

• iterable
  • 一个能够一次返回其成员的对象。可迭代的示例包括所有序列类型(例如list，str和tuple)和一些非序列类型(例如dict，file objects)以及您使用iter()方法或实现Sequence语义的getitem()方法定义的任何类的对象。

迭代器可以在for循环中使用，也可以在需要序列的其他许多地方使用(zip()，map()…)。将可迭代对象作为参数传递给内置函数iter()时，它将返回该对象的迭代器。此迭代器适合在一组值上传递一次。使用可迭代对象时，通常不必自己调用iter()或处理迭代器对象。 for语句会自动为您执行此操作，并创建一个临时的未命名变量来在循环期间保存迭代器。另请参见iterator，sequence和generator。

• iterator
  • 表示数据流的对象。重复调用迭代器的next()方法(或将其传递给内置函数next())将返回流中的后续项。如果没有更多数据可用，则会引发StopIteration异常。此时，迭代器对象已用尽，对它的__next__()方法的任何进一步调用只会再次提高StopIteration。迭代器必须具有返回迭代器对象本身的iter()方法，因此每个迭代器也是可迭代的，并且可以在接受其他可迭代的大多数地方使用。一个值得注意的 exception 是try多次迭代遍历的代码。每次将容器对象传递给iter()函数或在for循环中使用它时，容器对象(例如list)都会产生一个新的新迭代器。使用迭代器try执行此操作将仅返回上一次迭代过程中使用的相同的耗尽的迭代器对象，使其看起来像一个空容器。

可以在Iterator Types中找到更多信息。

• key function
  • 键函数或归类函数是可调用的，可返回用于排序或排序的值。例如，locale.strxfrm()用于产生一个排序键，该键知道特定于语言环境的排序约定。

Python 中的许多工具都接受关键Function来控制元素的排序或分组方式。它们包括min()，max()，sorted()，list.sort()，heapq.merge()，heapq.nsmallest()，heapq.nlargest()和itertools.groupby()。

有几种创建键Function的方法。例如。 str.lower()方法可用作区分大小写的排序的关键Function。或者，可以从_表达式(例如lambda r: (r[0], r[2]))构建键函数。此外，operator模块提供了三个关键函数构造函数：attrgetter()，itemgetter()和methodcaller()。有关如何创建和使用关键Function的示例，请参见排序方式。

• keyword argument

  • See argument.

• lambda

  • 一个由单个expression组成的匿名内联函数，在调用该函数时会对其进行评估。创建 lambda 函数的语法为lambda [parameters]: expression

• LBYL

  • 三思而后行。这种编码样式在进行调用或查找之前会明确测试前提条件。这种风格与EAFP方法相反，其 Feature 是存在许多if语句。

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

• list

  • 内置 Python sequence。尽管它的名称是 O(1)，但它更类似于其他语言中的数组而不是链接列表。

• list comprehension

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

• loader

  • 加载模块的对象。它必须定义一个名为load_module()的方法。加载程序通常由finder返回。有关详细信息，请参见 PEP 302，有关抽象 Base Class的信息请参见importlib.abc.Loader。

• magic method

  • special method的非正式同义词。

• mapping

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

• 元路径查找器

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

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

• metaclass
  • 一类的一类。类定义创建类名称，类字典和 Base Class 列表。元类负责接受这三个参数并创建类。大多数面向对象的编程语言都提供默认实现。使 Python 与众不同的是，可以创建自定义元类。大多数用户从不需要此工具，但是当需要时，元类可以提供强大而优雅的解决方案。它们已用于记录属性访问，增加线程安全性，跟踪对象创建，实现单例以及许多其他任务。

可以在Metaclasses中找到更多信息。

• method

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

• 方法解析 Sequences

  • 方法解析 Sequences 是查找期间在 Base Class 中搜索成员的 Sequences。有关自 2.3 版本以来 Python 解释器使用的算法的详细信息，请参见Python 2.3 方法解析 Sequences。

• module

  • 用作 Python 代码的组织单位的对象。模块具有一个包含任意 Python 对象的名称空间。passimporting的过程将模块加载到 Python 中。

另请参见package。

• module spec

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

• MRO

  • See 方法解析 Sequences.

• mutable

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

• named tuple

  • 术语“命名 Tuples”适用于从 Tuples 继承的任何类型或类，并且其可索引元素也可以使用命名属性进行访问。类型或类也可能具有其他Function。

几种内置类型称为 Tuples，包括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

一些命名 Tuples 是内置类型(例如上述示例)。或者，可以从继承自tuple并定义命名字段的常规类定义中创建命名 Tuples。可以手动编写此类，也可以使用工厂函数collections.namedtuple()创建此类。后一种技术还添加了一些额外的方法，这些方法在手写或内置命名 Tuples 中可能找不到。

• namespace

  • 变量存储的位置。命名空间被实现为字典。对象(在方法中)具有本地，全局和内置名称空间以及嵌套名称空间。命名空间pass防止命名冲突来支持模块化。例如，函数builtins.open和os.open()pass它们的名称空间来区分。命名空间还可以pass清楚地说明哪个模块实现了Function来提高可读性和可维护性。例如，编写random.seed()或itertools.islice()可以清楚地表明这些Function分别由random和itertools模块实现。

• namespace package

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

另请参见module。

• nested scope

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

• new-style class

  • 现在用于所有类对象的类风格的旧名称。在早期的 Python 版本中，只有new-style类才能使用 Python 的更新，通用Function，例如slots，Descriptors，属性，getattribute()，类方法和静态方法。

• object

  • 具有状态(属性或值)和定义的行为(方法)的任何数据。也是new-style class的finally Base Class。

• package

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

另请参见regular package和namespace package。

• parameter

  • function(或方法)定义中的已命名实体，它指定函数可以接受的argument(或在某些情况下为参数)。参数有五种：
• • positional-or-keyword ：指定可以passpositionally或keyword argument传递的参数。这是默认的参数类型，例如下面的 foo 和 bar *：

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

• • positional-only ：指定只能由位置提供的参数。仅位置参数可以pass在函数定义的参数列表中加入/字符来定义，例如，下面的 posonly1 和 posonly2 *：

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

• • keyword-only ：指定只能由关键字提供的参数。可以pass在函数定义的参数列表中包含单个 var-positional 参数或裸露的*来定义仅关键字的参数，例如，下面的 kw_only1 和 kw_only2 *：

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

• • var-positional ：指定可以提供任意 Sequences 的位置参数(除了已被其他参数接受的任何位置参数)。可以pass在参数名称前加上*来定义这样的参数，例如下面的 args *：

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

• • var-keyword ：指定可以提供任意多个关键字参数(除了已被其他参数接受的任何关键字参数)。可以pass在参数名称前加上**来定义此类参数，例如，在以上示例中为 kwargs *。

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

另请参见argument词汇表条目，参数和参数之间的区别的 FAQ 问题，inspect.Parameter类，Function definitions部分和 PEP 362。

• path entry

  • import path上的一个位置，基于路径的查找器参考该位置以查找要导入的模块。

• 路径 Importing 查找器

  • 可调用的sys.path_hooks(即路径进入钩子)返回的finder知道如何定位给定path entry的模块。

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

• 路径 Importing 钩子

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

• 基于路径的查找器

  • 默认的元路径发现者之一，它在import path中搜索模块。

• path-like object

  • 表示文件系统路径的对象。Classpath 对象是表示路径的str或bytes对象，或者是实现os.PathLike协议的对象。pass调用os.fspath()函数，可以将支持os.PathLike协议的对象转换为str或bytes文件系统路径。分别使用os.fsdecode()和os.fsencode()来保证str或bytes结果。由 PEP 519引入。

• PEP

  • Python 增强建议。 PEP 是一个设计文档，向 Python 社区提供信息，或描述 Python 或其过程或环境的新Function。 PEP 应提供简明的技术规范和建议Function的原理。

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

See PEP 1.

• portion

  • 单个目录中的一组文件(可能存储在 zip 文件中)，它们构成了 PEP 420中定义的名称空间包。

• positional argument

  • See argument.

• provisional API

  • 临时 API 是故意从标准库的向后兼容性保证中排除的。尽管不希望对此类接口进行重大更改，但只要将它们标记为临时，就可以在核心开发人员认为必要的情况下进行向后不兼容的更改(直到并包括删除接口)。这样的更改将不会随意进行-仅当发现在包含 API 之前就已发现的严重的基本缺陷被发现时，才会发生。

即使对于临时 API，向后不兼容的更改也被视为“万不得已的解决方案”-仍将尽一切努力找到任何已发现问题的向后兼容解决方案。

此过程使标准库可以随着时间的推移不断 Developing，而不会长时间锁定有问题的设计错误。有关更多详细信息，请参见 PEP 411。

• provisional package

  • See 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)

• 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()函数，程序员可以调用该函数返回特定对象的引用计数。

• regular package

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

另请参见namespace package。

• slots

  • 类内的语句可pass预先语句实例属性的空间并消除实例字典来节省内存。尽管这项技术很受欢迎，但要正确使用它有些棘手，最适合保留在内存至关重要的应用程序中有大量实例的罕见情况。

• sequence

  • iterable支持passgetitem()特殊方法使用整数索引进行有效的元素访问，并定义len()方法，该方法返回序列的长度。一些内置序列类型是list，str，tuple和bytes。请注意，dict还支持getitem()和len()，但是被视为 Map 而不是序列，因为查找使用了任意的immutable键而不是整数。

collections.abc.Sequence抽象 Base Class 定义了一个更丰富的接口，该接口不仅包含getitem()和len()，还添加了count()，index()，contains()和reversed()。可以使用register()显式注册实现此扩展接口的类型。

• single dispatch

  • generic function调度的一种形式，其中根据单个参数的类型选择实现。

• slice

  • 通常包含sequence的一部分的对象。使用下标符号[]创建一个切片，当给出多个时，例如在variable_name[1:3:5]中，数字之间用冒号表示。方括号(下标)表示法在内部使用slice个对象。

• special method

  • Python 隐式调用的一种方法，用于对类型(例如加法)执行特定操作。此类方法的名称以双下划线开头和结尾。 特殊方法名称中记录了特殊方法。

• statement

  • 语句是套件(代码的“块”)的一部分。语句可以是expression，也可以是带有关键字的多个结构之一，例如if，while或for。

• text encoding

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

• text file

  • file object能够读取和写入str个对象。通常，文本文件实际上会访问面向字节的数据流并自动处理text encoding。文本文件的示例包括以文本模式('r'或'w')，sys.stdin，sys.stdout和io.StringIO的实例打开的文件。

另请参见binary file以获取能够读取和写入bytes-like objects的文件对象。

• triple-quoted string

  • 由引号(“)或撇号(')的三个实例绑定的字符串。尽管它们不提供单引号字符串不具备的任何Function，但由于多种原因，它们很有用。它们允许您可以在字符串中包含未转义的单引号和双引号，并且它们可以跨越多行而无需使用延续字符，这使得它们在编写文档字符串时特别有用。

• type

  • Python 对象的类型决定了它是哪种对象。每个对象都有一个类型。对象的类型可以pass其class属性进行访问，也可以使用type(obj)进行检索。

• type alias

  • pass将类型分配给标识符创建的类型的同义词。

类型别名对于简化type hints很有用。例如：

from typing import List, Tuple

def remove_gray_shades(
        colors: List[Tuple[int, int, int]]) -> List[Tuple[int, int, int]]:
    pass

可以像这样使可读性更强：

from typing import List, Tuple

Color = Tuple[int, int, int]

def remove_gray_shades(colors: List[Color]) -> List[Color]:
    pass

请参阅typing和 PEP 484，它们描述了此Function。

• type hint
  • annotation，用于指定变量，类属性或函数参数或返回值的预期类型。

类型提示是可选的，不是由 Python 强制执行的，但它们对静态类型分析工具很有用，并有助于 IDE 进行代码完成和重构。

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

请参阅typing和 PEP 484，它们描述了此Function。

• universal newlines

  • 一种解释文本流的方式，其中将以下所有内容都视为行尾：Unix 行尾约定'\n'，Windows 约定'\r\n'和旧的 Macintosh 约定'\r'。另请参见 PEP 278和 PEP 3116以及bytes.splitlines()。

• variable annotation

  • 变量或类属性的annotation。

Comments 变量或类属性时，赋值是可选的：

class C:
    field: 'annotation'

变量 Comments 通常用于type hints：例如，此变量应采用int值：

count: int = 0

带 Comments 的赋值语句部分中说明了变量 Comments 语法。

请参阅function annotation， PEP 484和 PEP 526，它们描述了此Function。

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

另请参见venv。

• virtual machine

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

• 禅宗 Python

  • 列出有助于理解和使用该语言的 Python 设计原则和 IDEA。可以在交互式提示符下键入“ import this”来找到列表。