### 导航
- [索引](genindex.xhtml "总目录")
- [模块](py-modindex.xhtml "Python 模块索引") |
- [下一页](about.xhtml "文档说明") |
- [上一页](faq/installed.xhtml "“为什么我的电脑上安装了 Python ？”") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](index.xhtml) »
- $('.inline-search').show(0); |
# 术语对照表
`>>>`交互式终端中默认的 Python 提示符。往往会显示于能以交互方式在解释器里执行的样例代码之前。
`...`交互式终端中输入特殊代码行时默认的 Python 提示符，包括：缩进的代码块，成对的分隔符之内（圆括号、方括号、花括号或三重引号），或是指定一个装饰器之后。
2to3一个将 Python 2.x 代码转换为 Python 3.x 代码的工具，能够处理大部分通过解析源码并遍历解析树可检测到的不兼容问题。
2to3 包含在标准库中，模块名为 [`lib2to3`](library/2to3.xhtml#module-lib2to3 "lib2to3: the 2to3 library")；并提供一个独立入口点 `Tools/scripts/2to3`。参见 [2to3 - 自动将 Python 2 代码转为 Python 3 代码](library/2to3.xhtml#to3-reference)。
abstract base class -- 抽象基类抽象基类简称 ABC，是对 [duck-typing](#term-duck-typing) 的补充，它提供了一种定义接口的新方式，相比之下其他技巧例如 [`hasattr()`](library/functions.xhtml#hasattr "hasattr") 显得过于笨拙或有微妙错误（例如使用 [魔术方法](reference/datamodel.xhtml#special-lookup)）。ABC 引入了虚拟子类，这种类并非继承自其他类，但却仍能被 [`isinstance()`](library/functions.xhtml#isinstance "isinstance") 和 [`issubclass()`](library/functions.xhtml#issubclass "issubclass") 所认可；详见 [`abc`](library/abc.xhtml#module-abc "abc: Abstract base classes according to PEP 3119.") 模块文档。Python 自带许多内置的 ABC 用于实现数据结构（在 [`collections.abc`](library/collections.abc.xhtml#module-collections.abc "collections.abc: Abstract base classes for containers") 模块中）、数字（在 [`numbers`](library/numbers.xhtml#module-numbers "numbers: Numeric abstract base classes (Complex, Real, Integral, etc.).") 模块中）、流（在 [`io`](library/io.xhtml#module-io "io: Core tools for working with streams.") 模块中）、导入查找器和加载器（在 [`importlib.abc`](library/importlib.xhtml#module-importlib.abc "importlib.abc: Abstract base classes related to import") 模块中）。你可以使用 [`abc`](library/abc.xhtml#module-abc "abc: Abstract base classes according to PEP 3119.") 模块来创建自己的 ABC。
annotation -- 标注关联到某个变量、类属性、函数形参或返回值的标签，被约定作为 [type hint](#term-type-hint) 来使用。
局部变量的标注在运行时不可访问，但全局变量、类属性和函数的标注会分别存放模块、类和函数的 `__annotations__` 特殊属性中。
参见 [variable annotation](#term-variable-annotation)、[function annotation](#term-function-annotation)、[**PEP 484**](https://www.python.org/dev/peps/pep-0484) \[https://www.python.org/dev/peps/pep-0484\] 和 [**PEP 526**](https://www.python.org/dev/peps/pep-0526) \[https://www.python.org/dev/peps/pep-0526\]，对此功能均有介绍。
argument -- 参数在调用函数时传给 [function](#term-function) （或 [method](#term-method) ）的值。参数分为两种：
- *关键字参数*: 在函数调用中前面带有标识符（例如 `name=`）或者作为包含在前面带有 `**` 的字典里的值传入。举例来说，`3` 和 `5` 在以下对 [`complex()`](library/functions.xhtml#complex "complex") 的调用中均属于关键字参数:
```
complex(real=3, imag=5)
complex(**{'real': 3, 'imag': 5})
```
- *位置参数*: 不属于关键字参数的参数。位置参数可出现于参数列表的开头以及/或者作为前面带有 `*` 的 [iterable](#term-iterable) 里的元素被传入。举例来说，`3` 和 `5` 在以下调用中均属于位置参数:
```
complex(3, 5)
complex(*(3, 5))
```
参数会被赋值给函数体中对应的局部变量。有关赋值规则参见 [调用](reference/expressions.xhtml#calls) 一节。根据语法，任何表达式都可用来表示一个参数；最终算出的值会被赋给对应的局部变量。
另参见 [parameter](#term-parameter) 术语表条目，常见问题中 [参数与形参的区别](faq/programming.xhtml#faq-argument-vs-parameter) 以及 [**PEP 362**](https://www.python.org/dev/peps/pep-0362) \[https://www.python.org/dev/peps/pep-0362\]。
asynchronous context manager -- 异步上下文管理器此种对象通过定义 [`__aenter__()`](reference/datamodel.xhtml#object.__aenter__ "object.__aenter__") 和 [`__aexit__()`](reference/datamodel.xhtml#object.__aexit__ "object.__aexit__") 方法来对 [`async with`](reference/compound_stmts.xhtml#async-with) 语句中的环境进行控制。由 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\] 引入。
asynchronous generator -- 异步生成器返回值为 [asynchronous generator iterator](#term-asynchronous-generator-iterator) 的函数。它与使用 [`async def`](reference/compound_stmts.xhtml#async-def) 定义的协程函数很相似，不同之处在于它包含 [`yield`](reference/simple_stmts.xhtml#yield) 表达式以产生一系列可在 [`async for`](reference/compound_stmts.xhtml#async-for) 循环中使用的值。
此术语通常是指异步生成器函数，但在某些情况下则可能是指 *异步生成器迭代器*。如果需要清楚表达具体含义，请使用全称以避免歧义。
一个异步生成器函数可能包含 [`await`](reference/expressions.xhtml#await) 表达式或者 [`async for`](reference/compound_stmts.xhtml#async-for) 以及 [`async with`](reference/compound_stmts.xhtml#async-with) 语句。
asynchronous generator iterator -- 异步生成器迭代器[asynchronous generator](#term-asynchronous-generator) 函数所创建的对象。
此对象属于 [asynchronous iterator](#term-asynchronous-iterator)，当使用 [`__anext__()`](reference/datamodel.xhtml#object.__anext__ "object.__anext__") 方法调用时会返回一个可等待对象来执行异步生成器函数的代码直到下一个 [`yield`](reference/simple_stmts.xhtml#yield) 表达式。
每个 [`yield`](reference/simple_stmts.xhtml#yield) 会临时暂停处理，记住当前位置执行状态 (包括局部变量和挂起的 try 语句)。当该 *异步生成器迭代器* 与其他 [`__anext__()`](reference/datamodel.xhtml#object.__anext__ "object.__anext__") 返回的可等待对象有效恢复时，它会从离开位置继续执行。参见 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\] 和 [**PEP 525**](https://www.python.org/dev/peps/pep-0525) \[https://www.python.org/dev/peps/pep-0525\]。
asynchronous iterable -- 异步可迭代对象可在 [`async for`](reference/compound_stmts.xhtml#async-for) 语句中被使用的对象。必须通过它的 [`__aiter__()`](reference/datamodel.xhtml#object.__aiter__ "object.__aiter__") 方法返回一个 [asynchronous iterator](#term-asynchronous-iterator)。由 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\] 引入。
asynchronous iterator -- 异步迭代器实现了 [`__aiter__()`](reference/datamodel.xhtml#object.__aiter__ "object.__aiter__") 和 [`__anext__()`](reference/datamodel.xhtml#object.__anext__ "object.__anext__") 方法的对象。`__anext__` 必须返回一个 [awaitable](#term-awaitable) 对象。[`async for`](reference/compound_stmts.xhtml#async-for) 会处理异步迭代器的 [`__anext__()`](reference/datamodel.xhtml#object.__anext__ "object.__anext__") 方法所返回的可等待对象，直到其引发一个 [`StopAsyncIteration`](library/exceptions.xhtml#StopAsyncIteration "StopAsyncIteration") 异常。由 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\] 引入。
attribute -- 属性关联到一个对象的值，可以使用点号表达式通过其名称来引用。例如，如果一个对象 *o* 具有一个属性 *a*，就可以用 *o.a* 来引用它。
awaitable -- 可等待对象能在 [`await`](reference/expressions.xhtml#await) 表达式中使用的对象。可以是 [coroutine](#term-coroutine) 或是具有 [`__await__()`](reference/datamodel.xhtml#object.__await__ "object.__await__") 方法的对象。参见 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\]。
BDFL“终身仁慈独裁者”的英文缩写，即 [Guido van Rossum](https://gvanrossum.github.io/) \[https://gvanrossum.github.io/\]，Python 的创造者。
binary file -- 二进制文件[file object](#term-file-object) 能够读写 [字节类对象](#term-bytes-like-object)。二进制文件的例子包括以二进制模式（`'rb'`, `'wb'` or `'rb+'`）打开的文件、`sys.stdin.buffer`、`sys.stdout.buffer` 以及 [`io.BytesIO`](library/io.xhtml#io.BytesIO "io.BytesIO") 和 [`gzip.GzipFile`](library/gzip.xhtml#gzip.GzipFile "gzip.GzipFile") 的实例。
另请参见 [text file](#term-text-file) 了解能够读写 [`str`](library/stdtypes.xhtml#str "str") 对象的文件对象。
bytes-like object -- 字节类对象支持 [缓冲协议](c-api/buffer.xhtml#bufferobjects) 并且能导出 C-[contiguous](#term-contiguous) 缓冲的对象。这包括所有 [`bytes`](library/stdtypes.xhtml#bytes "bytes")、[`bytearray`](library/stdtypes.xhtml#bytearray "bytearray") 和 [`array.array`](library/array.xhtml#array.array "array.array") 对象，以及许多普通 [`memoryview`](library/stdtypes.xhtml#memoryview "memoryview") 对象。字节类对象可在多种二进制数据操作中使用；这些操作包括压缩、保存为二进制文件以及通过套接字发送等。
某些操作需要可变的二进制数据。这种对象在文档中常被称为“可读写字节类对象”。可变缓冲对象的例子包括 [`bytearray`](library/stdtypes.xhtml#bytearray "bytearray") 以及 [`bytearray`](library/stdtypes.xhtml#bytearray "bytearray") 的 [`memoryview`](library/stdtypes.xhtml#memoryview "memoryview")。其他操作要求二进制数据存放于不可变对象 ("只读字节类对象")；这种对象的例子包括 [`bytes`](library/stdtypes.xhtml#bytes "bytes") 以及 [`bytes`](library/stdtypes.xhtml#bytes "bytes") 对象的 [`memoryview`](library/stdtypes.xhtml#memoryview "memoryview")。
bytecode -- 字节码Python 源代码会被编译为字节码，即 CPython 解释器中表示 Python 程序的内部代码。字节码还会缓存在 `.pyc` 文件中，这样第二次执行同一文件时速度更快（可以免去将源码重新编译为字节码）。这种 "中间语言" 运行在根据字节码执行相应机器码的 [virtual machine](#term-virtual-machine) 之上。请注意不同 Python 虚拟机上的字节码不一定通用，也不一定能在不同 Python 版本上兼容。
字节码指令列表可以在 [dis 模块](library/dis.xhtml#bytecodes) 的文档中查看。
class -- 类用来创建用户定义对象的模板。类定义通常包含对该类的实例进行操作的方法定义。
class variable -- 类变量在类中定义的变量，并且仅限在类的层级上修改 (而不是在类的实例中修改)。
coercion -- 强制类型转换在包含两个相同类型参数的操作中，一种类型的实例隐式地转换为另一种类型。例如，`int(3.15)` 是将原浮点数转换为整型数 `3`，但在 `3+4.5` 中，参数的类型不一致（一个是 int, 一个是 float），两者必须转换为相同类型才能相加，否则将引发 [`TypeError`](library/exceptions.xhtml#TypeError "TypeError")。如果没有强制类型转换机制，程序员必须将所有可兼容参数归一化为相同类型，例如要写成 `float(3)+4.5` 而不是 `3+4.5`。
complex number -- 复数对普通实数系统的扩展，其中所有数字都被表示为一个实部和一个虚部的和。虚数是虚数单位（`-1` 的平方根）的实倍数，通常在数学中写为 `i`，在工程学中写为 `j`。Python 内置了对复数的支持，采用工程学标记方式；虚部带有一个 `j` 后缀，例如 `3+1j`。如果需要 [`math`](library/math.xhtml#module-math "math: Mathematical functions (sin() etc.).") 模块内对象的对应复数版本，请使用 [`cmath`](library/cmath.xhtml#module-cmath "cmath: Mathematical functions for complex numbers.")，复数的使用是一个比较高级的数学特性。如果你感觉没有必要，忽略它们也几乎不会有任何问题。
context manager -- 上下文管理器在 [`with`](reference/compound_stmts.xhtml#with) 语句中使用，通过定义 [`__enter__()`](reference/datamodel.xhtml#object.__enter__ "object.__enter__") 和 [`__exit__()`](reference/datamodel.xhtml#object.__exit__ "object.__exit__") 方法来控制环境状态的对象。参见 [**PEP 343**](https://www.python.org/dev/peps/pep-0343) \[https://www.python.org/dev/peps/pep-0343\]。
ntext variable A variable which can have different values depending on its context. This is similar to Thread-Local Storage in which each execution thread may have a different value for a variable. However, with context variables, there may be several contexts in one execution thread and the main usage for context variables is to keep track of variables in concurrent asynchronous tasks. See [`contextvars`](library/contextvars.xhtml#module-contextvars "contextvars: Context Variables").
contiguous -- 连续一个缓冲如果是 *C 连续* 或 *Fortran 连续* 就会被认为是连续的。零维缓冲是 C 和 Fortran 连续的。在一维数组中，所有条目必须在内存中彼此相邻地排列，采用从零开始的递增索引顺序。在多维 C-连续数组中，当按内存地址排列时用最后一个索引访问条目时速度最快。但是在 Fortran 连续数组中则是用第一个索引最快。
coroutine -- 协程协程是子例程的更一般形式。子例程可以在某一点进入并在另一点退出。协程则可以在许多不同的点上进入、退出和恢复。它们可通过 [`async def`](reference/compound_stmts.xhtml#async-def) 语句来实现。参见 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\]。
coroutine function -- 协程函数返回一个 [coroutine](#term-coroutine) 对象的函数。协程函数可通过 [`async def`](reference/compound_stmts.xhtml#async-def) 语句来定义，并可能包含 [`await`](reference/expressions.xhtml#await)、[`async for`](reference/compound_stmts.xhtml#async-for) 和 [`async with`](reference/compound_stmts.xhtml#async-with) 关键字。这些特性是由 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\] 引入的。
CPythonPython 编程语言的规范实现，在 [python.org](https://www.python.org) \[https://www.python.org\] 上发布。"CPython" 一词用于在必要时将此实现与其他实现例如 Jython 或 IronPython 相区别。
decorator -- 装饰器返回值为另一个函数的函数，通常使用 `@wrapper` 语法形式来进行函数变换。 装饰器的常见例子包括 [`classmethod()`](library/functions.xhtml#classmethod "classmethod") 和 [`staticmethod()`](library/functions.xhtml#staticmethod "staticmethod")。
装饰器语法只是一种语法糖，以下两个函数定义在语义上完全等价:
```
def f(...):
...
f = staticmethod(f)
@staticmethod
def f(...):
...
```
同的样概念也适用于类，但通常较少这样使用。有关装饰器的详情可参见 [函数定义](reference/compound_stmts.xhtml#function) 和 [类定义](reference/compound_stmts.xhtml#class) 的文档。
descriptor -- 描述器任何定义了 [`__get__()`](reference/datamodel.xhtml#object.__get__ "object.__get__"), [`__set__()`](reference/datamodel.xhtml#object.__set__ "object.__set__") 或 [`__delete__()`](reference/datamodel.xhtml#object.__delete__ "object.__delete__") 方法的对象。当一个类属性为描述器时，它的特殊绑定行为就会在属性查找时被触发。通常情况下，使用 *a.b* 来获取、设置或删除一个属性时会在 *a* 的类字典中查找名称为 *b* 的对象，但如果 *b* 是一个描述器，则会调用对应的描述器方法。理解描述器的概念是更深层次理解 Python 的关键，因为这是许多重要特性的基础，包括函数、方法、属性、类方法、静态方法以及对超类的引用等等。
有关描述符的方法的详情可参看 [实现描述器](reference/datamodel.xhtml#descriptors)。
dictionary -- 字典一个关联数组，其中的任意键都映射到相应的值。键可以是任何具有 [`__hash__()`](reference/datamodel.xhtml#object.__hash__ "object.__hash__") 和 [`__eq__()`](reference/datamodel.xhtml#object.__eq__ "object.__eq__") 方法的对象。在 Perl 语言中称为 hash。
dictionary view -- 字典视图从 [`dict.keys()`](library/stdtypes.xhtml#dict.keys "dict.keys"), [`dict.values()`](library/stdtypes.xhtml#dict.values "dict.values") 和 [`dict.items()`](library/stdtypes.xhtml#dict.items "dict.items") 返回的对象被称为字典视图。它们提供了字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。要将字典视图强制转换为真正的列表，可使用 `list(dictview)`。参见 [字典视图对象](library/stdtypes.xhtml#dict-views)。
docstring -- 文档字符串作为类、函数或模块之内的第一个表达式出现的字符串字面值。它在代码执行时会被忽略，但会被解释器识别并放入所在类、函数或模块的 `__doc__` 属性中。由于它可用于代码内省，因此是对象存放文档的规范位置。
duck-typing -- 鸭子类型指一种编程风格，它并不依靠查找对象类型来确定其是否具有正确的接口，而是直接调用或使用其方法或属性（“看起来像鸭子，叫起来也像鸭子，那么肯定就是鸭子。”）由于强调接口而非特定类型，设计良好的代码可通过允许多态替代来提升灵活性。鸭子类型避免使用 [`type()`](library/functions.xhtml#type "type") 或 [`isinstance()`](library/functions.xhtml#isinstance "isinstance") 检测。(但要注意鸭子类型可以使用 [抽象基类](#term-abstract-base-class) 作为补充。) 而往往会采用 [`hasattr()`](library/functions.xhtml#hasattr "hasattr") 检测或是 [EAFP](#term-eafp) 编程。
EAFP“求原谅比求许可更容易”的英文缩写。这种 Python 常用代码编写风格会假定所需的键或属性存在，并在假定错误时捕获异常。这种简洁快速风格的特点就是大量运用 [`try`](reference/compound_stmts.xhtml#try) 和 [`except`](reference/compound_stmts.xhtml#except) 语句。于其相对的则是所谓 [LBYL](#term-lbyl) 风格，常见于 C 等许多其他语言。
expression -- 表达式可以求出某个值的语法单元。 换句话说，一个表达式就是表达元素例如字面值、名称、属性访问、运算符或函数调用的汇总，它们最终都会返回一个值。 与许多其他语言不同，并非所有语言构件都是表达式。 还存在不能被用作表达式的 [statement](#term-statement)，例如 [`while`](reference/compound_stmts.xhtml#while)。 赋值也是属于语句而非表达式。
extension module -- 扩展模块以 C 或 C++ 编写的模块，使用 Python 的 C API 来与语言核心以及用户代码进行交互。
f-string -- f-字符串带有 `'f'` 或 `'F'` 前缀的字符串字面值通常被称为“f-字符串”即 [格式化字符串字面值](reference/lexical_analysis.xhtml#f-strings) 的简写。参见 [**PEP 498**](https://www.python.org/dev/peps/pep-0498) \[https://www.python.org/dev/peps/pep-0498\]。
file object -- 文件对象对外提供面向文件 API 以使用下层资源的对象（带有 `read()` 或 `write()` 这样的方法）。根据其创建方式的不同，文件对象可以处理对真实磁盘文件，对其他类型存储，或是对通讯设备的访问（例如标准输入/输出、内存缓冲区、套接字、管道等等）。文件对象也被称为 *文件类对象* 或 *流*。
实际上共有三种类别的文件对象: 原始 [二进制文件](#term-binary-file), 缓冲 [二进制文件](#term-binary-file) 以及 [文本文件](#term-text-file)。它们的接口定义均在 [`io`](library/io.xhtml#module-io "io: Core tools for working with streams.") 模块中。创建文件对象的规范方式是使用 [`open()`](library/functions.xhtml#open "open") 函数。
file-like object -- 文件类对象[file object](#term-file-object) 的同义词。
finder -- 查找器一种会尝试查找被导入模块的 [loader](#term-loader) 的对象。
从 Python 3.3 起存在两种类型的查找器: [元路径查找器](#term-meta-path-finder) 配合 [`sys.meta_path`](library/sys.xhtml#sys.meta_path "sys.meta_path") 使用，以及 [path entry finders](#term-path-entry-finder) 配合 [`sys.path_hooks`](library/sys.xhtml#sys.path_hooks "sys.path_hooks") 使用。
更多详情可参见 [**PEP 302**](https://www.python.org/dev/peps/pep-0302) \[https://www.python.org/dev/peps/pep-0302\], [**PEP 420**](https://www.python.org/dev/peps/pep-0420) \[https://www.python.org/dev/peps/pep-0420\] 和 [**PEP 451**](https://www.python.org/dev/peps/pep-0451) \[https://www.python.org/dev/peps/pep-0451\]。
floor division -- 向下取整除法向下舍入到最接近的整数的数学除法。向下取整除法的运算符是 `//` 。例如，表达式 `11 // 4` 的计算结果是 `2` ，而与之相反的是浮点数的真正除法返回 `2.75` 。注意 `(-11) // 4` 会返回 `-3` 因为这是 `-2.75` *向下* 舍入得到的结果。见 [**PEP 238**](https://www.python.org/dev/peps/pep-0238) \[https://www.python.org/dev/peps/pep-0238\] 。
function -- 函数可以向调用者返回某个值的一组语句。还可以向其传入零个或多个 [参数](#term-argument) 并在函数体执行中被使用。另见 [parameter](#term-parameter), [method](#term-method) 和 [函数定义](reference/compound_stmts.xhtml#function) 等节。
function annotation -- 函数标注即针对函数形参或返回值的 [annotation](#term-annotation) 。
函数标注通常用于 [类型提示](#term-type-hint)：例如以下函数预期接受两个 [`int`](library/functions.xhtml#int "int") 参数并预期返回一个 [`int`](library/functions.xhtml#int "int") 值:
```
def sum_two_numbers(a: int, b: int) -> int:
return a + b
```
函数标注语法的详解见 [函数定义](reference/compound_stmts.xhtml#function) 一节。
请参看 [variable annotation](#term-variable-annotation) 和 [**PEP 484**](https://www.python.org/dev/peps/pep-0484) \[https://www.python.org/dev/peps/pep-0484\] 对此功能的描述。
\_\_future\_\_一种伪模块，可被程序员用来启用与当前解释器不兼容的新语言特性。
通过导入 [`__future__`](library/__future__.xhtml#module-__future__ "__future__: Future statement definitions") 模块并对其中的变量求值，你可以查看新特性何时首次加入语言以及何时成为默认:
```
>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
```
garbage collection -- 垃圾回收释放不再被使用的内存空间的过程。Python 是通过引用计数和一个能够检测和打破循环引用的循环垃圾回收器来执行垃圾回收的。可以使用 [`gc`](library/gc.xhtml#module-gc "gc: Interface to the cycle-detecting garbage collector.") 模块来控制垃圾回收器。
generator -- 生成器返回一个 [generator iterator](#term-generator-iterator) 的函数。它看起来很像普通函数，不同点在于其包含 [`yield`](reference/simple_stmts.xhtml#yield) 表达式以便产生一系列值供给 for-循环使用或是通过 [`next()`](library/functions.xhtml#next "next") 函数逐一获取。
通常是指生成器函数，但在某些情况下也可能是指 *生成器迭代器*。如果需要清楚表达具体含义，请使用全称以避免歧义。
generator iterator -- 生成器迭代器[generator](#term-generator) 函数所创建的对象。
每个 [`yield`](reference/simple_stmts.xhtml#yield) 会临时暂停处理，记住当前位置执行状态（包括局部变量和挂起的 try 语句）。当该 *生成器迭代器* 恢复时，它会从离开位置继续执行（这与每次调用都从新开始的普通函数差别很大）。
generator expression -- 生成器表达式返回一个迭代器的表达式。 它看起来很像普通表达式后面带有定义了一个循环变量、范围的 `for` 子句，以及一个可选的 `if` 子句。 以下复合表达式会为外层函数生成一系列值:
```
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
285
```
generic function -- 泛型函数为不同的类型实现相同操作的多个函数所组成的函数。在调用时会由调度算法来确定应该使用哪个实现。
另请参见 [single dispatch](#term-single-dispatch) 术语表条目、[`functools.singledispatch()`](library/functools.xhtml#functools.singledispatch "functools.singledispatch") 装饰器以及 [**PEP 443**](https://www.python.org/dev/peps/pep-0443) \[https://www.python.org/dev/peps/pep-0443\]。
GIL参见 [global interpreter lock](#term-global-interpreter-lock)。
global interpreter lock -- 全局解释器锁[CPython](#term-cpython) 解释器所采用的一种机制，它确保同一时刻只有一个线程在执行 Python [bytecode](#term-bytecode)。此机制通过设置对象模型（包括 [`dict`](library/stdtypes.xhtml#dict "dict") 等重要内置类型）针对并发访问的隐式安全简化了 CPython 实现。给整个解释器加锁使得解释器多线程运行更方便，其代价则是牺牲了在多处理器上的并行性。
不过，某些标准库或第三方库的扩展模块被设计为在执行计算密集型任务如压缩或哈希时释放 GIL。此外，在执行 I/O 操作时也总是会释放 GIL。
创建一个（以更精细粒度来锁定共享数据的）“自由线程”解释器的努力从未获得成功，因为这会牺牲在普通单处理器情况下的性能。据信克服这种性能问题的措施将导致实现变得更复杂，从而更难以维护。
hash-based pyc -- 基于哈希的 pyc使用对应源文件的哈希值而非最后修改时间来确定其有效性的字节码缓存文件。 参见 [已缓存字节码的失效](reference/import.xhtml#pyc-invalidation)。
hashable -- 可哈希一个对象的哈希值如果在其生命周期内绝不改变，就被称为 *可哈希* （它需要具有 [`__hash__()`](reference/datamodel.xhtml#object.__hash__ "object.__hash__") 方法），并可以同其他对象进行比较（它需要具有 [`__eq__()`](reference/datamodel.xhtml#object.__eq__ "object.__eq__") 方法）。可哈希对象必须具有相同的哈希值比较结果才会相同。
可哈希性使得对象能够作为字典键或集合成员使用，因为这些数据结构要在内部使用哈希值。
所有 Python 中的不可变内置对象都是可哈希的；可变容器（例如列表或字典）都不可哈希。用户定义类的实例对象默认是可哈希的。它们在比较时一定不相同（除非是与自己比较），它们的哈希值的生成基于其 [`id()`](library/functions.xhtml#id "id")。
IDLEPython 的 IDE，“集成开发与学习环境”的英文缩写。是 Python 标准发行版附带的基本编程器和解释器环境。
immutable -- 不可变具有固定值的对象。不可变对象包括数字、字符串和元组。这样的对象不能被改变。如果必须存储一个不同的值，则必须创建新的对象。它们在需要常量哈希值的地方起着重要作用，例如作为字典中的键。
import path -- 导入路径由多个位置（或 [路径条目](#term-path-entry)）组成的列表，会被模块的 [path based finder](#term-path-based-finder) 用来查找导入目标。在导入时，此位置列表通常来自 [`sys.path`](library/sys.xhtml#sys.path "sys.path")，但对次级包来说也可能来自上级包的 `__path__` 属性。
importing -- 导入令一个模块中的 Python 代码能为另一个模块中的 Python 代码所使用的过程。
importer -- 导入器查找并加载模块的对象；此对象既属于 [finder](#term-finder) 又属于 [loader](#term-loader)。
interactive -- 交互Python 带有一个交互式解释器，即你可以在解释器提示符后输入语句和表达式，立即执行并查看其结果。只需不带参数地启动 `python` 命令（也可以在你的计算机开始菜单中选择相应菜单项）。在测试新想法或检验模块和包的时候用这种方式会非常方便（请记得使用 `help(x)`）。
interpreted -- 解释型Python 一是种解释型语言，与之相对的是编译型语言，虽然两者的区别由于字节码编译器的存在而会有所模糊。这意味着源文件可以直接运行而不必显式地创建可执行文件再运行。解释型语言通常具有比编译型语言更短的开发/调试周期，但是其程序往往运行得更慢。参见 [interactive](#term-interactive)。
interpreter shutdown -- 解释器关闭当被要求关闭时，Python 解释器将进入一个特殊运行阶段并逐步释放所有已分配资源，例如模块和各种关键内部结构等。它还会多次调用 [垃圾回收器](#term-garbage-collection)。这会触发用户定义析构器或弱引用回调中的代码执行。在关闭阶段执行的代码可能会遇到各种异常，因为其所依赖的资源已不再有效（常见的例子有库模块或警告机制等）。
解释器需要关闭的主要原因有 `__main__` 模块或所运行的脚本已完成执行。
iterable -- 可迭代对象能够逐一返回其成员项的对象。可迭代对象的例子包括所有序列类型（例如 [`list`](library/stdtypes.xhtml#list "list")、[`str`](library/stdtypes.xhtml#str "str") 和 [`tuple`](library/stdtypes.xhtml#tuple "tuple")）以及某些非序列类型例如 [`dict`](library/stdtypes.xhtml#dict "dict")、[文件对象](#term-file-object) 以及定义了 [`__iter__()`](reference/datamodel.xhtml#object.__iter__ "object.__iter__") 方法或是实现了 [Sequence](#term-sequence) 语义的 [`__getitem__()`](reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 方法的任意自定义类对象。
可迭代对象被可用于 [`for`](reference/compound_stmts.xhtml#for) 循环以及许多其他需要一个序列的地方（[`zip()`](library/functions.xhtml#zip "zip")、[`map()`](library/functions.xhtml#map "map") ...）。当一个可迭代对象作为参数传给内置函数 [`iter()`](library/functions.xhtml#iter "iter") 时，它会返回该对象的迭代器。这种迭代器适用于对值集合的一次性遍历。在使用可迭代对象时，你通常不需要调用 [`iter()`](library/functions.xhtml#iter "iter") 或者自己处理迭代器对象。`for` 语句会为你自动处理那些操作，创建一个临时的未命名变量用来在循环期间保存迭代器。参见 [iterator](#term-iterator)、[sequence](#term-sequence) 以及 [generator](#term-generator)。
iterator -- 迭代器用来表示一连串数据流的对象。重复调用迭代器的 [`__next__()`](library/stdtypes.xhtml#iterator.__next__ "iterator.__next__") 方法（或将其传给内置函数 [`next()`](library/functions.xhtml#next "next")）将逐个返回流中的项。当没有数据可用时则将引发 [`StopIteration`](library/exceptions.xhtml#StopIteration "StopIteration") 异常。到这时迭代器对象中的数据项已耗尽，继续调用其 `__next__()` 方法只会再次引发 [`StopIteration`](library/exceptions.xhtml#StopIteration "StopIteration") 异常。迭代器必须具有 [`__iter__()`](reference/datamodel.xhtml#object.__iter__ "object.__iter__") 方法用来返回该迭代器对象自身，因此迭代器必定也是可迭代对象，可被用于其他可迭代对象适用的大部分场合。一个显著的例外是那些会多次重复访问迭代项的代码。容器对象（例如 [`list`](library/stdtypes.xhtml#list "list")）在你每次向其传入 [`iter()`](library/functions.xhtml#iter "iter") 函数或是在 [`for`](reference/compound_stmts.xhtml#for) 循环中使用它时都会产生一个新的迭代器。如果在此情况下你尝试用迭代器则会返回在之前迭代过程中被耗尽的同一迭代器对象，使其看起来就像是一个空容器。
更多信息可查看 [迭代器类型](library/stdtypes.xhtml#typeiter)。
key function -- 键函数键函数或称整理函数，是能够返回用于排序或排位的值的可调用对象。例如，[`locale.strxfrm()`](library/locale.xhtml#locale.strxfrm "locale.strxfrm") 可用于生成一个符合特定区域排序约定的排序键。
Python 中有许多工具都允许用键函数来控制元素的排位或分组方式。其中包括 [`min()`](library/functions.xhtml#min "min"), [`max()`](library/functions.xhtml#max "max"), [`sorted()`](library/functions.xhtml#sorted "sorted"), [`list.sort()`](library/stdtypes.xhtml#list.sort "list.sort"), [`heapq.merge()`](library/heapq.xhtml#heapq.merge "heapq.merge"), [`heapq.nsmallest()`](library/heapq.xhtml#heapq.nsmallest "heapq.nsmallest"), [`heapq.nlargest()`](library/heapq.xhtml#heapq.nlargest "heapq.nlargest") 以及 [`itertools.groupby()`](library/itertools.xhtml#itertools.groupby "itertools.groupby")。
要创建一个键函数有多种方式。例如，[`str.lower()`](library/stdtypes.xhtml#str.lower "str.lower") 方法可以用作忽略大小写排序的键函数。另外，键函数也可通过 [`lambda`](reference/expressions.xhtml#lambda) 表达式来创建，例如 `lambda r: (r[0], r[2])`。还有 [`operator`](library/operator.xhtml#module-operator "operator: Functions corresponding to the standard operators.") 模块提供了三个键函数构造器：[`attrgetter()`](library/operator.xhtml#operator.attrgetter "operator.attrgetter")、[`itemgetter()`](library/operator.xhtml#operator.itemgetter "operator.itemgetter") 和 [`methodcaller()`](library/operator.xhtml#operator.methodcaller "operator.methodcaller")。请查看 [如何排序](howto/sorting.xhtml#sortinghowto) 一节以获取创建和使用键函数的示例。
keyword argument -- 关键字参数参见 [argument](#term-argument)。
lambda由一个单独 [expression](#term-expression) 构成的匿名内联函数，表达式会在调用时被求值。创建 lambda 函数的句法为 `lambda [parameters]: expression`
LBYL“先查看后跳跃”的英文缩写。这种代码编写风格会在进行调用或查找之前显式地检查前提条件。此风格与 [EAFP](#term-eafp) 方式恰成对比，其特点是大量使用 [`if`](reference/compound_stmts.xhtml#if) 语句。
在多线程环境中，LBYL 方式会导致“查看”和“跳跃”之间发生条件竞争风险。例如，以下代码 `if key in mapping: return mapping[key]` 可能由于在检查操作之后其他线程从 *mapping* 中移除了 *key* 而出错。这种问题可通过加锁或使用 EAFP 方式来解决。
list -- 列表Python 内置的一种 [sequence](#term-sequence)。虽然名为列表，但更类似于其他语言中的数组而非链接列表，因为访问元素的时间复杂度为 O(1)。
list comprehension -- 列表推导式处理一个序列中的所有或部分元素并返回结果列表的一种紧凑写法。`result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]` 将生成一个 0 到 255 范围内的十六进制偶数对应字符串（0x..）的列表。其中 [`if`](reference/compound_stmts.xhtml#if) 子句是可选的，如果省略则 `range(256)` 中的所有元素都会被处理。
loader -- 加载器负责加载模块的对象。它必须定义名为 `load_module()` 的方法。加载器通常由一个 [finder](#term-finder) 返回。详情参见 [**PEP 302**](https://www.python.org/dev/peps/pep-0302) \[https://www.python.org/dev/peps/pep-0302\]，对于 [abstract base class](#term-abstract-base-class) 可参见 [`importlib.abc.Loader`](library/importlib.xhtml#importlib.abc.Loader "importlib.abc.Loader")。
magic method -- 魔术方法[special method](#term-special-method) 的非正式同义词 。
mapping -- 映射一种支持任意键查找并实现了 [`Mapping`](library/collections.abc.xhtml#collections.abc.Mapping "collections.abc.Mapping") 或 [`MutableMapping`](library/collections.abc.xhtml#collections.abc.MutableMapping "collections.abc.MutableMapping") [抽象基类](library/collections.abc.xhtml#collections-abstract-base-classes) 中所规定方法的容器对象。 此类对象的例子包括 [`dict`](library/stdtypes.xhtml#dict "dict"), [`collections.defaultdict`](library/collections.xhtml#collections.defaultdict "collections.defaultdict"), [`collections.OrderedDict`](library/collections.xhtml#collections.OrderedDict "collections.OrderedDict") 以及 [`collections.Counter`](library/collections.xhtml#collections.Counter "collections.Counter")。
meta path finder -- 元路径查找器[`sys.meta_path`](library/sys.xhtml#sys.meta_path "sys.meta_path") 的搜索所返回的 [finder](#term-finder)。元路径查找器与 [path entry finders](#term-path-entry-finder) 存在关联但并不相同。
请查看 [`importlib.abc.MetaPathFinder`](library/importlib.xhtml#importlib.abc.MetaPathFinder "importlib.abc.MetaPathFinder") 了解元路径查找器所实现的方法。
metaclass -- 元类一种用于创建类的类。类定义包含类名、类字典和基类列表。元类负责接受上述三个参数并创建相应的类。大部分面向对象的编程语言都会提供一个默认实现。Python 的特别之处在于可以创建自定义元类。大部分用户永远不需要这个工具，但当需要出现时，元类可提供强大而优雅的解决方案。它们已被用于记录属性访问日志、添加线程安全性、跟踪对象创建、实现单例，以及其他许多任务。
更多详情参见 [元类](reference/datamodel.xhtml#metaclasses)。
method -- 方法在类内部定义的函数。如果作为该类的实例的一个属性来调用，方法将会获取实例对象作为其第一个 [argument](#term-argument) (通常命名为 `self`)。参见 [function](#term-function) 和 [nested scope](#term-nested-scope)。
method resolution order -- 方法解析顺序方法解析顺序就是在查找成员时搜索全部基类所用的先后顺序。请查看 [Python 2.3 方法解析顺序](https://www.python.org/download/releases/2.3/mro/) \[https://www.python.org/download/releases/2.3/mro/\] 了解自 2.3 版起 Python 解析器所用相关算法的详情。
module -- 模块此对象是 Python 代码的一种组织单位。各模块具有独立的命名空间，可包含任意 Python 对象。模块可通过 [importing](#term-importing) 操作被加载到 Python 中。
另见 [package](#term-package)。
module spec -- 模块规格一个命名空间，其中包含用于加载模块的相关导入信息。是 [`importlib.machinery.ModuleSpec`](library/importlib.xhtml#importlib.machinery.ModuleSpec "importlib.machinery.ModuleSpec") 的实例。
MRO参见 [method resolution order](#term-method-resolution-order)。
mutable -- 可变可变对象可以在其 [`id()`](library/functions.xhtml#id "id") 保持固定的情况下改变其取值。另请参见 [immutable](#term-immutable)。
named tuple -- 具名元组任何类似元组的类，其中的可索引元素也能使用名称属性来访问。（例如，[`time.localtime()`](library/time.xhtml#time.localtime "time.localtime") 会返回一个类似元组的对象，其中的 *year* 既可以通过索引访问如 `t[0]` 也可以通过名称属性访问如 `t.tm_year`）。
具名元组可以是一个内置类型例如 [`time.struct_time`](library/time.xhtml#time.struct_time "time.struct_time")，也可以通过正规的类定义来创建。一个完备的具名元组还可以通过工厂函数 [`collections.namedtuple()`](library/collections.xhtml#collections.namedtuple "collections.namedtuple") 来创建。后面这种方式会自动提供一些额外特性，例如 `Employee(name='jones', title='programmer')` 这样的自包含文档表示形式。
namespace -- 命名空间命名空间是存放变量的场所。命名空间有局部、全局和内置的，还有对象中的嵌套命名空间（在方法之内）。命名空间通过防止命名冲突来支持模块化。例如，函数 [`builtins.open`](library/functions.xhtml#open "open") 与 [`os.open()`](library/os.xhtml#os.open "os.open") 可通过各自的命名空间来区分。命名空间还通过明确哪个模块实现那个函数来帮助提高可读性和可维护性。例如，[`random.seed()`](library/random.xhtml#random.seed "random.seed") 或 [`itertools.islice()`](library/itertools.xhtml#itertools.islice "itertools.islice") 这种写法明确了这些函数是由 [`random`](library/random.xhtml#module-random "random: Generate pseudo-random numbers with various common distributions.") 与 [`itertools`](library/itertools.xhtml#module-itertools "itertools: Functions creating iterators for efficient looping.") 模块分别实现的。
namespace package -- 命名空间包[**PEP 420**](https://www.python.org/dev/peps/pep-0420) \[https://www.python.org/dev/peps/pep-0420\] 所引入的一种仅被用作子包的容器的 [package](#term-package)，命名空间包可以没有实体表示物，其描述方式与 [regular package](#term-regular-package) 不同，因为它们没有 `__init__.py` 文件。
另可参见 [module](#term-module)。
nested scope -- 嵌套作用域在一个定义范围内引用变量的能力。例如，在另一函数之内定义的函数可以引用前者的变量。请注意嵌套作用域默认只对引用有效而对赋值无效。局部变量的读写都受限于最内层作用域。类似的，全局变量的读写则作用于全局命名空间。通过 [`nonlocal`](reference/simple_stmts.xhtml#nonlocal) 关键字可允许写入外层作用域。
new-style class -- 新式类对于目前已被应于所有类对象的类形式的旧称谓。在早先的 Python 版本中，只有新式类能够使用 Python 新增的更灵活特性，例如 [`__slots__`](reference/datamodel.xhtml#object.__slots__ "object.__slots__")、描述符、特征属性、[`__getattribute__()`](reference/datamodel.xhtml#object.__getattribute__ "object.__getattribute__")、类方法和静态方法等。
object -- 对象任何具有状态（属性或值）以及预定义行为（方法）的数据。object 也是任何 [new-style class](#term-new-style-class) 的最顶层基类名。
package -- 包一种可包含子模块或递归地包含子包的 Python [module](#term-module)。从技术上说，包是带有 `__path__` 属性的 Python 模块。
另参见 [regular package](#term-regular-package) 和 [namespace package](#term-namespace-package)。
parameter -- 形参[function](#term-function) （或方法）定义中的命名实体，它指定函数可以接受的一个 [argument](#term-argument) （或在某些情况下，多个实参）。有五种形参：
- *positional-or-keyword*：位置或关键字，指定一个可以作为 [位置参数](#term-argument) 传入也可以作为 [关键字参数](#term-argument) 传入的实参。这是默认的形参类型，例如下面的 *foo* 和 *bar*:
```
def func(foo, bar=None): ...
```
- *positional-only*：仅限位置，指定一个只能按位置传入的参数。Python 中没有定义仅限位置形参的语法。但是一些内置函数有仅限位置形参（比如 [`abs()`](library/functions.xhtml#abs "abs")）。
- *keyword-only*：仅限关键字，指定一个只能通过关键字传入的参数。仅限关键字形参可通过在函数定义的形参列表中包含单个可变位置形参或者在多个可变位置形参之前放一个 `*` 来定义，例如下面的 *kw\_only1* 和 *kw\_only2*:
```
def func(arg, *, kw_only1, kw_only2): ...
```
- *var-positional*：可变位置，指定可以提供由一个任意数量的位置参数构成的序列（附加在其他形参已接受的位置参数之后）。这种形参可通过在形参名称前加缀 `*` 来定义，例如下面的 *args*:
```
def func(*args, **kwargs): ...
```
- *var-keyword*：可变关键字，指定可以提供任意数量的关键字参数（附加在其他形参已接受的关键字参数之后）。这种形参可通过在形参名称前加缀 `**` 来定义，例如上面的 *kwargs*。
形参可以同时指定可选和必选参数，也可以为某些可选参数指定默认值。
另参见 [argument](#term-argument) 术语表条目、[参数与形参的区别](faq/programming.xhtml#faq-argument-vs-parameter) 中的常见问题、[`inspect.Parameter`](library/inspect.xhtml#inspect.Parameter "inspect.Parameter") 类、[函数定义](reference/compound_stmts.xhtml#function) 一节以及 [**PEP 362**](https://www.python.org/dev/peps/pep-0362) \[https://www.python.org/dev/peps/pep-0362\]。
path entry -- 路径入口[import path](#term-import-path) 中的一个单独位置，会被 [path based finder](#term-path-based-finder) 用来查找要导入的模块。
path entry finder -- 路径入口查找器任一可调用对象使用 [`sys.path_hooks`](library/sys.xhtml#sys.path_hooks "sys.path_hooks") (即 [path entry hook](#term-path-entry-hook)) 返回的 [finder](#term-finder)，此种对象能通过 [path entry](#term-path-entry) 来定位模块。
请参看 [`importlib.abc.PathEntryFinder`](library/importlib.xhtml#importlib.abc.PathEntryFinder "importlib.abc.PathEntryFinder") 以了解路径入口查找器所实现的各个方法。
path entry hook -- 路径入口钩子一种可调用对象，在知道如何查找特定 [path entry](#term-path-entry) 中的模块的情况下能够使用 `sys.path_hook` 列表返回一个 [path entry finder](#term-path-entry-finder)。
path based finder -- 基于路径的查找器默认的一种 [元路径查找器](#term-meta-path-finder)，可在一个 [import path](#term-import-path) 中查找模块。
path-like object -- 路径类对象代表一个文件系统路径的对象。类路径对象可以是一个表示路径的 [`str`](library/stdtypes.xhtml#str "str") 或者 [`bytes`](library/stdtypes.xhtml#bytes "bytes") 对象，还可以是一个实现了 [`os.PathLike`](library/os.xhtml#os.PathLike "os.PathLike") 协议的对象。一个支持 [`os.PathLike`](library/os.xhtml#os.PathLike "os.PathLike") 协议的对象可通过调用 [`os.fspath()`](library/os.xhtml#os.fspath "os.fspath") 函数转换为 [`str`](library/stdtypes.xhtml#str "str") 或者 [`bytes`](library/stdtypes.xhtml#bytes "bytes") 类型的文件系统路径；[`os.fsdecode()`](library/os.xhtml#os.fsdecode "os.fsdecode") 和 [`os.fsencode()`](library/os.xhtml#os.fsencode "os.fsencode") 可被分别用来确保获得 [`str`](library/stdtypes.xhtml#str "str") 或 [`bytes`](library/stdtypes.xhtml#bytes "bytes") 类型的结果。此对象是由 [**PEP 519**](https://www.python.org/dev/peps/pep-0519) \[https://www.python.org/dev/peps/pep-0519\] 引入的。
PEP“Python 增强提议”的英文缩写。一个 PEP 就是一份设计文档，用来向 Python 社区提供信息，或描述一个 Python 的新增特性及其进度或环境。PEP 应当提供精确的技术规格和所提议特性的原理说明。
PEP 应被作为提出主要新特性建议、收集社区对特定问题反馈以及为必须加入 Python 的设计决策编写文档的首选机制。PEP 的作者有责任在社区内部建立共识，并应将不同意见也记入文档。
参见 [**PEP 1**](https://www.python.org/dev/peps/pep-0001) \[https://www.python.org/dev/peps/pep-0001\]。
portion -- 部分构成一个命名空间包的单个目录内文件集合（也可能存放于一个 zip 文件内），具体定义见 [**PEP 420**](https://www.python.org/dev/peps/pep-0420) \[https://www.python.org/dev/peps/pep-0420\]。
positional argument -- 位置参数参见 [argument](#term-argument)。
provisional API -- 暂定 API暂定 API 是指被有意排除在标准库的向后兼容性保证之外的应用编程接口。虽然此类接口通常不会再有重大改变，但只要其被标记为暂定，就可能在核心开发者确定有必要的情况下进行向后不兼容的更改（甚至包括移除该接口）。此种更改并不会随意进行 -- 仅在 API 被加入之前未考虑到的严重基础性缺陷被发现时才可能会这样做。
即便是对暂定 API 来说，向后不兼容的更改也会被视为“最后的解决方案” —— 任何问题被确认时都会尽可能先尝试找到一种向后兼容的解决方案。
这种处理过程允许标准库持续不断地演进，不至于被有问题的长期性设计缺陷所困。详情见 [**PEP 411**](https://www.python.org/dev/peps/pep-0411) \[https://www.python.org/dev/peps/pep-0411\]。
provisional package -- 暂定包参见 [provisional API](#term-provisional-api)。
Python 3000Python 3.x 发布路线的昵称（这个名字在版本 3 的发布还遥遥无期的时候就已出现了）。有时也被缩写为“Py3k”。
Pythonic指一个思路或一段代码紧密遵循了 Python 语言最常用的风格和理念，而不是使用其他语言中通用的概念来实现代码。例如，Python 的常用风格是使用 [`for`](reference/compound_stmts.xhtml#for) 语句循环来遍历一个可迭代对象中的所有元素。许多其他语言没有这样的结构，因此不熟悉 Python 的人有时会选择使用一个数字计数器:
```
for i in range(len(food)):
print(food[i])
```
而相应的更简洁更 Pythonic 的方法是这样的:
```
for piece in food:
print(piece)
```
qualified name -- 限定名称一个以点号分隔的名称，显示从模块的全局作用域到该模块中定义的某个类、函数或方法的“路径”，相关定义见 [**PEP 3155**](https://www.python.org/dev/peps/pep-3155) \[https://www.python.org/dev/peps/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](#term-cpython) 实现的一个关键元素。[`sys`](library/sys.xhtml#module-sys "sys: Access system-specific parameters and functions.") 模块定义了一个 [`getrefcount()`](library/sys.xhtml#sys.getrefcount "sys.getrefcount") 函数，程序员可调用它来返回特定对象的引用计数。
regular package -- 正规包传统型的 [package](#term-package)，例如包含有一个 `__init__.py` 文件的目录。
另参见 [namespace package](#term-namespace-package)。
\_\_slots\_\_一种写在类内部的声明，通过预先声明实例属性等对象并移除实例字典来节省内存。虽然这种技巧很流行，但想要用好却并不容易，最好是只保留在少数情况下采用，例如极耗内存的应用程序，并且其中包含大量实例。
sequence -- 序列一种 [iterable](#term-iterable)，它支持通过 [`__getitem__()`](reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 特殊方法来使用整数索引进行高效的元素访问，并定义了一个返回序列长度的 [`__len__()`](reference/datamodel.xhtml#object.__len__ "object.__len__") 方法。内置的序列类型有 [`list`](library/stdtypes.xhtml#list "list")、[`str`](library/stdtypes.xhtml#str "str")、[`tuple`](library/stdtypes.xhtml#tuple "tuple") 和 [`bytes`](library/stdtypes.xhtml#bytes "bytes")。注意虽然 [`dict`](library/stdtypes.xhtml#dict "dict") 也支持 [`__getitem__()`](reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 和 [`__len__()`](reference/datamodel.xhtml#object.__len__ "object.__len__")，但它被认为属于映射而非序列，因为它查找时使用任意的 [immutable](#term-immutable) 键而非整数。
[`collections.abc.Sequence`](library/collections.abc.xhtml#collections.abc.Sequence "collections.abc.Sequence") 抽象基类定义了一个更丰富的接口，它超越了 [`__getitem__()`](reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 和 [`__len__()`](reference/datamodel.xhtml#object.__len__ "object.__len__")，添加了 `count()`, `index()`, [`__contains__()`](reference/datamodel.xhtml#object.__contains__ "object.__contains__") 和 [`__reversed__()`](reference/datamodel.xhtml#object.__reversed__ "object.__reversed__") 。 可以使用 `register()` 显式注册实现此扩展接口的类型。
single dispatch -- 单分派一种 [generic function](#term-generic-function) 分派形式，其实现是基于单个参数的类型来选择的。
slice -- 切片通常只包含了特定 [sequence](#term-sequence) 的一部分的对象。切片是通过使用下标标记来创建的，在 `[]` 中给出几个以冒号分隔的数字，例如 `variable_name[1:3:5]`。方括号（下标）标记在内部使用 [`slice`](library/functions.xhtml#slice "slice") 对象。
special method -- 特殊方法一种由 Python 隐式调用的方法，用来对某个类型执行特定操作例如相加等等。这种方法的名称的首尾都为双下划线。特殊方法的文档参见 [特殊方法名称](reference/datamodel.xhtml#specialnames)。
statement -- 语句语句是程序段（一个代码“块”）的组成单位。一条语句可以是一个 [expression](#term-expression) 或某个带有关键字的结构，例如 [`if`](reference/compound_stmts.xhtml#if)、[`while`](reference/compound_stmts.xhtml#while) 或 [`for`](reference/compound_stmts.xhtml#for)。
struct sequence -- 结构序列具有命名元素的元组。结构序列所暴露的接口类似于 [named tuple](#term-named-tuple)，其元素既可通过索引也可作为属性来访问。不过，它们没有任何具名元组的方法，例如 [`_make()`](library/collections.xhtml#collections.somenamedtuple._make "collections.somenamedtuple._make") 或 [`_asdict()`](library/collections.xhtml#collections.somenamedtuple._asdict "collections.somenamedtuple._asdict")。结构序列的例子包括 [`sys.float_info`](library/sys.xhtml#sys.float_info "sys.float_info") 以及 [`os.stat()`](library/os.xhtml#os.stat "os.stat") 的返回值。
text encoding -- 文本编码用于将Unicode字符串编码为字节串的编码器。
text file -- 文本文件一种能够读写 [`str`](library/stdtypes.xhtml#str "str") 对象的 [file object](#term-file-object)。通常一个文本文件实际是访问一个面向字节的数据流并自动处理 [text encoding](#term-text-encoding)。文本文件的例子包括以文本模式（`'r'` 或 `'w'`）打开的文件、[`sys.stdin`](library/sys.xhtml#sys.stdin "sys.stdin")、[`sys.stdout`](library/sys.xhtml#sys.stdout "sys.stdout") 以及 [`io.StringIO`](library/io.xhtml#io.StringIO "io.StringIO") 的实例。
另请参看 [binary file](#term-binary-file) 了解能够读写 [字节类对象](#term-bytes-like-object) 的文件对象。
triple-quoted string -- 三引号字符串首尾各带三个连续双引号（"）或者单引号（'）的字符串。它们在功能上与首尾各用一个引号标注的字符串没有什么不同，但是有多种用处。它们允许你在字符串内包含未经转义的单引号和双引号，并且可以跨越多行而无需使用连接符，在编写文档字符串时特别好用。
type -- 类型类型决定一个 Python 对象属于什么种类；每个对象都具有一种类型。要知道对象的类型，可以访问它的 [`__class__`](library/stdtypes.xhtml#instance.__class__ "instance.__class__") 属性，或是通过 `type(obj)` 来获取。
type alias -- 类型别名一个类型的同义词，创建方式是把类型赋值给特定的标识符。
类型别名的作用是简化 [类型提示](#term-type-hint)。例如:
```
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`](library/typing.xhtml#module-typing "typing: Support for type hints (see PEP 484).") 和 [**PEP 484**](https://www.python.org/dev/peps/pep-0484) \[https://www.python.org/dev/peps/pep-0484\]，其中有对此功能的详细描述。
type hint -- 类型提示[annotation](#term-annotation) 为变量、类属性、函数的形参或返回值指定预期的类型。
类型提示属于可选项，Python 不要求提供，但其可对静态类型分析工具起作用，并可协助 IDE 实现代码补全与重构。
全局变量、类属性和函数的类型提示可以使用 [`typing.get_type_hints()`](library/typing.xhtml#typing.get_type_hints "typing.get_type_hints") 来访问，但局部变量则不可以。
参见 [`typing`](library/typing.xhtml#module-typing "typing: Support for type hints (see PEP 484).") 和 [**PEP 484**](https://www.python.org/dev/peps/pep-0484) \[https://www.python.org/dev/peps/pep-0484\]，其中有对此功能的详细描述。
universal newlines -- 通用换行一种解读文本流的方式，将以下所有符号都识别为行结束标志：Unix 的行结束约定 `'\n'`、Windows 的约定 `'\r\n'` 以及旧版 Macintosh 的约定 `'\r'`。参见 [**PEP 278**](https://www.python.org/dev/peps/pep-0278) \[https://www.python.org/dev/peps/pep-0278\] 和 [**PEP 3116**](https://www.python.org/dev/peps/pep-3116) \[https://www.python.org/dev/peps/pep-3116\] 和 [`bytes.splitlines()`](library/stdtypes.xhtml#bytes.splitlines "bytes.splitlines") 了解更多用法说明。
variable annotation -- 变量标注对变量或类属性的 [annotation](#term-annotation)。
在标注变量或类属性时，还可选择为其赋值:
```
class C:
field: 'annotation'
```
变量标注通常被用作 [类型提示](#term-type-hint)：例如以下变量预期接受 [`int`](library/functions.xhtml#int "int") 类型的值:
```
count: int = 0
```
变量标注语法的详细解释见 [带标注的赋值语句](reference/simple_stmts.xhtml#annassign) 一节。
请参看 [function annotation](#term-function-annotation)、[**PEP 484**](https://www.python.org/dev/peps/pep-0484) \[https://www.python.org/dev/peps/pep-0484\] 和 [**PEP 526**](https://www.python.org/dev/peps/pep-0526) \[https://www.python.org/dev/peps/pep-0526\]，其中对此功能有详细描述。
virtual environment -- 虚拟环境一种采用协作式隔离的运行时环境，允许 Python 用户和应用程序在安装和升级 Python 分发包时不会干扰到同一系统上运行的其他 Python 应用程序的行为。
另参见 [`venv`](library/venv.xhtml#module-venv "venv: Creation of virtual environments.")。
virtual machine -- 虚拟机一台完全通过软件定义的计算机。Python 虚拟机可执行字节码编译器所生成的 [bytecode](#term-bytecode)。
Zen of Python -- Python 之禅列出 Python 设计的原则与哲学，有助于理解与使用这种语言。查看其具体内容可在交互模式提示符中输入 "`import this`"。
### 导航
- [索引](genindex.xhtml "总目录")
- [模块](py-modindex.xhtml "Python 模块索引") |
- [下一页](about.xhtml "文档说明") |
- [上一页](faq/installed.xhtml "“为什么我的电脑上安装了 Python ？”") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](index.xhtml) »
- $('.inline-search').show(0); |
© [版权所有](copyright.xhtml) 2001-2019, Python Software Foundation.
Python 软件基金会是一个非盈利组织。 [请捐助。](https://www.python.org/psf/donations/)
最后更新于 5月 21, 2019. [发现了问题](bugs.xhtml)？
使用[Sphinx](http://sphinx.pocoo.org/)1.8.4 创建。
- Python文档内容
- Python 有什么新变化？
- Python 3.7 有什么新变化
- 摘要 - 发布重点
- 新的特性
- 其他语言特性修改
- 新增模块
- 改进的模块
- C API 的改变
- 构建的改变
- 性能优化
- 其他 CPython 实现的改变
- 已弃用的 Python 行为
- 已弃用的 Python 模块、函数和方法
- 已弃用的 C API 函数和类型
- 平台支持的移除
- API 与特性的移除
- 移除的模块
- Windows 专属的改变
- 移植到 Python 3.7
- Python 3.7.1 中的重要变化
- Python 3.7.2 中的重要变化
- Python 3.6 有什么新变化A
- 摘要 - 发布重点
- 新的特性
- 其他语言特性修改
- 新增模块
- 改进的模块
- 性能优化
- Build and C API Changes
- 其他改进
- 弃用
- 移除
- 移植到Python 3.6
- Python 3.6.2 中的重要变化
- Python 3.6.4 中的重要变化
- Python 3.6.5 中的重要变化
- Python 3.6.7 中的重要变化
- Python 3.5 有什么新变化
- 摘要 - 发布重点
- 新的特性
- 其他语言特性修改
- 新增模块
- 改进的模块
- Other module-level changes
- 性能优化
- Build and C API Changes
- 弃用
- 移除
- Porting to Python 3.5
- Notable changes in Python 3.5.4
- What's New In Python 3.4
- 摘要 - 发布重点
- 新的特性
- 新增模块
- 改进的模块
- CPython Implementation Changes
- 弃用
- 移除
- Porting to Python 3.4
- Changed in 3.4.3
- What's New In Python 3.3
- 摘要 - 发布重点
- PEP 405: Virtual Environments
- PEP 420: Implicit Namespace Packages
- PEP 3118: New memoryview implementation and buffer protocol documentation
- PEP 393: Flexible String Representation
- PEP 397: Python Launcher for Windows
- PEP 3151: Reworking the OS and IO exception hierarchy
- PEP 380: Syntax for Delegating to a Subgenerator
- PEP 409: Suppressing exception context
- PEP 414: Explicit Unicode literals
- PEP 3155: Qualified name for classes and functions
- PEP 412: Key-Sharing Dictionary
- PEP 362: Function Signature Object
- PEP 421: Adding sys.implementation
- Using importlib as the Implementation of Import
- 其他语言特性修改
- A Finer-Grained Import Lock
- Builtin functions and types
- 新增模块
- 改进的模块
- 性能优化
- Build and C API Changes
- 弃用
- Porting to Python 3.3
- What's New In Python 3.2
- PEP 384: Defining a Stable ABI
- PEP 389: Argparse Command Line Parsing Module
- PEP 391: Dictionary Based Configuration for Logging
- PEP 3148: The concurrent.futures module
- PEP 3147: PYC Repository Directories
- PEP 3149: ABI Version Tagged .so Files
- PEP 3333: Python Web Server Gateway Interface v1.0.1
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- 多线程
- 性能优化
- Unicode
- Codecs
- 文档
- IDLE
- Code Repository
- Build and C API Changes
- Porting to Python 3.2
- What's New In Python 3.1
- PEP 372: Ordered Dictionaries
- PEP 378: Format Specifier for Thousands Separator
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- 性能优化
- IDLE
- Build and C API Changes
- Porting to Python 3.1
- What's New In Python 3.0
- Common Stumbling Blocks
- Overview Of Syntax Changes
- Changes Already Present In Python 2.6
- Library Changes
- PEP 3101: A New Approach To String Formatting
- Changes To Exceptions
- Miscellaneous Other Changes
- Build and C API Changes
- 性能
- Porting To Python 3.0
- What's New in Python 2.7
- The Future for Python 2.x
- Changes to the Handling of Deprecation Warnings
- Python 3.1 Features
- PEP 372: Adding an Ordered Dictionary to collections
- PEP 378: Format Specifier for Thousands Separator
- PEP 389: The argparse Module for Parsing Command Lines
- PEP 391: Dictionary-Based Configuration For Logging
- PEP 3106: Dictionary Views
- PEP 3137: The memoryview Object
- 其他语言特性修改
- New and Improved Modules
- Build and C API Changes
- Other Changes and Fixes
- Porting to Python 2.7
- New Features Added to Python 2.7 Maintenance Releases
- Acknowledgements
- Python 2.6 有什么新变化
- Python 3.0
- Changes to the Development Process
- PEP 343: The 'with' statement
- PEP 366: Explicit Relative Imports From a Main Module
- PEP 370: Per-user site-packages Directory
- PEP 371: The multiprocessing Package
- PEP 3101: Advanced String Formatting
- PEP 3105: print As a Function
- PEP 3110: Exception-Handling Changes
- PEP 3112: Byte Literals
- PEP 3116: New I/O Library
- PEP 3118: Revised Buffer Protocol
- PEP 3119: Abstract Base Classes
- PEP 3127: Integer Literal Support and Syntax
- PEP 3129: Class Decorators
- PEP 3141: A Type Hierarchy for Numbers
- 其他语言特性修改
- New and Improved Modules
- Deprecations and Removals
- Build and C API Changes
- Porting to Python 2.6
- Acknowledgements
- What's New in Python 2.5
- PEP 308: Conditional Expressions
- PEP 309: Partial Function Application
- PEP 314: Metadata for Python Software Packages v1.1
- PEP 328: Absolute and Relative Imports
- PEP 338: Executing Modules as Scripts
- PEP 341: Unified try/except/finally
- PEP 342: New Generator Features
- PEP 343: The 'with' statement
- PEP 352: Exceptions as New-Style Classes
- PEP 353: Using ssize_t as the index type
- PEP 357: The 'index' method
- 其他语言特性修改
- New, Improved, and Removed Modules
- Build and C API Changes
- Porting to Python 2.5
- Acknowledgements
- What's New in Python 2.4
- PEP 218: Built-In Set Objects
- PEP 237: Unifying Long Integers and Integers
- PEP 289: Generator Expressions
- PEP 292: Simpler String Substitutions
- PEP 318: Decorators for Functions and Methods
- PEP 322: Reverse Iteration
- PEP 324: New subprocess Module
- PEP 327: Decimal Data Type
- PEP 328: Multi-line Imports
- PEP 331: Locale-Independent Float/String Conversions
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- Build and C API Changes
- Porting to Python 2.4
- Acknowledgements
- What's New in Python 2.3
- PEP 218: A Standard Set Datatype
- PEP 255: Simple Generators
- PEP 263: Source Code Encodings
- PEP 273: Importing Modules from ZIP Archives
- PEP 277: Unicode file name support for Windows NT
- PEP 278: Universal Newline Support
- PEP 279: enumerate()
- PEP 282: The logging Package
- PEP 285: A Boolean Type
- PEP 293: Codec Error Handling Callbacks
- PEP 301: Package Index and Metadata for Distutils
- PEP 302: New Import Hooks
- PEP 305: Comma-separated Files
- PEP 307: Pickle Enhancements
- Extended Slices
- 其他语言特性修改
- New, Improved, and Deprecated Modules
- Pymalloc: A Specialized Object Allocator
- Build and C API Changes
- Other Changes and Fixes
- Porting to Python 2.3
- Acknowledgements
- What's New in Python 2.2
- 概述
- PEPs 252 and 253: Type and Class Changes
- PEP 234: Iterators
- PEP 255: Simple Generators
- PEP 237: Unifying Long Integers and Integers
- PEP 238: Changing the Division Operator
- Unicode Changes
- PEP 227: Nested Scopes
- New and Improved Modules
- Interpreter Changes and Fixes
- Other Changes and Fixes
- Acknowledgements
- What's New in Python 2.1
- 概述
- PEP 227: Nested Scopes
- PEP 236: future Directives
- PEP 207: Rich Comparisons
- PEP 230: Warning Framework
- PEP 229: New Build System
- PEP 205: Weak References
- PEP 232: Function Attributes
- PEP 235: Importing Modules on Case-Insensitive Platforms
- PEP 217: Interactive Display Hook
- PEP 208: New Coercion Model
- PEP 241: Metadata in Python Packages
- New and Improved Modules
- Other Changes and Fixes
- Acknowledgements
- What's New in Python 2.0
- 概述
- What About Python 1.6?
- New Development Process
- Unicode
- 列表推导式
- Augmented Assignment
- 字符串的方法
- Garbage Collection of Cycles
- Other Core Changes
- Porting to 2.0
- Extending/Embedding Changes
- Distutils: Making Modules Easy to Install
- XML Modules
- Module changes
- New modules
- IDLE Improvements
- Deleted and Deprecated Modules
- Acknowledgements
- 更新日志
- Python 下一版
- Python 3.7.3 最终版
- Python 3.7.3 发布候选版 1
- Python 3.7.2 最终版
- Python 3.7.2 发布候选版 1
- Python 3.7.1 最终版
- Python 3.7.1 RC 2版本
- Python 3.7.1 发布候选版 1
- Python 3.7.0 正式版
- Python 3.7.0 release candidate 1
- Python 3.7.0 beta 5
- Python 3.7.0 beta 4
- Python 3.7.0 beta 3
- Python 3.7.0 beta 2
- Python 3.7.0 beta 1
- Python 3.7.0 alpha 4
- Python 3.7.0 alpha 3
- Python 3.7.0 alpha 2
- Python 3.7.0 alpha 1
- Python 3.6.6 final
- Python 3.6.6 RC 1
- Python 3.6.5 final
- Python 3.6.5 release candidate 1
- Python 3.6.4 final
- Python 3.6.4 release candidate 1
- Python 3.6.3 final
- Python 3.6.3 release candidate 1
- Python 3.6.2 final
- Python 3.6.2 release candidate 2
- Python 3.6.2 release candidate 1
- Python 3.6.1 final
- Python 3.6.1 release candidate 1
- Python 3.6.0 final
- Python 3.6.0 release candidate 2
- Python 3.6.0 release candidate 1
- Python 3.6.0 beta 4
- Python 3.6.0 beta 3
- Python 3.6.0 beta 2
- Python 3.6.0 beta 1
- Python 3.6.0 alpha 4
- Python 3.6.0 alpha 3
- Python 3.6.0 alpha 2
- Python 3.6.0 alpha 1
- Python 3.5.5 final
- Python 3.5.5 release candidate 1
- Python 3.5.4 final
- Python 3.5.4 release candidate 1
- Python 3.5.3 final
- Python 3.5.3 release candidate 1
- Python 3.5.2 final
- Python 3.5.2 release candidate 1
- Python 3.5.1 final
- Python 3.5.1 release candidate 1
- Python 3.5.0 final
- Python 3.5.0 release candidate 4
- Python 3.5.0 release candidate 3
- Python 3.5.0 release candidate 2
- Python 3.5.0 release candidate 1
- Python 3.5.0 beta 4
- Python 3.5.0 beta 3
- Python 3.5.0 beta 2
- Python 3.5.0 beta 1
- Python 3.5.0 alpha 4
- Python 3.5.0 alpha 3
- Python 3.5.0 alpha 2
- Python 3.5.0 alpha 1
- Python 教程
- 课前甜点
- 使用 Python 解释器
- 调用解释器
- 解释器的运行环境
- Python 的非正式介绍
- Python 作为计算器使用
- 走向编程的第一步
- 其他流程控制工具
- if 语句
- for 语句
- range() 函数
- break 和 continue 语句，以及循环中的 else 子句
- pass 语句
- 定义函数
- 函数定义的更多形式
- 小插曲：编码风格
- 数据结构
- 列表的更多特性
- del 语句
- 元组和序列
- 集合
- 字典
- 循环的技巧
- 深入条件控制
- 序列和其它类型的比较
- 模块
- 有关模块的更多信息
- 标准模块
- dir() 函数
- 包
- 输入输出
- 更漂亮的输出格式
- 读写文件
- 错误和异常
- 语法错误
- 异常
- 处理异常
- 抛出异常
- 用户自定义异常
- 定义清理操作
- 预定义的清理操作
- 类
- 名称和对象
- Python 作用域和命名空间
- 初探类
- 补充说明
- 继承
- 私有变量
- 杂项说明
- 迭代器
- 生成器
- 生成器表达式
- 标准库简介
- 操作系统接口
- 文件通配符
- 命令行参数
- 错误输出重定向和程序终止
- 字符串模式匹配
- 数学
- 互联网访问
- 日期和时间
- 数据压缩
- 性能测量
- 质量控制
- 自带电池
- 标准库简介 —— 第二部分
- 格式化输出
- 模板
- 使用二进制数据记录格式
- 多线程
- 日志
- 弱引用
- 用于操作列表的工具
- 十进制浮点运算
- 虚拟环境和包
- 概述
- 创建虚拟环境
- 使用pip管理包
- 接下来？
- 交互式编辑和编辑历史
- Tab 补全和编辑历史
- 默认交互式解释器的替代品
- 浮点算术：争议和限制
- 表示性错误
- 附录
- 交互模式
- 安装和使用 Python
- 命令行与环境
- 命令行
- 环境变量
- 在Unix平台中使用Python
- 获取最新版本的Python
- 构建Python
- 与Python相关的路径和文件
- 杂项
- 编辑器和集成开发环境
- 在Windows上使用 Python
- 完整安装程序
- Microsoft Store包
- nuget.org 安装包
- 可嵌入的包
- 替代捆绑包
- 配置Python
- 适用于Windows的Python启动器
- 查找模块
- 附加模块
- 在Windows上编译Python
- 其他平台
- 在苹果系统上使用 Python
- 获取和安装 MacPython
- IDE
- 安装额外的 Python 包
- Mac 上的图形界面编程
- 在 Mac 上分发 Python 应用程序
- 其他资源
- Python 语言参考
- 概述
- 其他实现
- 标注
- 词法分析
- 行结构
- 其他形符
- 标识符和关键字
- 字面值
- 运算符
- 分隔符
- 数据模型
- 对象、值与类型
- 标准类型层级结构
- 特殊方法名称
- 协程
- 执行模型
- 程序的结构
- 命名与绑定
- 异常
- 导入系统
- importlib
- 包
- 搜索
- 加载
- 基于路径的查找器
- 替换标准导入系统
- Package Relative Imports
- 有关 main 的特殊事项
- 开放问题项
- 参考文献
- 表达式
- 算术转换
- 原子
- 原型
- await 表达式
- 幂运算符
- 一元算术和位运算
- 二元算术运算符
- 移位运算
- 二元位运算
- 比较运算
- 布尔运算
- 条件表达式
- lambda 表达式
- 表达式列表
- 求值顺序
- 运算符优先级
- 简单语句
- 表达式语句
- 赋值语句
- assert 语句
- pass 语句
- del 语句
- return 语句
- yield 语句
- raise 语句
- break 语句
- continue 语句
- import 语句
- global 语句
- nonlocal 语句
- 复合语句
- if 语句
- while 语句
- for 语句
- try 语句
- with 语句
- 函数定义
- 类定义
- 协程
- 最高层级组件
- 完整的 Python 程序
- 文件输入
- 交互式输入
- 表达式输入
- 完整的语法规范
- Python 标准库
- 概述
- 可用性注释
- 内置函数
- 内置常量
- 由 site 模块添加的常量
- 内置类型
- 逻辑值检测
- 布尔运算 — and, or, not
- 比较
- 数字类型 — int, float, complex
- 迭代器类型
- 序列类型 — list, tuple, range
- 文本序列类型 — str
- 二进制序列类型 — bytes, bytearray, memoryview
- 集合类型 — set, frozenset
- 映射类型 — dict
- 上下文管理器类型
- 其他内置类型
- 特殊属性
- 内置异常
- 基类
- 具体异常
- 警告
- 异常层次结构
- 文本处理服务
- string — 常见的字符串操作
- re — 正则表达式操作
- 模块 difflib 是一个计算差异的助手
- textwrap — Text wrapping and filling
- unicodedata — Unicode 数据库
- stringprep — Internet String Preparation
- readline — GNU readline interface
- rlcompleter — GNU readline的完成函数
- 二进制数据服务
- struct — Interpret bytes as packed binary data
- codecs — Codec registry and base classes
- 数据类型
- datetime — 基础日期/时间数据类型
- calendar — General calendar-related functions
- collections — 容器数据类型
- collections.abc — 容器的抽象基类
- heapq — 堆队列算法
- bisect — Array bisection algorithm
- array — Efficient arrays of numeric values
- weakref — 弱引用
- types — Dynamic type creation and names for built-in types
- copy — 浅层 (shallow) 和深层 (deep) 复制操作
- pprint — 数据美化输出
- reprlib — Alternate repr() implementation
- enum — Support for enumerations
- 数字和数学模块
- numbers — 数字的抽象基类
- math — 数学函数
- cmath — Mathematical functions for complex numbers
- decimal — 十进制定点和浮点运算
- fractions — 分数
- random — 生成伪随机数
- statistics — Mathematical statistics functions
- 函数式编程模块
- itertools — 为高效循环而创建迭代器的函数
- functools — 高阶函数和可调用对象上的操作
- operator — 标准运算符替代函数
- 文件和目录访问
- pathlib — 面向对象的文件系统路径
- os.path — 常见路径操作
- fileinput — Iterate over lines from multiple input streams
- stat — Interpreting stat() results
- filecmp — File and Directory Comparisons
- tempfile — Generate temporary files and directories
- glob — Unix style pathname pattern expansion
- fnmatch — Unix filename pattern matching
- linecache — Random access to text lines
- shutil — High-level file operations
- macpath — Mac OS 9 路径操作函数
- 数据持久化
- pickle —— Python 对象序列化
- copyreg — Register pickle support functions
- shelve — Python object persistence
- marshal — Internal Python object serialization
- dbm — Interfaces to Unix “databases”
- sqlite3 — SQLite 数据库 DB-API 2.0 接口模块
- 数据压缩和存档
- zlib — 与 gzip 兼容的压缩
- gzip — 对 gzip 格式的支持
- bz2 — 对 bzip2 压缩算法的支持
- lzma — 用 LZMA 算法压缩
- zipfile — 在 ZIP 归档中工作
- tarfile — Read and write tar archive files
- 文件格式
- csv — CSV 文件读写
- configparser — Configuration file parser
- netrc — netrc file processing
- xdrlib — Encode and decode XDR data
- plistlib — Generate and parse Mac OS X .plist files
- 加密服务
- hashlib — 安全哈希与消息摘要
- hmac — 基于密钥的消息验证
- secrets — Generate secure random numbers for managing secrets
- 通用操作系统服务
- os — 操作系统接口模块
- io — 处理流的核心工具
- time — 时间的访问和转换
- argparse — 命令行选项、参数和子命令解析器
- getopt — C-style parser for command line options
- 模块 logging — Python 的日志记录工具
- logging.config — 日志记录配置
- logging.handlers — Logging handlers
- getpass — 便携式密码输入工具
- curses — 终端字符单元显示的处理
- curses.textpad — Text input widget for curses programs
- curses.ascii — Utilities for ASCII characters
- curses.panel — A panel stack extension for curses
- platform — Access to underlying platform's identifying data
- errno — Standard errno system symbols
- ctypes — Python 的外部函数库
- 并发执行
- threading — 基于线程的并行
- multiprocessing — 基于进程的并行
- concurrent 包
- concurrent.futures — 启动并行任务
- subprocess — 子进程管理
- sched — 事件调度器
- queue — 一个同步的队列类
- _thread — 底层多线程 API
- _dummy_thread — _thread 的替代模块
- dummy_threading — 可直接替代 threading 模块。
- contextvars — Context Variables
- Context Variables
- Manual Context Management
- asyncio support
- 网络和进程间通信
- asyncio — 异步 I/O
- socket — 底层网络接口
- ssl — TLS/SSL wrapper for socket objects
- select — Waiting for I/O completion
- selectors — 高级 I/O 复用库
- asyncore — 异步socket处理器
- asynchat — 异步 socket 指令/响应 处理器
- signal — Set handlers for asynchronous events
- mmap — Memory-mapped file support
- 互联网数据处理
- email — 电子邮件与 MIME 处理包
- json — JSON 编码和解码器
- mailcap — Mailcap file handling
- mailbox — Manipulate mailboxes in various formats
- mimetypes — Map filenames to MIME types
- base64 — Base16, Base32, Base64, Base85 数据编码
- binhex — 对binhex4文件进行编码和解码
- binascii — 二进制和 ASCII 码互转
- quopri — Encode and decode MIME quoted-printable data
- uu — Encode and decode uuencode files
- 结构化标记处理工具
- html — 超文本标记语言支持
- html.parser — 简单的 HTML 和 XHTML 解析器
- html.entities — HTML 一般实体的定义
- XML处理模块
- xml.etree.ElementTree — The ElementTree XML API
- xml.dom — The Document Object Model API
- xml.dom.minidom — Minimal DOM implementation
- xml.dom.pulldom — Support for building partial DOM trees
- xml.sax — Support for SAX2 parsers
- xml.sax.handler — Base classes for SAX handlers
- xml.sax.saxutils — SAX Utilities
- xml.sax.xmlreader — Interface for XML parsers
- xml.parsers.expat — Fast XML parsing using Expat
- 互联网协议和支持
- webbrowser — 方便的Web浏览器控制器
- cgi — Common Gateway Interface support
- cgitb — Traceback manager for CGI scripts
- wsgiref — WSGI Utilities and Reference Implementation
- urllib — URL 处理模块
- urllib.request — 用于打开 URL 的可扩展库
- urllib.response — Response classes used by urllib
- urllib.parse — Parse URLs into components
- urllib.error — Exception classes raised by urllib.request
- urllib.robotparser — Parser for robots.txt
- http — HTTP 模块
- http.client — HTTP协议客户端
- ftplib — FTP protocol client
- poplib — POP3 protocol client
- imaplib — IMAP4 protocol client
- nntplib — NNTP protocol client
- smtplib —SMTP协议客户端
- smtpd — SMTP Server
- telnetlib — Telnet client
- uuid — UUID objects according to RFC 4122
- socketserver — A framework for network servers
- http.server — HTTP 服务器
- http.cookies — HTTP state management
- http.cookiejar — Cookie handling for HTTP clients
- xmlrpc — XMLRPC 服务端与客户端模块
- xmlrpc.client — XML-RPC client access
- xmlrpc.server — Basic XML-RPC servers
- ipaddress — IPv4/IPv6 manipulation library
- 多媒体服务
- audioop — Manipulate raw audio data
- aifc — Read and write AIFF and AIFC files
- sunau — 读写 Sun AU 文件
- wave — 读写WAV格式文件
- chunk — Read IFF chunked data
- colorsys — Conversions between color systems
- imghdr — 推测图像类型
- sndhdr — 推测声音文件的类型
- ossaudiodev — Access to OSS-compatible audio devices
- 国际化
- gettext — 多语种国际化服务
- locale — 国际化服务
- 程序框架
- turtle — 海龟绘图
- cmd — 支持面向行的命令解释器
- shlex — Simple lexical analysis
- Tk图形用户界面(GUI)
- tkinter — Tcl/Tk的Python接口
- tkinter.ttk — Tk themed widgets
- tkinter.tix — Extension widgets for Tk
- tkinter.scrolledtext — 滚动文字控件
- IDLE
- 其他图形用户界面（GUI）包
- 开发工具
- typing — 类型标注支持
- pydoc — Documentation generator and online help system
- doctest — Test interactive Python examples
- unittest — 单元测试框架
- unittest.mock — mock object library
- unittest.mock 上手指南
- 2to3 - 自动将 Python 2 代码转为 Python 3 代码
- test — Regression tests package for Python
- test.support — Utilities for the Python test suite
- test.support.script_helper — Utilities for the Python execution tests
- 调试和分析
- bdb — Debugger framework
- faulthandler — Dump the Python traceback
- pdb — The Python Debugger
- The Python Profilers
- timeit — 测量小代码片段的执行时间
- trace — Trace or track Python statement execution
- tracemalloc — Trace memory allocations
- 软件打包和分发
- distutils — 构建和安装 Python 模块
- ensurepip — Bootstrapping the pip installer
- venv — 创建虚拟环境
- zipapp — Manage executable Python zip archives
- Python运行时服务
- sys — 系统相关的参数和函数
- sysconfig — Provide access to Python's configuration information
- builtins — 内建对象
- main — 顶层脚本环境
- warnings — Warning control
- dataclasses — 数据类
- contextlib — Utilities for with-statement contexts
- abc — 抽象基类
- atexit — 退出处理器
- traceback — Print or retrieve a stack traceback
- future — Future 语句定义
- gc — 垃圾回收器接口
- inspect — 检查对象
- site — Site-specific configuration hook
- 自定义 Python 解释器
- code — Interpreter base classes
- codeop — Compile Python code
- 导入模块
- zipimport — Import modules from Zip archives
- pkgutil — Package extension utility
- modulefinder — 查找脚本使用的模块
- runpy — Locating and executing Python modules
- importlib — The implementation of import
- Python 语言服务
- parser — Access Python parse trees
- ast — 抽象语法树
- symtable — Access to the compiler's symbol tables
- symbol — 与 Python 解析树一起使用的常量
- token — 与Python解析树一起使用的常量
- keyword — 检验Python关键字
- tokenize — Tokenizer for Python source
- tabnanny — 模糊缩进检测
- pyclbr — Python class browser support
- py_compile — Compile Python source files
- compileall — Byte-compile Python libraries
- dis — Python 字节码反汇编器
- pickletools — Tools for pickle developers
- 杂项服务
- formatter — Generic output formatting
- Windows系统相关模块
- msilib — Read and write Microsoft Installer files
- msvcrt — Useful routines from the MS VC++ runtime
- winreg — Windows 注册表访问
- winsound — Sound-playing interface for Windows
- Unix 专有服务
- posix — The most common POSIX system calls
- pwd — 用户密码数据库
- spwd — The shadow password database
- grp — The group database
- crypt — Function to check Unix passwords
- termios — POSIX style tty control
- tty — 终端控制功能
- pty — Pseudo-terminal utilities
- fcntl — The fcntl and ioctl system calls
- pipes — Interface to shell pipelines
- resource — Resource usage information
- nis — Interface to Sun's NIS (Yellow Pages)
- Unix syslog 库例程
- 被取代的模块
- optparse — Parser for command line options
- imp — Access the import internals
- 未创建文档的模块
- 平台特定模块
- 扩展和嵌入 Python 解释器
- 推荐的第三方工具
- 不使用第三方工具创建扩展
- 使用 C 或 C++ 扩展 Python
- 自定义扩展类型：教程
- 定义扩展类型：已分类主题
- 构建C/C++扩展
- 在Windows平台编译C和C++扩展
- 在更大的应用程序中嵌入 CPython 运行时
- Embedding Python in Another Application
- Python/C API 参考手册
- 概述
- 代码标准
- 包含文件
- 有用的宏
- 对象、类型和引用计数
- 异常
- 嵌入Python
- 调试构建
- 稳定的应用程序二进制接口
- The Very High Level Layer
- Reference Counting
- 异常处理
- Printing and clearing
- 抛出异常
- Issuing warnings
- Querying the error indicator
- Signal Handling
- Exception Classes
- Exception Objects
- Unicode Exception Objects
- Recursion Control
- 标准异常
- 标准警告类别
- 工具
- 操作系统实用程序
- 系统功能
- 过程控制
- 导入模块
- Data marshalling support
- 语句解释及变量编译
- 字符串转换与格式化
- 反射
- 编解码器注册与支持功能
- 抽象对象层
- Object Protocol
- 数字协议
- Sequence Protocol
- Mapping Protocol
- 迭代器协议
- 缓冲协议
- Old Buffer Protocol
- 具体的对象层
- 基本对象
- 数值对象
- 序列对象
- 容器对象
- 函数对象
- 其他对象
- Initialization, Finalization, and Threads
- 在Python初始化之前
- 全局配置变量
- Initializing and finalizing the interpreter
- Process-wide parameters
- Thread State and the Global Interpreter Lock
- Sub-interpreter support
- Asynchronous Notifications
- Profiling and Tracing
- Advanced Debugger Support
- Thread Local Storage Support
- 内存管理
- 概述
- 原始内存接口
- Memory Interface
- 对象分配器
- 默认内存分配器
- Customize Memory Allocators
- The pymalloc allocator
- tracemalloc C API
- 示例
- 对象实现支持
- 在堆中分配对象
- Common Object Structures
- Type 对象
- Number Object Structures
- Mapping Object Structures
- Sequence Object Structures
- Buffer Object Structures
- Async Object Structures
- 使对象类型支持循环垃圾回收
- API 和 ABI 版本管理
- 分发 Python 模块
- 关键术语
- 开源许可与协作
- 安装工具
- 阅读指南
- 我该如何...？
- ...为我的项目选择一个名字？
- ...创建和分发二进制扩展？
- 安装 Python 模块
- 关键术语
- 基本使用
- 我应如何 ...？
- ... 在 Python 3.4 之前的 Python 版本中安装 pip ？
- ... 只为当前用户安装软件包？
- ... 安装科学计算类 Python 软件包？
- ... 使用并行安装的多个 Python 版本？
- 常见的安装问题
- 在 Linux 的系统 Python 版本上安装
- 未安装 pip
- 安装二进制编译扩展
- Python 常用指引
- 将 Python 2 代码迁移到 Python 3
- 简要说明
- 详情
- 将扩展模块移植到 Python 3
- 条件编译
- 对象API的更改
- 模块初始化和状态
- CObject 替换为 Capsule
- 其他选项
- Curses Programming with Python
- What is curses?
- Starting and ending a curses application
- Windows and Pads
- Displaying Text
- User Input
- For More Information
- 实现描述器
- 摘要
- 定义和简介
- 描述器协议
- 发起调用描述符
- 描述符示例
- Properties
- 函数和方法
- Static Methods and Class Methods
- 函数式编程指引
- 概述
- 迭代器
- 生成器表达式和列表推导式
- 生成器
- 内置函数
- itertools 模块
- The functools module
- Small functions and the lambda expression
- Revision History and Acknowledgements
- 引用文献
- 日志 HOWTO
- 日志基础教程
- 进阶日志教程
- 日志级别
- 有用的处理程序
- 记录日志中引发的异常
- 使用任意对象作为消息
- 优化
- 日志操作手册
- 在多个模块中使用日志
- 在多线程中使用日志
- 使用多个日志处理器和多种格式化
- 在多个地方记录日志
- 日志服务器配置示例
- 处理日志处理器的阻塞
- Sending and receiving logging events across a network
- Adding contextual information to your logging output
- Logging to a single file from multiple processes
- Using file rotation
- Use of alternative formatting styles
- Customizing LogRecord
- Subclassing QueueHandler - a ZeroMQ example
- Subclassing QueueListener - a ZeroMQ example
- An example dictionary-based configuration
- Using a rotator and namer to customize log rotation processing
- A more elaborate multiprocessing example
- Inserting a BOM into messages sent to a SysLogHandler
- Implementing structured logging
- Customizing handlers with dictConfig()
- Using particular formatting styles throughout your application
- Configuring filters with dictConfig()
- Customized exception formatting
- Speaking logging messages
- Buffering logging messages and outputting them conditionally
- Formatting times using UTC (GMT) via configuration
- Using a context manager for selective logging
- 正则表达式HOWTO
- 概述
- 简单模式
- 使用正则表达式
- 更多模式能力
- 修改字符串
- 常见问题
- 反馈
- 套接字编程指南
- 套接字
- 创建套接字
- 使用一个套接字
- 断开连接
- 非阻塞的套接字
- 排序指南
- 基本排序
- 关键函数
- Operator 模块函数
- 升序和降序
- 排序稳定性和排序复杂度
- 使用装饰-排序-去装饰的旧方法
- 使用 cmp 参数的旧方法
- 其它
- Unicode 指南
- Unicode 概述
- Python's Unicode Support
- Reading and Writing Unicode Data
- Acknowledgements
- 如何使用urllib包获取网络资源
- 概述
- Fetching URLs
- 处理异常
- info and geturl
- Openers and Handlers
- Basic Authentication
- Proxies
- Sockets and Layers
- 脚注
- Argparse 教程
- 概念
- 基础
- 位置参数介绍
- Introducing Optional arguments
- Combining Positional and Optional arguments
- Getting a little more advanced
- Conclusion
- ipaddress模块介绍
- 创建 Address/Network/Interface 对象
- 审查 Address/Network/Interface 对象
- Network 作为 Address 列表
- 比较
- 将IP地址与其他模块一起使用
- 实例创建失败时获取更多详细信息
- Argument Clinic How-To
- The Goals Of Argument Clinic
- Basic Concepts And Usage
- Converting Your First Function
- Advanced Topics
- 使用 DTrace 和 SystemTap 检测CPython
- Enabling the static markers
- Static DTrace probes
- Static SystemTap markers
- Available static markers
- SystemTap Tapsets
- 示例
- Python 常见问题
- Python常见问题
- 一般信息
- 现实世界中的 Python
- 编程常见问题
- 一般问题
- 核心语言
- 数字和字符串
- 性能
- 序列（元组/列表）
- 对象
- 模块
- 设计和历史常见问题
- 为什么Python使用缩进来分组语句？
- 为什么简单的算术运算得到奇怪的结果？
- 为什么浮点计算不准确？
- 为什么Python字符串是不可变的？
- 为什么必须在方法定义和调用中显式使用“self”？
- 为什么不能在表达式中赋值？
- 为什么Python对某些功能（例如list.index()）使用方法来实现，而其他功能（例如len(List)）使用函数实现？
- 为什么 join()是一个字符串方法而不是列表或元组方法？
- 异常有多快？
- 为什么Python中没有switch或case语句？
- 难道不能在解释器中模拟线程，而非得依赖特定于操作系统的线程实现吗？
- 为什么lambda表达式不能包含语句？
- 可以将Python编译为机器代码，C或其他语言吗？
- Python如何管理内存？
- 为什么CPython不使用更传统的垃圾回收方案？
- CPython退出时为什么不释放所有内存？
- 为什么有单独的元组和列表数据类型？
- 列表是如何在CPython中实现的？
- 字典是如何在CPython中实现的？
- 为什么字典key必须是不可变的？
- 为什么 list.sort() 没有返回排序列表？
- 如何在Python中指定和实施接口规范？
- 为什么没有goto？
- 为什么原始字符串（r-strings）不能以反斜杠结尾？
- 为什么Python没有属性赋值的“with”语句？
- 为什么 if/while/def/class语句需要冒号？
- 为什么Python在列表和元组的末尾允许使用逗号？
- 代码库和插件 FAQ
- 通用的代码库问题
- 通用任务
- 线程相关
- 输入输出
- 网络 / Internet 编程
- 数据库
- 数学和数字
- 扩展/嵌入常见问题
- 可以使用C语言中创建自己的函数吗？
- 可以使用C++语言中创建自己的函数吗？
- C很难写，有没有其他选择？
- 如何从C执行任意Python语句？
- 如何从C中评估任意Python表达式？
- 如何从Python对象中提取C的值？
- 如何使用Py_BuildValue()创建任意长度的元组？
- 如何从C调用对象的方法？
- 如何捕获PyErr_Print()（或打印到stdout / stderr的任何内容）的输出？
- 如何从C访问用Python编写的模块？
- 如何从Python接口到C ++对象？
- 我使用Setup文件添加了一个模块，为什么make失败了？
- 如何调试扩展？
- 我想在Linux系统上编译一个Python模块，但是缺少一些文件。为什么?
- 如何区分“输入不完整”和“输入无效”？
- 如何找到未定义的g++符号__builtin_new或__pure_virtual？
- 能否创建一个对象类，其中部分方法在C中实现，而其他方法在Python中实现（例如通过继承）？
- Python在Windows上的常见问题
- 我怎样在Windows下运行一个Python程序？
- 我怎么让 Python 脚本可执行？
- 为什么有时候 Python 程序会启动缓慢？
- 我怎样使用Python脚本制作可执行文件？
- *.pyd 文件和DLL文件相同吗？
- 我怎样将Python嵌入一个Windows程序？
- 如何让编辑器不要在我的 Python 源代码中插入 tab ？
- 如何在不阻塞的情况下检查按键？
- 图形用户界面（GUI）常见问题
- 图形界面常见问题
- Python 是否有平台无关的图形界面工具包？
- 有哪些Python的GUI工具是某个平台专用的？
- 有关Tkinter的问题
- “为什么我的电脑上安装了 Python ？”
- 什么是Python？
- 为什么我的电脑上安装了 Python ？
- 我能删除 Python 吗？
- 术语对照表
- 文档说明
- Python 文档贡献者
- 解决 Bug
- 文档错误
- 使用 Python 的错误追踪系统
- 开始为 Python 贡献您的知识
- 版权
- 历史和许可证
- 软件历史
- 访问Python或以其他方式使用Python的条款和条件
- Python 3.7.3 的 PSF 许可协议
- Python 2.0 的 BeOpen.com 许可协议
- Python 1.6.1 的 CNRI 许可协议
- Python 0.9.0 至 1.2 的 CWI 许可协议
- 集成软件的许可和认可
- Mersenne Twister
- 套接字
- Asynchronous socket services
- Cookie management
- Execution tracing
- UUencode and UUdecode functions
- XML Remote Procedure Calls
- test_epoll
- Select kqueue
- SipHash24
- strtod and dtoa
- OpenSSL
- expat
- libffi
- zlib
- cfuhash
- libmpdec