术语表

>>>

交互shell的默认python提示。通常用于代码示例，这些代码示例可以在解释器中交互执行。

...

可以指：

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

• 这个 Ellipsis 内置常量。

2to3

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

标准库中的2to3可用作 lib2to3 ；提供独立入口点 Tools/scripts/2to3 . 见 2to 3-自动python 2到3代码转换 .

抽象基类

抽象基类补集 duck-typing 当其他技术如 hasattr() 会是笨拙或微妙的错误（例如 magic methods ）ABC引入了虚拟子类，这些类不是从类继承的，但仍然可以被识别 isinstance() 和 issubclass() 见 abc 模块文档。python为数据结构（在 collections.abc 模块），数字（在 numbers 模块），流（在 io 模块），导入查找器和加载器（在 importlib.abc 模块）。您可以使用 abc 模块。

注释

与变量、类属性、函数参数或返回值关联的标签，按约定用作 type hint .

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

见 variable annotation ， function annotation ， PEP 484 和 PEP 526 ，描述此功能。

参数

传递给 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 词汇表条目，常见问题 the difference between arguments and parameters 和 PEP 362 .

异步上下文管理器

控制在 async with 通过定义 __aenter__() 和 __aexit__() 方法。介绍通过 PEP 492 .

异步生成器

返回 asynchronous generator iterator . 它看起来像是用 async def 除了它包含 yield 用于生成可用于 async for 循环。

通常指的是异步生成器函数，但也可以指 异步生成器迭代器 在某些情况下。在意图不明确的情况下，使用完整的术语可以避免歧义。

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

异步生成器迭代器

由 asynchronous generator 功能。

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

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

异步可迭代的

一个对象，可用于 async for 语句。必须返回 asynchronous iterator 从其 __aiter__() 方法。介绍通过 PEP 492 .

异步迭代器

实现 __aiter__() 和 __anext__() 方法。 __anext__ 必须返回 awaitable 对象。 async for 解析异步迭代器返回的等待文件 __anext__() 方法，直到它引发 StopAsyncIteration 例外。介绍通过 PEP 492 .

属性

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

可期待的

可用于 await 表达式。可以是一个 coroutine 或者一个物体 __await__() 方法。也见 PEP 492 .

BDFL

仁慈的终身独裁者，A.K.A. Guido van Rossum Python 的创造者。

二进制文件

