词汇表

>>>

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

...

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

2对3

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

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

抽象基类

抽象基类通过提供一种定义接口的方法来补充 duck-typing，当其他技术如 hasattr() 会笨拙或微妙错误时（例如使用 magic methods ]）。 ABCs 引入了虚子类，它们是不从类继承但仍被 isinstance() 和 issubclass() 识别的类；请参阅 abc 模块文档。 Python 带有许多用于数据结构（在 collections 模块中）、数字（在 numbers 模块中）和流（在 io 模块中）的内置 ABC模块）。您可以使用 abc 模块创建自己的 ABC。

争论

调用函数时传递给函数（或方法）的值。有两种类型的参数：

关键字参数：前面有一个标识符的参数（例如 name=) 在函数调用中或作为值在以 ** 开头的字典中传递。例如，3 和 5 都是以下对 complex() 的调用中的关键字参数：
```
complex(real=3, imag=5)
complex(**{'real': 3, 'imag': 5})
```
位置参数：不是关键字参数的参数。位置参数可以出现在参数列表的开头和/或作为 iterable 前面有 * 的元素传递。例如，3 和 5 都是以下调用中的位置参数：
```
complex(3, 5)
complex(*(3, 5))
```

参数被分配给函数体中的命名局部变量。有关管理此分配的规则，请参阅 Calls 部分。从语法上讲，任何表达式都可以用来表示一个参数；评估值分配给局部变量。

另请参阅参数词汇表条目和有关参数和参数之间的区别的常见问题解答。

属性

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

BDFL

终生仁慈的独裁者，又名 Guido van Rossum，Python 的创造者。

类字节对象

支持缓冲协议的对象，如 str、bytearray 或 memoryview。类似字节的对象可用于各种需要二进制数据的操作，例如压缩、保存到二进制文件或通过套接字发送。某些操作需要二进制数据是可变的，在这种情况下，并非所有类似字节的对象都可以应用。

字节码

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

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

班级

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

经典课

任何不继承自 object 的类。参见新式类。 Python 3 中删除了经典类。

强迫

在涉及相同类型的两个参数的操作期间将一种类型的实例隐式转换为另一种类型。例如，int(3.15) 将浮点数转换为整数 3，但在 3+4.5 中，每个参数都是不同的类型（一个 int，一个 float），并且两者都是在添加它们之前必须转换为相同的类型，否则会引发 TypeError。可以使用 coerce 内置函数执行两个操作数之间的强制转换；因此，3+4.5 等效于调用 operator.add(*coerce(3, 4.5)) 并导致 operator.add(3.0, 4.5)。如果没有强制，即使兼容类型的所有参数都必须由程序员规范化为相同的值，例如，float(3)+4.5 而不仅仅是 3+4.5。

复数

熟悉的实数系统的扩展，其中所有数字都表示为实部和虚部之和。虚数是虚数单位（-1的平方根）的实数倍，数学上常写成i，工程上常写成j。 Python 内置了对复数的支持，复数是用后一种表示法编写的；虚部用 j 后缀表示，例如 3+1j。要访问 math 模块的复杂等效项，请使用 cmath。使用复数是一个相当高级的数学特征。如果您不知道对它们的需求，几乎可以肯定您可以安全地忽略它们。

上下文管理器

通过定义 __enter__() 和 __exit__() 方法来控制在 with 语句中看到的环境的对象。参见 PEP 343。

CPython

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

装饰师

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

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

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

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

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

描述符

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

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

字典

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

字典视图

从 dict.viewkeys()、dict.viewvalues() 和 dict.viewitems() 返回的对象称为字典视图。它们提供了字典条目的动态视图，这意味着当字典发生变化时，视图会反映这些变化。要强制字典视图成为完整列表，请使用 list(dictview)。请参阅字典视图对象。

文档字符串

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

鸭子打字

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

EAFP

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

表达

可以评估为某个值的一段语法。换句话说，表达式是表达式元素的累积，如文字、名称、属性访问、运算符或函数调用，它们都返回一个值。与许多其他语言相比，并非所有语言结构都是表达式。还有 statement 不能用作表达式，例如 print 或 if。赋值也是语句，而不是表达式。

扩展模块

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

文件对象

向底层资源公开面向文件的 API（使用 read() 或 write() 等方法）的对象。根据创建的方式，文件对象可以调解对真实磁盘文件或其他类型的存储或通信设备（例如标准输入/输出、内存缓冲区、套接字、管道等）的访问。 . 文件对象也称为 类文件对象 或流。

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

类文件对象

文件对象的同义词。

发现者

一个尝试为模块查找 loader 的对象。它必须实现一个名为 find_module() 的方法。有关详细信息，请参阅 PEP 302。

楼层划分

