术语表

>>>
Python默认的shell提示符。经常看到的代码示例，可以在解释器交互执行。
...
在输入缩进代码块的代码或一对匹配的左右分隔符（括号，方括号或花括号）时，交互式shell的默认Python提示。
2to3

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

2to3在标准库中可用lib2to3；提供了一个独立的入口点，如Tools/scripts/2to3。请参阅2to3 - Automated Python 2 to 3 code translation。

抽象基类
Abstract base classes complement duck-typing by providing a way to define interfaces when other techniques like hasattr() would be clumsy or subtly wrong (for example with magic methods). ABCs引入虚拟子类，这些类不继承类，但仍然被isinstance()和issubclass()识别；请参阅abc模块文档。Python comes with many built-in ABCs for data structures (in the collections.abc module), numbers (in the numbers module), streams (in the io module), import finders and loaders (in the importlib.abc module). 您可以使用abc模块创建自己的ABCs。
论据

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

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

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

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

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

参数被分配给函数体中指定的局部变量。有关管理此分配的规则，请参阅Calls部分。在语法上，任何表达式都可以用来表示参数；计算值分配给局部变量。

另请参阅parameter词汇表条目，有关the difference between arguments and parameters和 PEP 362。

异步上下文管理器
An object which controls the environment seen in an async with statement by defining __aenter__() and __aexit__() methods. 由 PEP 492引入。
异步迭代
一个对象，可以在async for语句。必须从其__aiter__()方法中返回asynchronous iterator。由 PEP 492引入。
异步迭代器
实现__aiter__()和__anext__()方法的对象。__anext__必须返回awaitable对象。async for resolves awaitable returned from asynchronous iterator’s __anext__() method until it raises StopAsyncIteration exception. 由 PEP 492引入。
属性
与使用点表达式的名称引用的对象关联的值。例如，如果对象o具有属性a，则它将被引用为o.a。
等待
可用于await表达式中的对象。可以是coroutine或具有__await__()方法的对象。另见 PEP 492。
BDFL
生命的亲切独裁者Guido van Rossum，Python的创作者。
二进制文件

file object能够读取和写入bytes-like objects。

也可以看看

text file读取和写入str对象。

字节状对象

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

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

字节码

Python源代码编译成字节码，CPython解释器中的Python程序的内部表示。字节码也缓存在.pyc和.pyo文件中，以便第二次执行相同的文件更快（可以避免从源码到字节码的重新编译）。这种“中间语言”被称为在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。使用复数是一个相当高级的数学特征。如果你不知道需要他们，几乎肯定你可以安全地忽略他们。
上下文管理器
通过定义__ enter __()和__ exit __()方法控制在中使用语句看到的环境的对象。请参阅 PEP 343。
连续

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

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

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

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

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

类存在相同的概念，但在那里不太常用。有关装饰器的更多信息，请参阅function definitions和class definitions的文档。

描述器

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

有关描述器的方法的详细信息，请参阅Implementing Descriptors。

字典
关联数组，其中任意键映射到值。键可以是具有__hash__()和__eq__()方法的任何对象。在Perl中调用了一个散列。
字典视图
从dict.keys()，dict.values()和dict.items()返回的对象称为字典视图。它们提供了对字典条目的动态视图，这意味着当字典更改时，视图反映这些更改。要强制字典视图成为完整列表，请使用list(dictview)。请参见Dictionary view objects。
docstring
字符串字面值，作为类，函数或模块中的第一个表达式出现。当套件被执行时被忽略，它被编译器识别并放入封装类，函数或模块的__doc__属性。因为它是通过内省可用的，它是对象的文档的规范的地方。
鸭子类型
一种编程风格，它不查看对象的类型来确定它是否具有正确的接口；相反，方法或属性被简单地调用或使用（“如果它看起来像一只鸭子，像鸭子一样夸张，它必须是一只鸭子。”通过强调接口而不是特定类型，精心设计的代码通过允许多态性替换。duck-typing避免使用type()或isinstance()进行测试。（请注意，鸭式类型可以用abstract base classes补充。）相反，它通常使用hasattr()测试或EAFP编程。
EAFP
更容易要求原谅比许可。这种常见的Python编码风格假定存在有效的键或属性，并且如果假设证明是假的，则捕获异常。这种干净快速的风格的特点是存在许多try和except语句。该技术与许多其他语言（例如C）通用的LBYL样式形成对比。
表达式
一个语法可以计算到一些值。换句话说，表达式是字面值，名称，属性访问，操作符或函数调用等表达式元素的累加，它们都返回一个值。与许多其他语言相反，并非所有的语言结构都是表达式。还有statement s，不能用作表达式，例如if。赋值也是语句，而不是表达式。
扩展模块
用C或C ++编写的模块，使用Python的C API与核心和用户代码交互。
文件对象

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

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