A file object 能够读写 bytes-like objects . 二进制文件的例子是以二进制模式打开的文件 ('rb' ， 'wb' 或 'rb+' ） sys.stdin.buffer ， sys.stdout.buffer 和的实例 io.BytesIO 和 gzip.GzipFile .

也见 text file 对于能够读写的文件对象 str 物体。

借用参考文献

在Python的C API中，借用的引用是对对象的引用。它不会修改对象引用计数。如果该对象被销毁，它将变成一个悬挂式指针。例如，垃圾收集可以删除最后一个 strong reference 带到这个物体上，然后把它毁了。

呼叫 Py_INCREF() 在 borrowed reference 建议将其转换为 strong reference 在位，除非在上次使用借用的参照之前无法销毁对象。这个 Py_NewRef() 函数可用于创建新的 strong reference 。

类似对象的字节

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

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

字节码

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

字节码指令列表可在以下文档中找到： the dis module .

回调

作为参数传递的一种子程序函数，在将来的某个时刻执行。

类

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

类变量

一个在类中定义的变量，只在类级别上被修改（即不在类的实例中）。

强制

在涉及同一类型的两个参数的操作期间，将一个类型的实例隐式转换为另一个类型的实例。例如， 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 . 使用复数是一个相当高级的数学特性。如果你不知道他们的需要，几乎可以肯定你可以安全地忽略他们。

上下文管理器

控制在 with 通过定义 __enter__() 和 __exit__() 方法。见 PEP 343 .

上下文变量

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

邻接的

缓冲区被认为是连续的，如果它是 C-contiguous 或 Fortran连片 . 零维缓冲区是C和Fortran连续的。在一维数组中，这些项必须按从零开始增加索引的顺序排列在内存中，并排放置。在多维C-连续数组中，按照内存地址的顺序访问项时，最后一个索引的变化最快。但是，在Fortran连续数组中，第一个索引变化最快。

协同程序

协程是子例程的一种更为普遍的形式。子程序在一点输入，在另一点退出。可以在许多不同的点进入、退出和恢复协同程序。它们可以通过 async def 语句。也见 PEP 492 .

协同作用

返回 coroutine 对象。协程函数可以用 async def 声明，并且可以包含 await ， async for 和 async with 关键词。这些是由 PEP 492 .

CPython

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

decorator

返回另一个函数的函数，通常作为函数转换使用 @wrapper 语法。装饰师的常见例子有 classmethod() 和 staticmethod() .

decorator语法只是语法上的糖分，以下两个函数定义在语义上是等价的：

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

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

同样的概念也存在于类中，但在类中不太常用。参见文档 function definitions 和 class definitions 关于装饰工的更多信息。

描述符

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

有关描述符的方法的详细信息，请参见 实现描述符 或者 Descriptor How To Guide 。

词典

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

词典理解

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

字典视图

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

文档字符串

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

duck-typing

一种编程风格，它不看对象的类型来确定它是否有正确的接口；相反，方法或属性只是简单地被调用或使用（“如果它看起来像鸭子，它必须是鸭子。”）通过强调接口而不是特定的类型，精心设计的代码通过允许polym提高了它的灵活性。形代换。duck类型避免使用 type() 或 isinstance() . （但是，请注意，duck类型可以与 abstract base classes ）相反，它通常采用 hasattr() 测试或 EAFP 编程。

EAFP

请求宽恕比请求允许更容易。这种常见的Python编码样式假定存在有效的键或属性，如果假设被证明是错误的，则捕获异常。这种干净快速的风格的特点是有许多 try 和 except 声明。这项技术与 LBYL 许多其他语言（如C）通用的样式。

表达

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

扩展模块

一个用C或C++编写的模块，使用Python的C API与内核进行交互，并用用户代码进行交互。

F字串

带前缀的字符串文本 'f' 或 'F' 通常称为“F字符串”，简称为 formatted string literals .另请参见 PEP 498 .

文件对象

公开面向文件的API的对象（使用诸如 read() 或 write() ）到基础资源。根据创建方式的不同，文件对象可以中介对实际磁盘文件或其他类型的存储或通信设备（例如标准输入/输出、内存缓冲区、套接字、管道等）的访问。文件对象也被称为 file-like objects 或 streams .

实际上有三类文件对象：原始 binary files 缓冲的 binary files 和 text files .它们的接口在 io 模块。创建文件对象的规范方法是使用 open() 功能。

类文件对象

同义词 file object .

文件系统编码和错误处理程序

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

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

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

这个 filesystem encoding and error handler 在Python启动时由 PyConfig_Read() 功能：请参阅 filesystem_encoding 和 filesystem_errors 成员： PyConfig 。

另请参阅 locale encoding 。

取景器

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

自python 3.3以来，有两种类型的finder： meta path finders 供使用 sys.meta_path 和 path entry finders 供使用 sys.path_hooks .

见 PEP 302 ， PEP 420 和 PEP 451 更多细节。

向下取整数

四舍五入为最接近整数的数学除法。向下取整数操作员是 // .例如，表达式 11 // 4 评估为 2 相比之下 2.75 由浮点真除法返回。注意 (-11) // 4 是 -3 因为那是 -2.75 圆形的 向下地 . 见 PEP 238 .

功能

一系列向调用者返回某个值的语句。它也可以通过零或更多 arguments 可用于执行尸体。也见 parameter ， method 和 函数定义 部分。

功能注释

安 annotation 函数参数或返回值。

函数注释通常用于 type hints ：例如，此函数应取两个 int 参数，还应具有 int 返回值：

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

第节解释了函数注释语法。 函数定义 .

见 variable annotation 和 PEP 484 ，描述此功能。

__future__

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

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

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

垃圾收集

当内存不再使用时释放内存的过程。python通过引用计数和能够检测和中断引用循环的循环垃圾收集器来执行垃圾收集。垃圾收集器可以使用 gc 模块。

生成器

返回 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() decorator，以及 PEP 443 .

泛型类型

A type 可以参数化的；通常是像这样的容器 list 。用于 type hints 和 annotations 。

看见 PEP 483 了解更多详细信息，以及 typing 或 generic alias type 因为它的用途。

GIL

见 global interpreter lock .

全局解释器锁

所使用的机制 CPython 解释器确保只有一个线程执行python bytecode 一次。这通过创建对象模型（包括关键的内置类型，如 dict ）对并发访问具有隐式安全性。锁定整个解释器使解释器更容易被多线程处理，而牺牲了多处理器机器提供的大部分并行性。

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

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

基于散列的PYC

一种字节码缓存文件，它使用hash而不是相应源文件的最后修改时间来确定其有效性。见 缓存字节码无效 .

可装卸的

对象是 可装卸的 如果它的hash值在其生存期内从未更改（它需要 __hash__() 方法），并且可以与其他对象进行比较（它需要 __eq__() 方法）。比较等于的hash对象必须具有相同的hash值。

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

python的大多数不可变内置对象都是可散列的；可变容器（如列表或字典）不是可散列的；不可变容器（如元组和frozenset）只有在元素是可散列的情况下才是可散列的。默认情况下，属于用户定义类实例的对象是可哈希的。它们都比较不相等（除了它们本身），并且它们的散列值是从它们的 id() .

IDLE

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

不变的

具有固定值的对象。不可变对象包括数字、字符串和元组。这样的物体是不能改变的。如果必须存储不同的值，则必须创建新对象。它们在需要常量散列值的地方扮演重要角色，例如作为字典中的键。

导入路径

位置列表（或 path entries ）被 path based finder 用于导入模块。在导入期间，此位置列表通常来自 sys.path ，但对于子包，它也可能来自父包的 __path__ 属性。

输入

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

importers

同时查找和加载模块的对象；都是 finder 和 loader 对象。

互动式

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

解释

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

解释程序关闭

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

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

可迭代的

能够一次返回一个成员的对象。iterables的示例包括所有序列类型（例如 list ， str 和 tuple ）还有一些非序列类型，比如 dict ， file objects 以及用 __iter__() 方法或 __getitem__() 实现的方法 Sequence 语义学。

iTerables可用于 for 在许多其他需要序列的地方循环 (zip() ， map() ，……）当iterable对象作为参数传递给内置函数时 iter() 返回对象的迭代器。这个迭代器很适合一次传递一组值。使用iterables时，通常不需要调用 iter() 或者自己处理迭代器对象。这个 for 语句为您自动执行此操作，创建一个临时的未命名变量，以便在循环期间保存迭代器。也见 iterator ， sequence 和 generator .

迭代器

表示数据流的对象。对迭代器的重复调用 __next__() 方法（或将其传递给内置函数 next() ）返回流中的连续项。当没有更多数据可用时 StopIteration 而是引发异常。此时，迭代器对象已用完，并且对它的 __next__() 方法只是提高 StopIteration 再一次。迭代器必须具有 __iter__() 方法，它返回迭代器对象本身，因此每个迭代器也可以是iterable，并且可以在大多数接受其他iterable的地方使用。一个显著的例外是尝试多次迭代的代码。容器对象（例如 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 有关如何创建和使用键函数的示例。

关键字参数

见 argument .

lambda

一个匿名内联函数，由一个 expression 在调用函数时对其进行计算。创建lambda函数的语法是 lambda [parameters]: expression

LBYL

三思而后行。这种编码风格在调用或查找之前显式地测试预条件。这种风格与 EAFP 方法，其特点是存在许多 if 声明。

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

区域设置编码

在Unix上，它是LC_CTYPE区域设置的编码。可以使用以下命令进行设置 locale.setlocale(locale.LC_CTYPE, new_locale) 。

在Windows上，它是ANSI代码页(例如： cp1252 )。

locale.getpreferredencoding(False) 可用于获取区域设置编码。

Python使用 filesystem encoding and error handler 若要在Unicode文件名和字节文件名之间进行转换，请执行以下操作。

列表

内置的python sequence . 尽管它的名称是O（1），但它更类似于其他语言的数组，而不是链表，因为对元素的访问是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 对于一个 abstract base class .

魔术法

非正式的同义词 special method .

映射

支持任意键查找并实现在中指定的方法的容器对象。 Mapping 或 MutableMapping abstract base classes . 示例包括 dict ， collections.defaultdict ， collections.OrderedDict 和 collections.Counter .

元路径查找器

A finder 通过搜索返回 sys.meta_path . 元路径查找器与相关，但不同于 path entry finders .

见 importlib.abc.MetaPathFinder 用于元路径查找器实现的方法。

元类

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

更多信息可在 元类 .

方法

在类体内部定义的函数。如果作为该类实例的属性调用，该方法将首先获取实例对象 argument （通常称为 self ）见 function 和 nested scope .

方法分辨率顺序

方法解析顺序是在查找过程中搜索成员的基类的顺序。见 The Python 2.3 Method Resolution Order 有关自2.3版本以来Python解释器使用的算法的详细信息。

模块

用作Python代码组织单位的对象。模块具有包含任意python对象的命名空间。模块通过 importing .

也见 package .

模块规格

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

MRO

见 method resolution order .

易变的

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

名元组

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

有几个内置类型是命名元组，包括 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 它定义了命名字段。这样的类可以手工编写，也可以使用factory函数创建 collections.namedtuple() . 后一种技术还添加了一些在手写或内置命名元组中找不到的额外方法。

命名空间

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

命名空间包

A PEP 420 package 仅用作子封装的容器。命名空间包可能没有物理表示，具体来说，它不像 regular package 因为他们没有 __init__.py 文件。

也见 module .

嵌套范围

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

新式类

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

对象

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

包裹

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

也见 regular package 和 namespace package .

参数

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

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

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

• positional-only ：指定只能由位置提供的参数。仅位置参数可以通过包含 / 函数定义的参数列表中的字符，例如 位置1 和 位置2 以下内容：

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

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

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

• var-positional ：指定可以提供任意位置参数序列（除其他参数已接受的任何位置参数之外）。这样的参数可以通过在参数名称前面加上 * ，例如 args 以下内容：

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

• var-keyword ：指定可以提供任意多个关键字参数（除了其他参数已接受的任何关键字参数）。这样的参数可以通过在参数名称前面加上 ** ，例如 关键字参数 在上面的例子中。

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

也见 argument 词汇表条目，常见问题 the difference between arguments and parameters , the inspect.Parameter 类 函数定义 截面和 PEP 362 .

路径入口

上的单个位置 import path 哪一个 path based finder 查询以查找要导入的模块。

路径入口查找器

A finder 由可调用的返回 sys.path_hooks （即 path entry hook ）它知道如何定位给定 path entry .

见 importlib.abc.PathEntryFinder 用于路径项查找器实现的方法。

路径入口钩子

可调用的 sys.path_hook 返回的列表 path entry finder 如果它知道如何在特定的 path entry .

基于路径的查找器

违约之一 meta path finders 搜索一个 import path 用于模块。

类路径对象

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

PEP

python增强建议。PEP是一个向Python社区提供信息的设计文档，或者描述Python或其流程或环境的新特性。PEP应提供一份简明的技术规范和拟议特征的基本原理。

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

见 PEP 1 .

部分

一个目录中的一组文件（可能存储在一个zip文件中），它们构成了一个命名空间包，如中所定义的 PEP 420 .

位置参数

见 argument .

临时API

临时API是故意从标准库的向后兼容性保证中排除的API。虽然预计不会对这些接口进行重大更改，但只要它们被标记为临时的，如果核心开发人员认为有必要，则可能会发生向后不兼容的更改（直到并包括删除接口）。这样的改变不会是无缘无故的——只有在API加入之前发现了严重的根本缺陷，这些缺陷才会发生。

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

这个过程允许标准库随着时间的推移继续发展，而不会在长时间内锁定有问题的设计错误。见 PEP 411 了解更多详细信息。

临时工程包

见 provisional API .

Python 3000

python 3.x发布行的昵称（很久以前，版本3的发布是在遥远的将来才出现的）也缩写为“py3k”。

Python 的

一种思想或一段代码，它密切遵循Python语言中最常见的习惯用法，而不是使用其他语言通用的概念来实现代码。例如，Python中的一个常见习惯用法是使用 for 语句。许多其他语言没有这种类型的构造，因此不熟悉Python的人有时会使用数字计数器：

for i in range(len(food)):
    print(food[i])

与清洁剂相反， Python 法：

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() 。

集合理解

一种处理可迭代中的全部或部分元素并返回包含结果的集合的紧凑方式。 results = {{c for c in 'abracadabra' if c not in 'abc'}} 生成字符串集 {{'r', 'd'}} 。看见 显示列表、集合和字典 。

单次调度

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

片

通常包含 sequence .切片是使用下标表示法创建的， [] 当给定多个数字时，数字之间有冒号，如in variable_name[1:3:5] . 括号（下标）表示法使用 slice 内部对象。

特殊方法

python隐式调用的方法，用于对类型（如addition）执行某个操作。此类方法的名称以双下划线开头和结尾。特殊方法记录在 特殊方法名称 .

陈述

语句是一个套件（代码块）的一部分。语句可以是 expression 或具有关键字的多个构造之一，例如 if ， while 或 for .

强引用

在Python的C API中，强引用是对对象的引用，该对象在创建时递增对象的引用计数，在删除时递减对象的引用计数。

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

另请参阅 borrowed reference 。

文本编码

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

文本文件

A file object 能够读写 str 物体。通常，文本文件实际上访问面向字节的数据流并处理 text encoding 自动地。文本文件的示例是以文本模式打开的文件 ('r' 或 'w' ） sys.stdin ， sys.stdout 和的实例 io.StringIO .

也见 binary file 对于能够读写的文件对象 bytes-like objects .

三引号字符串

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

类型

python对象的类型决定了它是什么类型的对象；每个对象都有一个类型。对象的类型可以作为其 __class__ 属性或可以用 type(obj) .

类型别名

通过将类型分配给标识符而创建的类型的同义词。

类型别名对于简化 type hints . 例如：：

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 ，描述此功能。

类型提示

安 annotation 它指定变量、类属性、函数参数或返回值的预期类型。

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

全局变量、类属性和函数（而不是局部变量）的类型提示可以使用 typing.get_type_hints() .

见 typing 和 PEP 484 ，描述此功能。

通用换行符

一种解释文本流的方式，在这种方式中，所有以下内容都被识别为行尾：unix行尾约定 '\n' ，Windows惯例 '\r\n' 和旧的Macintosh惯例 '\r' . 见 PEP 278 和 PEP 3116 以及 bytes.splitlines() 作为附加用途。

变量注释

安 annotation 变量或类属性的。

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

class C:
    field: 'annotation'

变量注释通常用于 type hints ：例如，此变量应采用 int 价值观：

count: int = 0

变量注释语法在第节中解释。 带批注的工作分配语句 .

见 function annotation ， PEP 484 和 PEP 526 ，描述此功能。

虚拟环境

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

也见 venv .

虚拟机

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

Python 禅

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