向下舍入到最接近的整数的数学除法。楼层划分算子是//。例如，与 float true 除法返回的 2.75 相比，表达式 11 // 4 的计算结果为 2。请注意，(-11) // 4 是 -3，因为它是 -2.75 向下舍入 '。参见 PEP 238。

功能

向调用者返回一些值的一系列语句。它还可以传递零个或多个参数，这些参数可用于主体的执行。另请参阅参数、方法和函数定义部分。

__未来__

一个伪模块，程序员可以使用它来启用与当前解释器不兼容的新语言功能。例如，表达式 11/4 当前计算为 2。如果执行它的模块通过执行启用了 真除法 ：

from __future__ import division

表达式 11/4 的计算结果为 2.75。通过导入 __future__ 模块并评估其变量，您可以查看新功能何时首次添加到语言中以及何时成为默认功能：

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

垃圾收集

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

发电机

一个返回迭代器的函数。它看起来像一个普通函数，除了它包含 yield 语句，用于生成一系列可用于 for 循环的值，或者可以使用 next() 一次检索一个值功能。每个 yield 暂时暂停处理，记住位置执行状态（包括局部变量和挂起的 try 语句）。当生成器恢复时，它从停止的地方开始（与每次调用都重新开始的函数相反）。

生成器表达式

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

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

吉尔吉斯斯坦

参见全局解释器锁。

全局解释器锁

CPython 解释器使用的机制来确保一次只有一个线程执行 Python bytecode。这通过使对象模型（包括关键的内置类型，如 dict）隐式安全地防止并发访问来简化 CPython 实现。锁定整个解释器使解释器更容易成为多线程，但代价是多处理器机器提供的大部分并行性。

但是，一些扩展模块，无论是标准的还是第三方的，都被设计为在执行压缩或散列等计算密集型任务时释放 GIL。此外，在执行 I/O 时始终会释放 GIL。

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

可散列的

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

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

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

空闲

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

不可变的

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

整数除法

数学除法丢弃任何余数。例如，与浮点除法返回的 2.75 相比，表达式 11/4 当前的计算结果为 2。也称为 地板分隔 。当两个整数相除时，结果将始终是另一个整数（应用了 floor 函数）。但是，如果其中一个操作数是另一种数字类型（例如 float），则结果将被强制转换（请参阅 coercion）为通用类型。例如，整数除以浮点数将产生浮点值，可能带有小数。可以使用 // 运算符代替 / 运算符来强制整数除法。另见 __future__。

输入

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

进口商

一个既可以查找又可以加载模块的对象； finder 和 loader 对象。

交互的

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

解释的

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

可迭代的

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

迭代器

表示数据流的对象。重复调用迭代器的 next() 方法会返回流中的连续项目。当没有更多数据可用时，会引发 StopIteration 异常。此时，迭代器对象已耗尽，任何对其 next() 方法的进一步调用只会再次引发 StopIteration。迭代器需要有一个 __iter__() 方法来返回迭代器对象本身，所以每个迭代器也是可迭代的，并且可以在大多数接受其他可迭代对象的地方使用。一个值得注意的例外是尝试多次迭代的代码。每次将容器对象（例如 list）传递给 iter() 函数或在 for 循环中使用它时，都会生成一个全新的迭代器。使用迭代器尝试这样做只会返回与前一次迭代中使用的相同的耗尽迭代器对象，使其看起来像一个空容器。

更多信息可以在迭代器类型中找到。

按键功能

键函数或排序函数是可调用的，它返回用于排序或排序的值。例如， locale.strxfrm() 用于生成一个排序键，该键可识别特定于语言环境的排序约定。

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

有多种方法可以创建键函数。例如。 str.lower() 方法可以作为不区分大小写排序的关键函数。或者，可以从 lambda 表达式（例如 lambda r: (r[0], r[2])）构建临时密钥函数。此外，operator 模块提供了三个关键的函数构造函数：attrgetter()、itemgetter() 和 methodcaller()。有关如何创建和使用关键函数的示例，请参阅 Sorting HOW TO。

关键字参数

请参阅参数。

拉姆达

由单个表达式组成的匿名内联函数，该函数在调用函数时进行计算。创建 lambda 函数的语法是 lambda [parameters]: expression

LBYL

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

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

列表

一个内置的 Python 序列。尽管它的名字，它更类似于其他语言中的数组而不是链表，因为对元素的访问是 O(1)。

列表理解

一种处理序列中全部或部分元素并返回包含结果的列表的紧凑方法。 result = ["0x%02x" % x for x in range(256) if x % 2 == 0] 生成一个字符串列表，其中包含 0 到 255 范围内的偶数十六进制数 (0x..)。 if 子句是可选的。如果省略，则处理 range(256) 中的所有元素。

装载机

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

魔法方法

特殊方法的非正式同义词。

映射

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

元类

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

更多信息可以在自定义类创建中找到。

方法

在类体内定义的函数。如果作为该类的实例的属性调用，则该方法将获取实例对象作为其第一个参数（通常称为 self）。请参阅函数和嵌套作用域。