文件状对象
file object的同义词。
发现者

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

Since Python 3.3, there are two types of finder: meta path finders for use with sys.meta_path, and path entry finders for use with sys.path_hooks.

参见 PEP 302， PEP 420和 PEP 451

地板划分
向下舍入到最接近的整数的数学除法。底板划分操作符是//。例如，表达式11 // 4评估为2由float true除法返回的2.75。请注意，（ - 11） // 4是-3 -2.75舍入向下。请参见 PEP 238。
功能
一系列对调用者返回一些值的语句。它也可以传递零个或多个arguments，可以在主体的执行中使用。另请参见parameter，method和Function definitions部分。
函数注解

与函数参数或返回值相关联的任意元数据值。其语法在Function definitions中进行了说明。注解可以通过函数对象的__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语句）。当生成器迭代器恢复时，它会在其中删除的位置（与在每次调用时开始的函数相反）。

生成器表达式

返回迭代器的表达式。它看起来像是一个正常表达式，后面是定义循环变量，范围和可选的if表达式的for表达式。组合表达式生成包围函数的值：

>>> 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__()方法），并可以与其他对象a __eq__()方法）。比较相等的散列对象必须具有相同的散列值。

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

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

IDLE
Python的集成开发环境。IDLE是一个基本的编辑器和解释器环境，附带Python的标准分布。
不可变
具有固定值的对象。不可变对象包括数字，字符串和元组。这样的对象不能被改变。如果必须存储不同的值，则必须创建新对象。它们在需要恒定哈希值的地方起重要作用，例如作为字典中的键。
导入路径
由path based finder搜索的位置列表（或path entries）以供导入的模块。在导入期间，此位置列表通常来自sys.path，但对于子包，它也可能来自父包的__path__属性。
输入
一个模块中的Python代码可用于另一个模块中的Python代码的过程。
进口商
既找到又加载模块的对象； finder和loader对象。
互动
Python有一个交互式解释器，这意味着您可以在解释器提示符处输入语句和表达式，立即执行它们并查看它们的结果。只需启动没有参数的python（可能从计算机的主菜单中选择它）。这是一种非常强大的方法来测试新的想法或检查模块和包（记住help(x)）。
解释
Python是一种解释型语言，与编译型语言相反，尽管由于字节码编译器的存在，区别可能很模糊。这意味着源文件可以直接运行而不显式创建可执行文件，然后运行。解释语言通常具有比编译的语言更短的开发/调试周期，尽管它们的程序通常也运行得更慢。另请参阅interactive。
解释器关机

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

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

可迭代
能够一次返回其成员一个对象。Examples of iterables include all sequence types (such as list, str, and tuple) and some non-sequence types like dict, file objects, and objects of any classes you define with an __iter__() or __getitem__() method. Iterables可以在for循环，也可以用在需要序列的很多其他地方（zip()，map() 。）。当可迭代对象作为参数传递给内建函数iter()时，它会返回对象的迭代器。这个迭代器对于一组值是有利的。当使用iterables时，通常不需要调用iter()或者自己处理iterator对象。for语句会自动为您创建一个临时未命名变量，以便在循环持续时间内保存迭代器。另请参见iterator，sequence和generator。
迭代器

表示数据流的对象。重复调用迭代器的__next__()方法（或将其传递给内建函数next()）会返回流中的连续项。当没有更多数据可用时，会出现StopIteration异常。此时，迭代器对象被耗尽，并且对其__next__()方法的任何进一步调用再次引发StopIteration。迭代器需要具有返回迭代器对象本身的__iter__()方法，因此每个迭代器也是可迭代的，并且可以在其他迭代被接受的大多数地方使用。一个值得注意的例外是尝试多次迭代的代码。A container object (such as a list) produces a fresh new iterator each time you pass it to the iter() function or use it in a for loop. 使用迭代器尝试这个操作只会返回上一次迭代过程中使用的相同的穷尽迭代器对象，使其看起来像一个空容器。

有关详细信息，请参阅Iterator Types。

键功能

键函数或排序规则函数是返回用于排序或排序的值的可调用方法。例如，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 [arguments]： 表达式
LBYL

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