方法解析顺序

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

模块

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

另见包。

维修保养办公室

参见方法解析顺序。

可变的

可变对象可以改变它们的值，但保持它们的 id()。另见不可变。

命名元组

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

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

命名空间

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

嵌套作用域

在封闭定义中引用变量的能力。例如，定义在另一个函数内部的函数可以引用外部函数中的变量。请注意，嵌套作用域仅用于引用，而不适用于始终写入最内部作用域的赋值。相比之下，局部变量在最内部的作用域中读写。同样，全局变量读写全局命名空间。

新式班

任何继承自 object 的类。这包括所有内置类型，如 list 和 dict。只有新样式的类才能使用 Python 更新的、通用的特性，如 __slots__、描述符、属性和 __getattribute__()。

更多信息可以在新式和经典类中找到。

目的

任何具有状态（属性或值）和定义的行为（方法）的数据。也是任何新式类的终极基类。

包裹

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

范围

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

positional-or-keyword：指定可以通过 positionally 或作为 keyword 参数传递的参数。这是默认的参数类型，例如下面的 foo 和 bar：
```
def func(foo, bar=None): ...
```
positional-only：指定只能由位置提供的参数。 Python 没有用于定义仅位置参数的语法。然而，一些内置函数只有位置参数（例如 abs())。
var-positional：指定可以提供任意位置参数序列（除了已经被其他参数接受的任何位置参数）。这样的参数可以通过在参数名称前加上 * 来定义，例如 args 如下：
```
def func(*args, **kwargs): ...
```
var-keyword：指定可以提供任意多个关键字参数（除了已经被其他参数接受的任何关键字参数）。这样的参数可以通过在参数名称前面加上 ** 来定义，例如上面例子中的 kwargs。

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

另请参阅参数词汇表条目、关于参数和参数之间的区别的常见问题解答以及函数定义部分。

政治公众人物

Python 增强建议。 PEP 是为 Python 社区提供信息或描述 Python 或其进程或环境的新功能的设计文档。 PEP 应提供简明的技术规范和建议功能的基本原理。

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

参见 PEP 1。

位置论证

请参阅参数。

蟒蛇 3000

Python 3.x 发布系列的昵称（很久以前创造的，当时版本 3 的发布是在遥远的未来。）这也缩写为“Py3k”。

蟒蛇式

紧跟 Python 语言最常见习语的想法或代码片段，而不是使用其他语言常见的概念来实现代码。例如，Python 中的一个常见习惯用法是使用 for 语句循环遍历可迭代对象的所有元素。许多其他语言没有这种类型的结构，所以不熟悉 Python 的人有时会使用数字计数器来代替：

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

与更干净的 Pythonic 方法相反：

for piece in food:
    print piece

引用计数

对象的引用次数。当一个对象的引用计数下降到零时，它被释放。引用计数通常对 Python 代码不可见，但它是 CPython 实现的关键元素。 sys 模块定义了一个 getrefcount() 函数，程序员可以调用该函数来返回特定对象的引用计数。

__插槽__

新式类中的声明，通过预先声明实例属性的空间并消除实例字典来节省内存。虽然很流行，但该技术很难正确使用，最好保留用于内存关键应用程序中存在大量实例的极少数情况。

顺序

一个 iterable 支持通过 __getitem__() 特殊方法使用整数索引进行有效元素访问，并定义了一个 len() 方法来返回序列的长度。一些内置序列类型是 list、str、tuple 和 unicode。请注意，dict 也支持 [X38X] 和 __len__()，但被视为映射而不是序列，因为查找使用任意 immutable 键而不是整数.

片

通常包含序列的一部分的对象。切片是使用下标表示法创建的，[] 在给出多个数字时在数字之间使用冒号，例如在 variable_name[1:3:5] 中。括号（下标）表示法在内部使用 slice 对象（或在旧版本中使用 __getslice__() 和 __setslice__()）。

特殊方法

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

陈述

语句是套件（代码“块”）的一部分。语句是表达式或几个带有关键字的结构之一，例如 if、while 或 for。

结构序列

具有命名元素的元组。结构序列公开了一个类似于命名元组的接口，其中元素可以通过索引或作为属性访问。但是，它们没有任何命名的元组方法，如 _make() 或 _asdict()。结构序列的示例包括 sys.float_info 和 os.stat() 的返回值。

三引号字符串

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

类型

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

通用换行符

一种解释文本流的方式，其中所有以下内容都被识别为行结束：Unix 行尾约定 '\n'、Windows 约定 '\r\n' 和旧的 Macintosh 约定 [ X211X]。请参阅 PEP 278 和 PEP 3116，以及 str.splitlines() 以了解其他用途。

虚拟环境

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

虚拟机

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

Python之禅

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

词汇表 — Python 文档

词汇表