在多线程环境中，LBYL方法可能会在“查找”和“跨越”之间引入竞争条件。For example, the code, if key in mapping: return mapping[key] can fail if another thread removes key from mapping after the test, but before the lookup. 这个问题可以用锁或使用EAFP方法解决。

列表
内建Python sequence。尽管它的名称，它更像是一个数组在其他语言，而不是一个链表，因为访问元素是O（1）。
list推导式
一种处理序列中所有或部分元素并返回结果列表的紧凑方法。result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] generates a list of strings containing even hex numbers (0x..) in the range from 0 to 255. if子句是可选的。如果省略，则处理range(256)中的所有元素。
装载机
加载模块的对象。它必须定义一个名为load_module()的方法。加载器通常由finder返回。有关详细信息，请参阅 PEP 302，对于abstract base class，请参阅importlib.abc.Loader。
映射
支持任意键查找并实现Mapping或MutableMapping abstract base classes中指定的方法的容器对象。示例包括dict，collections.defaultdict，collections.OrderedDict和collections.Counter。
元路径查找器

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

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

元类

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

有关详细信息，请参见Customizing class creation。

方法
一个在类体内定义的函数。如果被称为该类的实例的属性，该方法将获得实例对象作为其第一个argument（通常称为self）。请参见function和nested scope。
方法解析顺序
方法解析顺序是在查找期间搜索基类以查找成员的顺序。有关自2.3版本以来Python解释器使用的算法的详细信息，请参见Python 2.3方法解析顺序。
模块

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

另请参见package。

模块规格
包含用于加载模块的导入相关信息的命名空间。importlib.machinery.ModuleSpec的实例。
MRO
请参阅method resolution order。
可变
可变对象可以更改其值，但保留其id()。另请参见immutable。
命名元组

使用命名属性（例如time.localtime()可访问其可索引元素的任何类似元组的类都返回一个类似元组的对象，其中年诸如t[0]或具有诸如t.tm_year的命名属性的索引）。

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

命名空间
存储变量的位置。命名空间实现为字典。在对象中（在方法中）有local，global和内建命名空间以及嵌套命名空间。命名空间通过防止命名冲突来支持模块化。对于实例，函数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__属性的Python模块。

另请参阅regular package和namespace package。

参数

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

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

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

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

  • 仅限关键字：指定只能由关键字提供的参数。可以通过在函数定义的参数列表中包括单个var位置参数或裸元素*来定义纯关键字参数，例如kw_only1和kw_only2：

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

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

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

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

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

另请参见argument词汇表条目，the difference between arguments and parameters，inspect.Parameter类，Function definitions部分和 PEP 362。

路径条目
import path上的path based finder的单个位置可查找用于导入的模块。
路径入口查找器

由sys.path_hooks上的可调用方返回的findera path entry hook），其知道如何定位给定path entry的模块。

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

路径入口钩
在sys.path_hook列表上的可调用项，如果它知道如何在特定path entry上查找模块，则返回path entry finder。
基于路径的查找器
其中一个默认的meta path finders用于搜索模块的import path。
一部分
在 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__
一个类中的声明，通过为实例属性预先声明空间并消除实例字典来节省内存。虽然很受欢迎，但这种技术有点棘手，而且最好保留用于在内存关键型应用程序中有大量实例的罕见情况。
序列

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

The collections.abc.Sequence abstract base class defines a much richer interface that goes beyond just __getitem__() and __len__(), adding count(), index(), __contains__(), and __reversed__(). 实现此扩展接口的类型可以使用register()显式注册。

单调度
generic function的形式，其中基于单个参数的类型选择实现。
片
通常包含sequence部分的对象。使用下标符号[]创建切片，例如在variable_name[1:3:5]中，在给定几个数字时在数字之间使用冒号。括号（下标）符号在内部使用slice对象。
特殊方法
由Python隐式调用以对类型执行某个操作（如加法）的方法。这样的方法具有以双下划线开始和结束的名称。在Special method names中记录了特殊方法。
声明
语句是套件的一部分（代码的“块”）。语句是expression或具有关键字的多个构造中的一个，例如if，while或for 。
结构序列
具有命名元素的元组。Struct序列暴露类似于named tuple的接口，因为可以通过索引或作为属性访问元素。但是，它们没有任何名为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()供额外使用。
虚拟环境

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

另请参见pyvenv - Creating virtual environments。

虚拟机
完全由软件定义的计算机。Python的虚拟机执行字节码编译器发出的bytecode。
Python的禅
列出有助于理解和使用语言的Python设计原则和哲学。可以在交互式提示符处键入“import this”找到列表。