### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](simple_stmts.xhtml "7. 简单语句") |
- [上一页](import.xhtml "5. 导入系统") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 语言参考](index.xhtml) »
- $('.inline-search').show(0); |
# 6. 表达式
本章将解释 Python 中组成表达式的各种元素的的含义。
**语法注释:** 在本章和后续章节中，会使用扩展 BNF 标注来描述语法而不是词法分析。 当（某种替代的）语法规则具有如下形式
```
name ::= `othername`
```
并且没有给出语义，则这种形式的 `name` 在语法上与 `othername` 相同。
## 6.1. 算术转换
当对下述某个算术运算符的描述中使用了“数值参数被转换为普通类型”这样的说法，这意味着内置类型的运算符实现采用了如下作用方式:
- 如果任一参数为复数，另一参数会被转换为复数；
- 否则，如果任一参数为浮点数，另一参数会被转换为浮点数；
- 否则，两者应该都为整数，不需要进行转换。
某些附加规则会作用于特定运算符（例如，字符串作为 '%' 运算符的左运算参数）。 扩展必须定义它们自己的转换行为。
## 6.2. 原子
“原子”指表达式的最基本构成元素。 最简单的原子是标识符和字面值。 以圆括号、方括号或花括号包括的形式在语法上也被归类为原子。 原子的句法为:
```
atom ::= identifier | literal | enclosure
enclosure ::= parenth_form | list_display | dict_display | set_display
| generator_expression | yield_atom
```
### 6.2.1. 标识符（名称）
作为原子出现的标识符叫做名称。 请参看 [标识符和关键字](lexical_analysis.xhtml#identifiers) 一节了解其词法定义，以及 [命名与绑定](executionmodel.xhtml#naming) 获取有关命名与绑定的文档。
当名称被绑定到一个对象时，对该原子求值将返回相应对象。 当名称未被绑定时，尝试对其求值将引发 [`NameError`](../library/exceptions.xhtml#NameError "NameError") 异常。
**私有名称转换:** 当以文本形式出现在类定义中的一个标识符以两个或更多下划线开头并且不以两个或更多下划线结尾，它会被视为该类的 *私有名称*。 私有名称会在为其生成代码之前被转换为一种更长的形式。 转换时会插入类名，移除打头的下划线再在名称前增加一个下划线。 例如，出现在一个名为 `Ham` 的类中的标识符 `__spam` 会被转换为 `_Ham__spam`。 这种转换独立于标识符所使用的相关句法。 如果转换后的名称太长（超过 255 个字符），可能发生由具体实现定义的截断。 如果类名仅由下划线组成，则不会进行转换。
### 6.2.2. 字面值
Python 支持字符串和字节串字面值，以及几种数字字面值:
```
literal ::= stringliteral | bytesliteral
| integer | floatnumber | imagnumber
```
对字面值求值将返回一个该值所对应类型的对象（字符串、字节串、整数、浮点数、复数）。 对于浮点数和虚数（复数）的情况，该值可能为近似值。 详情参见 [字面值](lexical_analysis.xhtml#literals)。
所有字面值都对应与不可变数据类型，因此对象标识的重要性不如其实际值。 多次对具有相同值的字面值求值（不论是发生在程序文本的相同位置还是不同位置）可能得到相同对象或是具有相同值的不同对象。
### 6.2.3. 带圆括号的形式
带圆括号的形式是包含在圆括号中的可选表达式列表。
```
parenth_form ::= "(" [starred_expression] ")"
```
带圆括号的表达式列表将返回该表达式列表所产生的任何东西：如果该列表包含至少一个逗号，它会产生一个元组；否则，它会产生该表达式列表所对应的单一表达式。
An empty pair of parentheses yields an empty tuple object. Since tuples are immutable, the same rules as for literals apply (i.e., two occurrences of the empty tuple may or may not yield the same object).
请注意元组并不是由圆括号构建，实际起作用的是逗号操作符。 例外情况是空元组，这时圆括号 *才是* 必须的 --- 允许在表达式中使用不带圆括号的 "空" 会导致歧义，并会造成常见输入错误无法被捕获。
### 6.2.4. 列表、集合与字典的显示
为了构建列表、集合或字典，Python 提供了名为“显示”的特殊句法，每个类型各有两种形式:
- 第一种是显式地列出容器内容
- 第二种是通过一组循环和筛选指令计算出来，称为 *推导式*。
推导式的常用句法元素为:
```
comprehension ::= expression comp_for
comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter ::= comp_for | comp_if
comp_if ::= "if" expression_nocond [comp_iter]
```
推导式的结构是一个单独表达式后面加至少一个 `for` 子句以及零个或更多个 `for` 或 `if` 子句。 在这种情况下，新容器的元素产生方式是将每个 `for` 或 `if` 子句视为一个代码块，按从左至右的顺序嵌套，然后每次到达最内层代码块时就对表达式进行求值以产生一个元素。
不过，除了最左边 `for` 子句中的可迭代表达式，推导式是在另一个隐式嵌套的作用域内执行的。 这能确保赋给目标列表的名称不会“泄露”到外层的作用域。
最左边 `for` 子句中的可迭代表达式会直接在外层作用域中被求值，然后作为一个参数被传给隐式嵌套的作用域。 后续的 `for` 子句以及最左侧 `for` 子句中的任何筛选条件不能在外层作用域中被求值，因为它们可能依赖于从最左侧可迭代对象中获得的值。 例如: `[x*y for x in range(10) for y in range(x, x+10)]`.
为了确保推导式得出的结果总是一个类型正确的容器，在隐式嵌套的作用域内禁止使用 `yield` 和 `yield from` 表达式 (在 Python 3.7 中，这样的表达式会在编译时引发 [`DeprecationWarning`](../library/exceptions.xhtml#DeprecationWarning "DeprecationWarning")，在 Python 3.8+ 中它们将引发 [`SyntaxError`](../library/exceptions.xhtml#SyntaxError "SyntaxError"))。
从 Python 3.6 开始，在 [`async def`](compound_stmts.xhtml#async-def) 函数中可以使用 `async for` 子句来迭代 [asynchronous iterator](../glossary.xhtml#term-asynchronous-iterator)。 在 `async def` 函数中构建推导式可以通过在打头的表达式后加上 `for` 或 `async for` 子句，也可能包含额外的 `for` 或 `async for` 子句，还可能使用 [`await`](#await) 表达式。 如果一个推导式包含 `async for` 子句或者 `await` 表达式，则被称为 *异步推导式*。 异步推导式可以暂停执行它所在的协程函数。 另请参阅 [**PEP 530**](https://www.python.org/dev/peps/pep-0530) \[https://www.python.org/dev/peps/pep-0530\]。
3\.6 新版功能: 引入了异步推导式。
3\.7 版后已移除: `yield` and `yield from` 在隐式嵌套的作用域内已弃用。
### 6.2.5. 列表显示
列表显示是一个用方括号括起来的可能为空的表达式系列:
```
list_display ::= "[" [starred_list | comprehension] "]"
```
列表显示会产生一个新的列表对象，其内容通过一系列表达式或一个推导式来指定。 当提供由逗号分隔的一系列表达式时，其元素会从左至右被求值并按此顺序放入列表对象。 当提供一个推导式时，列表会根据推导式所产生的结果元素进行构建。
### 6.2.6. 集合显示
集合显示是用花括号标明的，与字典显示的区别在于没有冒号分隔的键和值:
```
set_display ::= "{" (starred_list | comprehension) "}"
```
集合显示会产生一个新的可变集合对象，其内容通过一系列表达式或一个推导式来指定。 当提供由逗号分隔的一系列表达式时，其元素会从左至右被求值并加入到集合对象。 当提供一个推导式时，集合会根据推导式所产生的结果元素进行构建。
空集合不能用 `{}` 来构建；该字面值所构建的是一个空字典。
### 6.2.7. 字典显示
字典显示是一个用花括号括起来的可能为空的键/数据对系列:
```
dict_display ::= "{" [key_datum_list | dict_comprehension] "}"
key_datum_list ::= key_datum ("," key_datum)* [","]
key_datum ::= expression ":" expression | "**" or_expr
dict_comprehension ::= expression ":" expression comp_for
```
字典显示会产生一个新的字典对象。
如果给出一个由逗号分隔的键/数据对序列，它们会从左至右被求值以定义字典的条目：每个键对象会被用作在字典中存放相应数据的键。 这意味着你可以在键/数据对序列中多次指定相同的键，最终字典的值将由最后一次给出的键决定。
双星号 `**` 表示 *字典拆包*。 它的操作数必须是一个 [mapping](../glossary.xhtml#term-mapping)。 每个映射项被会加入新的字典。 后续的值会替代先前的键/数据对和先前的字典拆包所设置的值。
3\.5 新版功能: 拆包到字典显示，最初由 [**PEP 448**](https://www.python.org/dev/peps/pep-0448) \[https://www.python.org/dev/peps/pep-0448\] 提出。
字典推导式与列表和集合推导式有所不同，它需要以冒号分隔的两个表达式，后面带上标准的 "for" 和 "if" 子句。 当推导式被执行时，作为结果的键和值元素会按它们的产生顺序被加入新的字典。
对键取值类型的限制已列在之前的 [标准类型层级结构](datamodel.xhtml#types) 一节中。 (总的说来，键的类型应该为 [hashable](../glossary.xhtml#term-hashable)，这就把所有可变对象都排除在外。) 重复键之间的冲突不会被检测；指定键所保存的最后一个数据 (即在显示中排最右边的文本) 为最终有效数据。
### 6.2.8. 生成器表达式
生成器表达式是用圆括号括起来的紧凑形式生成器标注。
```
generator_expression ::= "(" expression comp_for ")"
```
生成器表达式会产生一个新的生成器对象。 其句法与推导式相同，区别在于它是用圆括号而不是用方括号或花括号括起来的。
在生成器表达式中使用的变量会在为生成器对象调用 [`__next__()`](#generator.__next__ "generator.__next__") 方法的时候以惰性方式被求值（即与普通生成器相同的方式）。 但是，最左侧 `for` 子句内的可迭代对象是会被立即求值的，因此它所造成的错误会在生成器表达式被定义时被检测到，而不是在获取第一个值时才出错。 后续的 `for` 子句以及最左侧 `for` 子句内的任何筛选条件无法在外层作用域内被求值，因为它们可能会依赖于从最左侧可迭代对象获取的值。 例如: `(x*y for x in range(10) for y in range(x, x+10))`.
圆括号在只附带一个参数的调用中可以被省略。 详情参见 [调用](#calls) 一节。
为避免干扰到生成器表达式本身预期的操作，`yield` 和 `yield from` 表达式禁止在隐式定义的生成器中使用 (在 Python 3.7 中，这种表达式会在编译时引发 [`DeprecationWarning`](../library/exceptions.xhtml#DeprecationWarning "DeprecationWarning")，在 Python 3.8+ 中它们将引发 [`SyntaxError`](../library/exceptions.xhtml#SyntaxError "SyntaxError"))。
如果生成器表达式包含 `async for` 子句或 [`await`](#await) 表达式，则称为 *异步生成器表达式*。 异步生成器表达式会返回一个新的异步生成器对象，此对象属于异步迭代器 (参见 [异步迭代器](datamodel.xhtml#async-iterators))。
3\.6 新版功能: 引入了异步生成器表达式。
在 3.7 版更改: 在 Python 3.7 之前，异步生成器表达式只能在 [`async def`](compound_stmts.xhtml#async-def) 协和中出现。 从 3.7 开始，任何函数都可以使用异步生成器表达式。
3\.7 版后已移除: `yield` and `yield from` 在隐式嵌套的作用域内已弃用。
### 6.2.9. yield 表达式
```
yield_atom ::= "(" yield_expression ")"
yield_expression ::= "yield" [expression_list | "from" expression]
```
yield 表达式在定义 [generator](../glossary.xhtml#term-generator) 函数或是 [asynchronous generator](../glossary.xhtml#term-asynchronous-generator) 的时候才会用到。 因此只能在函数定义的内部使用yield表达式。 在一个函数体内使用 yield 表达式会使这个函数变成一个生成器，并且在一个 [`async def`](compound_stmts.xhtml#async-def) 定义的函数体内使用 yield 表达式会让协程函数变成异步的生成器。 比如说:
```
def gen(): # defines a generator function
yield 123
async def agen(): # defines an asynchronous generator function
yield 123
```
由于它们会对外层作用域造成附带影响，`yield` 表达式不被允许作为用于实现推导式和生成器表达式的隐式定义作用域的一部分 (在 Python 3.7 中，此类表达式会在编译时引发 [`DeprecationWarning`](../library/exceptions.xhtml#DeprecationWarning "DeprecationWarning")，在 Python 3.8+ 中它们将引发 [`SyntaxError`](../library/exceptions.xhtml#SyntaxError "SyntaxError"))。
3\.7 版后已移除: yield 表达式在用于实现推导式和生成器表达式的隐式嵌套作用域中已弃用。
下面是对生成器函数的描述，异步生成器函数会在 [异步生成器函数](#asynchronous-generator-functions) 一节中单独介绍。
当一个生成器函数被调用的时候，它返回一个迭代器，称为生成器。然后这个生成器来控制生成器函数的执行。当这个生成器的某一个方法被调用的时候，生成器函数开始执行。这时会一直执行到第一个 yield 表达式，在此执行再次被挂起，给生成器的调用者返回 [`expression_list`](#grammar-token-expression-list) 的值。挂起后，我们说所有局部状态都被保留下来，包括局部变量的当前绑定，指令指针，内部求值栈和任何异常处理的状态。通过调用生成器的某一个方法，生成器函数继续执行。此时函数的运行就和 yield 表达式只是一个外部函数调用的情况完全一致。恢复后 yield 表达式的值取决于调用的哪个方法来恢复执行。 如果用的是 [`__next__()`](#generator.__next__ "generator.__next__") (通常通过语言内置的 [`for`](compound_stmts.xhtml#for) 或是 [`next()`](../library/functions.xhtml#next "next") 来调用) 那么结果就是 [`None`](../library/constants.xhtml#None "None"). 否则，如果用 [`send()`](#generator.send "generator.send"), 那么结果就是传递给send方法的值。
所有这些使生成器函数与协程非常相似；它们 yield 多次，它们具有多个入口点，并且它们的执行可以被挂起。唯一的区别是生成器函数不能控制在它在 yield 后交给哪里继续执行；控制权总是转移到生成器的调用者。
在 [`try`](compound_stmts.xhtml#try) 结构中的任何位置都允许yield表达式。如果生成器在(因为引用计数到零或是因为被垃圾回收)销毁之前没有恢复执行，将调用生成器-迭代器的 [`close()`](#generator.close "generator.close") 方法. close 方法允许任何挂起的 [`finally`](compound_stmts.xhtml#finally) 子句执行。
当使用 `yield from <expr>` 时，它会将所提供的表达式视为一个子迭代器。 这个子迭代器产生的所有值都直接被传递给当前生成器方法的调用者。 通过 [`send()`](#generator.send "generator.send") 传入的任何值以及通过 [`throw()`](#generator.throw "generator.throw") 传入的任何异常如果有适当的方法则会被传给下层迭代器。 如果不是这种情况，那么 [`send()`](#generator.send "generator.send") 将引发 [`AttributeError`](../library/exceptions.xhtml#AttributeError "AttributeError") 或 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError")，而 [`throw()`](#generator.throw "generator.throw") 将立即引发所传入的异常。
When the underlying iterator is complete, the `value`attribute of the raised [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration") instance becomes the value of the yield expression. It can be either set explicitly when raising [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration"), or automatically when the subiterator is a generator (by returning a value from the subgenerator).
> 在 3.3 版更改: 添加 `yield from <expr>` 以委托控制流给一个子迭代器。
当yield表达式是赋值语句右侧的唯一表达式时，括号可以省略。
参见
[**PEP 255**](https://www.python.org/dev/peps/pep-0255) \[https://www.python.org/dev/peps/pep-0255\] - 简单生成器在 Python 中加入生成器和 [`yield`](simple_stmts.xhtml#yield) 语句的提议。
[**PEP 342**](https://www.python.org/dev/peps/pep-0342) \[https://www.python.org/dev/peps/pep-0342\] - 通过增强型生成器实现协程增强生成器 API 和语法的提议，使其可以被用作简单的协程。
[**PEP 380**](https://www.python.org/dev/peps/pep-0380) \[https://www.python.org/dev/peps/pep-0380\] - 委托给子生成器的语法The proposal to introduce the `yield_from` syntax, making delegation to subgenerators easy.
[**PEP 525**](https://www.python.org/dev/peps/pep-0525) \[https://www.python.org/dev/peps/pep-0525\] - 异步生成器通过给协程函数加入生成器功能对 [**PEP 492**](https://www.python.org/dev/peps/pep-0492) \[https://www.python.org/dev/peps/pep-0492\] 进行扩展的提议。
#### 6.2.9.1. 生成器-迭代器的方法
这个子小节描述了生成器迭代器的方法。 它们可被用于控制生成器函数的执行。
请注意在生成器已经在执行时调用以下任何方法都会引发 [`ValueError`](../library/exceptions.xhtml#ValueError "ValueError") 异常。
`generator.``__next__`()开始一个生成器函数的执行或是从上次执行的 yield 表达式位置恢复执行。 当一个生成器函数通过 [`__next__()`](#generator.__next__ "generator.__next__") 方法恢复执行时，当前的 yield 表达式总是取值为 [`None`](../library/constants.xhtml#None "None")。 随后会继续执行到下一个 yield 表达式，其 [`expression_list`](#grammar-token-expression-list) 的值会返回给 [`__next__()`](#generator.__next__ "generator.__next__") 的调用者。 如果生成器没有产生下一个值就退出，则将引发 [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration") 异常。
此方法通常是隐式地调用，例如通过 [`for`](compound_stmts.xhtml#for) 循环或是内置的 [`next()`](../library/functions.xhtml#next "next") 函数。
`generator.``send`(*value*)恢复执行并向生成器函数“发送”一个值。 *value* 参数将成为当前 yield 表达式的结果。 [`send()`](#generator.send "generator.send") 方法会返回生成器所产生的下一个值，或者如果生成器没有产生下一个值就退出则会引发 [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration")。 当调用 [`send()`](#generator.send "generator.send") 来启动生成器时，它必须以 [`None`](../library/constants.xhtml#None "None") 作为调用参数，因为这时没有可以接收值的 yield 表达式。
`generator.``throw`(*type*\[, *value*\[, *traceback*\]\])在生成器暂停的位置引发 `type` 类型的异常，并返回该生成器函数所产生的下一个值。 如果生成器没有产生下一个值就退出，则将引发 [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration") 异常。 如果生成器函数没有捕获传入的异常，或引发了另一个异常，则该异常会被传播给调用者。
`generator.``close`()在生成器函数暂停的位置引发 [`GeneratorExit`](../library/exceptions.xhtml#GeneratorExit "GeneratorExit")。 如果之后生成器函数正常退出、关闭或引发 [`GeneratorExit`](../library/exceptions.xhtml#GeneratorExit "GeneratorExit") (由于未捕获该异常) 则关闭并返回其调用者。 如果生成器产生了一个值，关闭会引发 [`RuntimeError`](../library/exceptions.xhtml#RuntimeError "RuntimeError")。 如果生成器引发任何其他异常，它会被传播给调用者。 如果生成器已经由于异常或正常退出则 [`close()`](#generator.close "generator.close") 不会做任何事。
#### 6.2.9.2. 示例
这里是一个简单的例子，演示了生成器和生成器函数的行为:
```
>>> def echo(value=None):
... print("Execution starts when 'next()' is called for the first time.")
... try:
... while True:
... try:
... value = (yield value)
... except Exception as e:
... value = e
... finally:
... print("Don't forget to clean up when 'close()' is called.")
...
>>> generator = echo(1)
>>> print(next(generator))
Execution starts when 'next()' is called for the first time.
1
>>> print(next(generator))
None
>>> print(generator.send(2))
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.
```
对于 `yield from` 的例子, 参见“Python 有什么新变化”中的 [PEP 380: Syntax for Delegating to a Subgenerator](../whatsnew/3.3.xhtml#pep-380)。
#### 6.2.9.3. 异步生成器函数
The presence of a yield expression in a function or method defined using [`async def`](compound_stmts.xhtml#async-def) further defines the function as an [asynchronous generator](../glossary.xhtml#term-asynchronous-generator) function.
当一个异步生成器函数被调用时，它会返回一个名为异步生成器对象的异步迭代器。 此对象将在之后控制该生成器函数的执行。 异步生成器对象通常被用在协程函数的 [`async for`](compound_stmts.xhtml#async-for) 语句中，类似于在 [`for`](compound_stmts.xhtml#for) 语句中使用生成器对象。
调用异步生成器的方法之一将返回 [awaitable](../glossary.xhtml#term-awaitable) 对象，执行会在此对象被等待时启动。 到那时，执行将前往第一个 yield 表达式，在那里它会再次暂停，将 [`expression_list`](#grammar-token-expression-list) 的值返回给等待中的协程。 与生成器一样，挂起意味着局部的所有状态会被保留，包括局部变量的当前绑定、指令的指针、内部求值的堆栈以及任何异常处理的状态。 当执行在等待异步生成器的方法返回下一个对象后恢复时，该函数可以从原状态继续进行，就仿佛 yield 表达式只是另一个外部调用。 恢复执行之后 yield 表达式的值取决于恢复执行所用的方法。 如果使用 [`__anext__()`](#agen.__anext__ "agen.__anext__") 则结果为 [`None`](../library/constants.xhtml#None "None")。 否则的话，如果使用 [`asend()`](#agen.asend "agen.asend") 则结果将是传递给该方法的值。
在异步生成器函数中，yield 表达式允许出现在 [`try`](compound_stmts.xhtml#try) 结构的任何位置。 但是，如果一个异步生成器在其被终结（由于引用计数达到零或被作为垃圾回收）之前未被恢复，则then a yield expression within a `try` 结构中的 yield 表达式可能导致挂起的 [`finally`](compound_stmts.xhtml#finally) 子句执行失败。 在此情况下，应由运行该异步生成器的事件循环或任务调度器来负责调用异步生成器-迭代器的 [`aclose()`](#agen.aclose "agen.aclose") 方法并运行所返回的协程对象，从而允许任何挂起的 `finally` 子句得以执行。
为了能处理最终化，事件循环应该定义一个 *终结器* 函数，它接受一个异步生成器-迭代器且可能调用 [`aclose()`](#agen.aclose "agen.aclose") 并执行协程。 这个 *终结器* 可能通过调用 [`sys.set_asyncgen_hooks()`](../library/sys.xhtml#sys.set_asyncgen_hooks "sys.set_asyncgen_hooks") 来注册。 当首次迭代时，异步生成器-迭代器将保存已注册的 *终结器* 以便在最终化时调用。 有关For a reference example of a *终结器* 方法的参考示例请查看 [Lib/asyncio/base\_events.py](https://github.com/python/cpython/tree/3.7/Lib/asyncio/base_events.py) \[https://github.com/python/cpython/tree/3.7/Lib/asyncio/base\_events.py\] 中实现的 `asyncio.Loop.shutdown_asyncgens`。
`yield from <expr>` 表达式如果在异步生成器函数中使用会引发语法错误。
#### 6.2.9.4. 异步生成器-迭代器方法
这个子小节描述了异步生成器迭代器的方法，它们可被用于控制生成器函数的执行。
*coroutine* `agen.``__anext__`()Returns an awaitable which when run starts to execute the asynchronous generator or resumes it at the last executed yield expression. When an asynchronous generator function is resumed with an [`__anext__()`](#agen.__anext__ "agen.__anext__")method, the current yield expression always evaluates to [`None`](../library/constants.xhtml#None "None") in the returned awaitable, which when run will continue to the next yield expression. The value of the [`expression_list`](#grammar-token-expression-list) of the yield expression is the value of the [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration") exception raised by the completing coroutine. If the asynchronous generator exits without yielding another value, the awaitable instead raises a [`StopAsyncIteration`](../library/exceptions.xhtml#StopAsyncIteration "StopAsyncIteration") exception, signalling that the asynchronous iteration has completed.
此方法通常是通过 [`async for`](compound_stmts.xhtml#async-for) 循环隐式地调用。
*coroutine* `agen.``asend`(*value*)返回一个可等待对象，它在运行时会恢复该异步生成器的执行。 与生成器的 [`send()`](#generator.send "generator.send") 方法一样，此方法会“发送”一个值给异步生成器函数，其 *value* 参数会成为当前 yield 表达式的结果值。 [`asend()`](#agen.asend "agen.asend") 方法所返回的可等待对象将返回生成器产生的下一个值，其值为所引发的 [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration")，或者如果异步生成器没有产生下一个值就退出则引发 [`StopAsyncIteration`](../library/exceptions.xhtml#StopAsyncIteration "StopAsyncIteration")。 当调用 [`asend()`](#agen.asend "agen.asend") 来启动异步生成器时，它必须以 [`None`](../library/constants.xhtml#None "None") 作为调用参数，因为这时没有可以接收值的 yield 表达式。
*coroutine* `agen.``athrow`(*type*\[, *value*\[, *traceback*\]\])Returns an awaitable that raises an exception of type `type` at the point where the asynchronous generator was paused, and returns the next value yielded by the generator function as the value of the raised [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration") exception. If the asynchronous generator exits without yielding another value, a [`StopAsyncIteration`](../library/exceptions.xhtml#StopAsyncIteration "StopAsyncIteration") exception is raised by the awaitable. If the generator function does not catch the passed-in exception, or raises a different exception, then when the awaitable is run that exception propagates to the caller of the awaitable.
*coroutine* `agen.``aclose`()返回一个可等待对象，它会在运行时向异步生成器函数暂停的位置抛入一个 [`GeneratorExit`](../library/exceptions.xhtml#GeneratorExit "GeneratorExit")。 如果该异步生成器函数正常退出、关闭或引发 [`GeneratorExit`](../library/exceptions.xhtml#GeneratorExit "GeneratorExit") (由于未捕获该异常) 则返回的可等待对象将引发 [`StopIteration`](../library/exceptions.xhtml#StopIteration "StopIteration") 异常。 后续调用异步生成器所返回的任何其他可等待对象将引发 [`StopAsyncIteration`](../library/exceptions.xhtml#StopAsyncIteration "StopAsyncIteration") 异常。 如果异步生成器产生了一个值，该可等待对象会引发 [`RuntimeError`](../library/exceptions.xhtml#RuntimeError "RuntimeError")。 如果异步生成器引发任何其他异常，它会被传播给可等待对象的调用者。 如果异步生成器已经由于异常或正常退出则后续调用 [`aclose()`](#agen.aclose "agen.aclose") 将返回一个不会做任何事的可等待对象。
## 6.3. 原型
原型代表编程语言中最紧密绑定的操作。 它们的句法如下:
```
primary ::= atom | attributeref | subscription | slicing | call
```
### 6.3.1. 属性引用
属性引用是后面带有一个句点加一个名称的原型:
```
attributeref ::= primary "." identifier
```
此原型必须求值为一个支持属性引用的类型的对象，多数对象都支持属性引用。 随后该对象会被要求产生以指定标识符为名称的属性。 这个产生过程可通过重载 [`__getattr__()`](datamodel.xhtml#object.__getattr__ "object.__getattr__") 方法来自定义。 如果这个属性不可用，则将引发 [`AttributeError`](../library/exceptions.xhtml#AttributeError "AttributeError") 异常。 否则的话，所产生对象的类型和值会根据该对象来确定。 对同一属性引用的多次求值可能产生不同的对象。
### 6.3.2. 抽取
抽取就是在序列（字符串、元组或列表）或映射（字典）对象中选择一项:
```
subscription ::= primary "[" expression_list "]"
```
此原型必须求值为一个支持抽取操作的对象（例如列表或字典）。 用户定义的对象可通过定义 [`__getitem__()`](datamodel.xhtml#object.__getitem__ "object.__getitem__") 方法来支持抽取操作。
对于内置对象，有两种类型的对象支持抽取操作:
如果原型为映射，表达式列表必须求值为一个以该映射的键为值的对象，抽取操作会在映射中选出该键所对应的值。（表达式列表为一个元组，除非其中只有一项。）
如果原型为序列，表达式列表必须求值为一个整数或一个切片（详情见下节）。
正式句法规则并没有在序列中设置负标号的特殊保留条款；但是，内置序列所提供的 [`__getitem__()`](datamodel.xhtml#object.__getitem__ "object.__getitem__") 方法都可通过在索引中添加序列长度来解析负标号 (这样 `x[-1]` 会选出 `x` 中的最后一项)。 结果值必须为一个小于序列中项数的非负整数，抽取操作会选出标号为该值的项（从零开始数）。 由于对负标号和切片的支持存在于对象的 [`__getitem__()`](datamodel.xhtml#object.__getitem__ "object.__getitem__") 方法，重载此方法的子类需要显式地添加这种支持。
字符串的项是字符。 字符不是单独的数据类型而是仅有一个字符的字符串。
### 6.3.3. 切片
切片就是在序列对象（字符串、元组或列表）中选择某个范围内的项。 切片可被用作表达式以及赋值或 [`del`](simple_stmts.xhtml#del) 语句的目标。 切片的句法如下:
```
slicing ::= primary "[" slice_list "]"
slice_list ::= slice_item ("," slice_item)* [","]
slice_item ::= expression | proper_slice
proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound ::= expression
upper_bound ::= expression
stride ::= expression
```
此处的正式句法中存在一点歧义：任何形似表达式列表的东西同样也会形似切片列表，因此任何抽取操作也可以被解析为切片。 为了不使句法更加复杂，于是通过定义将此情况解析为抽取优先于解析为切片来消除这种歧义（切片列表未包含正确的切片就属于此情况）。
切片的语义如下所述。 元型通过一个根据下面的切片列表来构造的键进行索引（与普通抽取一样使用 [`__getitem__()`](datamodel.xhtml#object.__getitem__ "object.__getitem__") 方法）。 如果切片列表包含至少一个逗号，则键将是一个包含切片项转换的元组；否则的话，键将是单个切片项的转换。 切片项如为一个表达式，则其转换就是该表达式。 一个正确切片的转换就是一个切片对象（参见 [标准类型层级结构](datamodel.xhtml#types) 一节），该对象的 `start`, `stop` 和 `step` 属性将分别为表达式所给出的下界、上界和步长值，省略的表达式将用 `None` 来替换。
### 6.3.4. 调用
所谓调用就是附带可能为空的一系列 [参数](../glossary.xhtml#term-argument) 来执行一个可调用对象 (例如 [function](../glossary.xhtml#term-function)):
```
call ::= primary "(" [argument_list [","] | comprehension] ")"
argument_list ::= positional_arguments ["," starred_and_keywords]
["," keywords_arguments]
| starred_and_keywords ["," keywords_arguments]
| keywords_arguments
positional_arguments ::= ["*"] expression ("," ["*"] expression)*
starred_and_keywords ::= ("*" expression | keyword_item)
("," "*" expression | "," keyword_item)*
keywords_arguments ::= (keyword_item | "**" expression)
("," keyword_item | "," "**" expression)*
keyword_item ::= identifier "=" expression
```
一个可选项为在位置和关键字参数后加上逗号而不影响语义。
此原型必须求值为一个可调用对象（用户定义的函数，内置函数，内置对象的方法，类对象，类实例的方法以及任何具有 [`__call__()`](datamodel.xhtml#object.__call__ "object.__call__") 方法的对象都是可调用对象）。 所有参数表达式将在尝试调用前被求值。 请参阅 [函数定义](compound_stmts.xhtml#function) 一节了解正式的 [parameter](../glossary.xhtml#term-parameter) 列表句法。
如果存在关键字参数，它们会先通过以下操作被转换为位置参数。 首先，为正式参数创建一个未填充空位的列表. 如果有 N 个位置参数，则将它们放入前 N 个空位。 然后，对于每个关键字参数，使用标识符来确定其对应的空位（如果标识符与第一个正式参数名相同则使用第一个个空位，依此类推）。 如果空位已被填充，则会引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError") 异常。 否则，将参数值放入空位进行填充（即使表达式为 `None` 也会填充空位）。 当所有参数处理完毕时，尚未填充的空位将用来自函数定义的相应默认值来填充。 （函数一旦定义其参数默认值就会被计算；因此，当列表或字典这类可变对象被用作默认值时，将会被所有未指定相应空位参数值的调用所共享；这种情况通常应当避免。） 如果任何一个未填充空位没有指定默认值，则会引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError") 异常。 否则的话，已填充空位的列表会被作为调用的参数列表。
**CPython implementation detail:** 某些实现可能提供位置参数没有名称的内置函数，即使它们在文档说明的场合下有“命名”，因此不能以关键字形式提供参数。 在 CPython 中，以 C 编写并使用 [`PyArg_ParseTuple()`](../c-api/arg.xhtml#c.PyArg_ParseTuple "PyArg_ParseTuple") 来解析其参数的函数实现就属于这种情况。
如果存在比正式参数空位多的位置参数，将会引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError") 异常，除非有一个正式参数使用了 `*identifier` 句法；在此情况下，该正式参数将接受一个包含了多余位置参数的元组（如果没有多余位置参数则为一个空元组）。
如果任何关键字参数没有与之对应的正式参数名称，将会引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError") 异常，除非有一个正式参数使用了 `**identifier` 句法，该正式参数将接受一个包含了多余关键字参数的字典（使用关键字作为键而参数值作为与键对应的值），如果没有多余关键字参数则为一个（新的）空字典。
如果函数调用中出现了 `*expression` 句法，`expression` 必须求值为一个 [iterable](../glossary.xhtml#term-iterable)。 来自该可迭代对象的元素会被当作是额外的位置参数。 对于 `f(x1, x2, *y, x3, x4)` 调用，如果 *y* 求值为一个序列 *y1*, ..., *yM*，则它就等价于一个带有 M+4 个位置参数 *x1*, *x2*, *y1*, ..., *yM*, *x3*, *x4* 的调用。
这样做的一个后果是虽然 `*expression` 句法可能出现于显式的关键字参数 *之后*，但它会在关键字参数（以及任何 `**expression` 参数 -- 见下文） *之前* 被处理。 因此:
```
>>> def f(a, b):
... print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2
```
在同一个调用中同时使用关键字参数和 `*expression` 句法并不常见，因此实际上这样的混淆不会发生。
如果函数调用中出现了 `**expression` 句法，`expression` 必须求值为一个 [mapping](../glossary.xhtml#term-mapping)，其内容会被当作是额外的关键字参数。 如果一个关键字已存在（作为显式关键字参数，或来自另一个拆包），则将引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError") 异常。
使用 `*identifier` 或 `**identifier` 句法的正式参数不能被用作位置参数空位或关键字参数名称。
在 3.5 版更改: 函数调用接受任意数量的 `*` 和 `**` 拆包，位置参数可能跟在可迭代对象拆包 (`*`) 之后，而关键字参数可能跟在字典拆包 (`**`) 之后。 由 [**PEP 448**](https://www.python.org/dev/peps/pep-0448) \[https://www.python.org/dev/peps/pep-0448\] 发起最初提议。
除非引发了异常，调用总是会有返回值，返回值也可能为 `None`。 返回值的计算方式取决于可调用对象的类型。
如果类型为---
用户自定义函数:函数的代码块会被执行，并向其传入参数列表。 代码块所做的第一件事是将正式形参绑定到对应参数；相关描述参见 [函数定义](compound_stmts.xhtml#function) 一节。 当代码块执行 [`return`](simple_stmts.xhtml#return) 语句时，由其指定函数调用的返回值。
内置函数或方法:具体结果依赖于解释器；有关内置函数和方法的描述参见 [内置函数](../library/functions.xhtml#built-in-funcs)。
类对象:返回该类的一个新实例。
类实例方法:调用相应的用户自定义函数，向其传入的参数列表会比调用的参数列表多一项：该实例将成为第一个参数。
类实例:该类必须定义有 [`__call__()`](datamodel.xhtml#object.__call__ "object.__call__") 方法；作用效果将等价于调用该方法。
## 6.4. await 表达式
挂起 [coroutine](../glossary.xhtml#term-coroutine) 的执行以等待一个 [awaitable](../glossary.xhtml#term-awaitable) 对象。 只能在 [coroutine function](../glossary.xhtml#term-coroutine-function) 内部使用。
```
await_expr ::= "await" primary
```
3\.5 新版功能.
## 6.5. 幂运算符
幂运算符的绑定比在其左侧的一元运算符更紧密；但绑定紧密程度不及在其右侧的一元运算符。 句法如下:
```
power ::= (await_expr | primary) ["**" u_expr]
```
因此，在一个未加圆括号的幂运算符和单目运算符序列中，运算符将从右向左求值（这不会限制操作数的求值顺序）: `-1**2` 结果将为 `-1`。
幂运算符与附带两个参数调用内置 [`pow()`](../library/functions.xhtml#pow "pow") 函数具有相同的语义：结果为对其左参数进行其右参数所指定幂次的乘方运算。 数值参数会先转换为相同类型，结果也为转换后的类型。
对于 int 类型的操作数，结果将具有与操作数相同的类型，除非第二个参数为负数；在那种情况下，所有参数会被转换为 float 类型并输出 float 类型的结果。 例如，`10**2` 返回 `100`，而 `10**-2` 返回 `0.01`。
对 `0.0` 进行负数幂次运算将导致 [`ZeroDivisionError`](../library/exceptions.xhtml#ZeroDivisionError "ZeroDivisionError")。 对负数进行分数幂次运算将返回 [`complex`](../library/functions.xhtml#complex "complex") 数值。 （在早期版本中这将引发 [`ValueError`](../library/exceptions.xhtml#ValueError "ValueError")。）
## 6.6. 一元算术和位运算
所有算术和位运算具有相同的优先级:
```
u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr
```
一元运算符 `-` (负) 会产生其数值参数的负值。
一元运算符 `+` (正) 会产生与其数值参数相同的值。
一元运算符 `~` (取反) 的结果是对其整数参数按位取反。 `x` 的按位取反被定义为 `-(x+1)`。 它只作用于整数。
在所有三种情况下，如果参数的类型不正确，将引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError") 异常。
## 6.7. 二元算术运算符
二元算术运算符遵循传统的优先级。 请注意某些此类运算符也作用于特定的非数字类型。 除幂运算符以外只有两个优先级别，一个作用于乘法型运算符，另一个作用于加法型运算符:
```
m_expr ::= u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
m_expr "//" u_expr | m_expr "/" u_expr |
m_expr "%" u_expr
a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr
```
运算符 `*` (乘) 将输出其参数的乘积。 两个参数或者必须都为数字，或者一个参数必须为整数而另一个参数必须为序列。 在前一种情况下，两个数字将被转换为相同类型然后相乘。 在后一种情况下，将执行序列的重复；重复因子为负数将输出空序列。
运算符 `@` (at) 的目标是用于矩阵乘法。 没有内置 Python 类型实现此运算符。
3\.5 新版功能.
运算符 `/` (除) 和 `//` (整除) 将输出其参数的商。 两个数字参数将先被转换为相同类型。 整数相除会输出一个 float 值，整数相整除的结果仍是整数；整除的结果就是使用 'floor' 函数进行算术除法的结果。 除以零的运算将引发 [`ZeroDivisionError`](../library/exceptions.xhtml#ZeroDivisionError "ZeroDivisionError") 异常。
运算符 `%` (模) 将输出第一个参数除以第二个参数的余数。 两个数字参数将先被转换为相同类型。 右参数为零将引发 [`ZeroDivisionError`](../library/exceptions.xhtml#ZeroDivisionError "ZeroDivisionError") 异常。 参数可以为浮点数，例如 `3.14%0.7` 等于 `0.34` (因为 `3.14` 等于 `4*0.7 + 0.34`)。 模运算符的结果的正负总是与第二个操作数一致（或是为零）；结果的绝对值一定小于第二个操作数的绝对值 [1](#id17)。
整除与模运算符的联系可通过以下等式说明: `x == (x//y)*y + (x%y)`。 此外整除与模也可通过内置函数 [`divmod()`](../library/functions.xhtml#divmod "divmod") 来同时进行: `divmod(x, y) == (x//y, x%y)`。 [2](#id18)。
除了对数字执行模运算，运算符 `%` 还被字符串对象重载用于执行旧式的字符串格式化（又称插值）。 字符串格式化句法的描述参见 Python 库参考的 [printf 风格的字符串格式化](../library/stdtypes.xhtml#old-string-formatting) 一节。
整除运算符，模运算符和 [`divmod()`](../library/functions.xhtml#divmod "divmod") 函数未被定义用于复数。 如果有必要可以使用 [`abs()`](../library/functions.xhtml#abs "abs") 函数将其转换为浮点数。
运算符 `+` (addition) 将输出其参数的和。 两个参数或者必须都为数字，或者都为相同类型的序列。 在前一种情况下，两个数字将被转换为相同类型然后相加。 在后一种情况下，将执行序列拼接操作。
运算符 `-` (减) 将输出其参数的差。 两个数字参数将先被转换为相同类型。
## 6.8. 移位运算
移位运算的优先级低于算术运算:
```
shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr
```
这些运算符接受整数参数。 它们会将第一个参数左移或右移第二个参数所指定的比特位数。
右移 *n* 位被定义为被 `pow(2,n)` 整除。 左移 *n* 位被定义为乘以 `pow(2,n)`。
## 6.9. 二元位运算
三种位运算具有各不相同的优先级:
```
and_expr ::= shift_expr | and_expr "&" shift_expr
xor_expr ::= and_expr | xor_expr "^" and_expr
or_expr ::= xor_expr | or_expr "|" xor_expr
```
运算符 `&` 对两个参数进行按位 AND (与) 运算，两个参数必须为整数。
运算符 `^` 对两个参数进行按位 XOR (异或) 运算，两个参数必须为整数。
运算符 `|` 对两个参数进行按位 OR (或) 运算，两个参数必须为整数。
## 6.10. 比较运算
与 C 不同，Python 中所有比较运算的优先级相同，低于任何算术、移位或位运算。 另一个与 C 不同之处在于 `a < b < c` 这样的表达式会按传统算术法则来解读:
```
comparison ::= or_expr (comp_operator or_expr)*
comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="
| "is" ["not"] | ["not"] "in"
```
比较运算将输出布尔值: `True` 或 `False`。
比较运算可以任意串连，例如 `x < y <= z` 等价于 `x < y and y <= z`，除了 `y` 只被求值一次（但在两种写法下当 `x < y` 值为假时 `z` 都不会被求值）。
正式的说法是这样：如果 *a*, *b*, *c*, ..., *y*, *z* 为表达式而 *op1*, *op2*, ..., *opN* 为比较运算符，则 `a op1 b op2 c ... y opN z` 就等价于 `a op1 b and b op2 c and ... y opN z`，后者的不同之处只是每个表达式最多只被求值一次。
请注意 `a op1 b op2 c` 不意味着在 *a* 和 *c* 之间进行任何比较，因此，如 `x < y > z` 这样的写法是完全合法的（虽然也许不太好看）。
### 6.10.1. 值比较
运算符 `<`, `>`, `==`, `>=`, `<=` 和 `!=` 将比较两个对象的值。 两个对象不要求为相同类型。
[对象、值与类型](datamodel.xhtml#objects) 一章已说明对象都有相应的值（还有类型和标识号）。 对象值在 Python 中是一个相当抽象的概念：例如，对象值并没有一个规范的访问方法。 而且，对象值并不要求具有特定的构建方式，例如由其全部数据属性组成等。 比较运算符实现了一个特定的对象值概念。 人们可以认为这是通过实现对象比较间接地定义了对象值。
由于所有类型都是 [`object`](../library/functions.xhtml#object "object") 的（直接或间接）子类型，它们都从 [`object`](../library/functions.xhtml#object "object") 继承了默认的比较行为。 类型可以通过实现 *丰富比较方法* 例如 [`__lt__()`](datamodel.xhtml#object.__lt__ "object.__lt__") 来定义自己的比较行为，详情参见 [基本定制](datamodel.xhtml#customization)。
默认的一致性比较 (`==` 和 `!=`) 是基于对象的标识号。 因此，具有相同标识号的实例一致性比较结果为相等，具有不同标识号的实例一致性比较结果为不等。 规定这种默认行为的动机是希望所有对象都应该是自反射的 (即 `x is y` 就意味着 `x == y`)。
次序比较 (`<`, `>`, `<=` 和 `>=`) 默认没有提供；如果尝试比较会引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError")。 规定这种默认行为的原因是缺少与一致性比较类似的固定值。
按照默认的一致性比较行为，具有不同标识号的实例总是不相等，这可能不适合某些对象值需要有合理定义并有基于值的一致性的类型。 这样的类型需要定制自己的比较行为，实际上，许多内置类型都是这样做的。
以下列表描述了最主要内置类型的比较行为。
- 内置数值类型 ([数字类型 --- int, float, complex](../library/stdtypes.xhtml#typesnumeric)) 以及标准库类型 [`fractions.Fraction`](../library/fractions.xhtml#fractions.Fraction "fractions.Fraction") 和 [`decimal.Decimal`](../library/decimal.xhtml#decimal.Decimal "decimal.Decimal") 可进行类型内部和跨类型的比较，例外限制是复数不支持次序比较。 在类型相关的限制以内，它们会按数学（算法）规则正确进行比较且不会有精度损失。
非数字值 `float('NaN')` 和 `decimal.Decimal('NaN')` 属于特例。 任何数字与非数字值的比较均返回假值。 还有一个反直觉的结果是非数字值不等于其自身。 例如，如果 `x = float('NaN')` 则 `3 < x`, `x < 3`, `x == x`, `x != x` 均为假值。 此行为是符合 IEEE 754 标准的。
- 二进制码序列 ([`bytes`](../library/stdtypes.xhtml#bytes "bytes") 或 [`bytearray`](../library/stdtypes.xhtml#bytearray "bytearray") 的实例) 可进行类型内部和跨类型的比较。 它们使用其元素的数字值按字典顺序进行比较。
- 字符串 ([`str`](../library/stdtypes.xhtml#str "str") 的实例) 使用其字符的 Unicode 码位数字值 (内置函数 [`ord()`](../library/functions.xhtml#ord "ord") 的结果) 按字典顺序进行比较。 [3](#id19)
字符串和二进制码序列不能直接比较。
- 序列 ([`tuple`](../library/stdtypes.xhtml#tuple "tuple"), [`list`](../library/stdtypes.xhtml#list "list") 或 [`range`](../library/stdtypes.xhtml#range "range") 的实例) 只可进行类型内部的比较，range 还有一个限制是不支持次序比较。 以上对象的跨类型一致性比较结果将是不相等，跨类型次序比较将引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError")。
序列通过相应元素的比较进行字典列比较，并强制规定元素自反射性。
由于强制元素自反射性，多项集的比较将假定对于一个多项集元素 `x`, `x == x` 总是为真。 基于该假设，将首先比较元素标识号，并且仅会对不同元素执行元素比较。 如果元素是自反射的，这种方式会产生与严格元素比较相同的结果。 对于非自反射的元素，结果将不同于严格元素比较，并且可能会令人惊讶：例如当在列表中使用非自反射的非数字值时，将导致以下比较行为:
```
>>> nan = float('NaN')
>>> nan is nan
True
>>> nan == nan
False <-- the defined non-reflexive behavior of NaN
>>> [nan] == [nan]
True <-- list enforces reflexivity and tests identity first
```
内置多项集间的字典序比较规则如下:
- 两个多项集若要相等，它们必须为相同类型、相同长度，并且每对相应的元素都必须相等（例如，`[1,2] == (1,2)` 为假值，因为类型不同）。
- 对于支持次序比较的多项集，排序与其第一个不相等元素的排序相同（例如 `[1,2,x] <= [1,2,y]` 的值与``x <= y`` 相同）。 如果对应元素不存在，较短的多项集排序在前（例如 `[1,2] < [1,2,3]` 为真值）。
- 两个映射 ([`dict`](../library/stdtypes.xhtml#dict "dict") 的实例) 若要相等，必须当且仅当它们具有相同的 (键, 值) 对。 键和值的一致性比较强制规定自反射性。
次序比较 (`<`, `>`, `<=` 和 `>=`) 将引发 [`TypeError`](../library/exceptions.xhtml#TypeError "TypeError")。
- 集合 ([`set`](../library/stdtypes.xhtml#set "set") 或 [`frozenset`](../library/stdtypes.xhtml#frozenset "frozenset") 的实例) 可进行类型内部和跨类型的比较。
它们将比较运算符定义为子集和超集检测。 这类关系没有定义完全排序（例如 `{1,2}` 和 `{2,3}` 两个集合不相等，即不为彼此的子集，也不为彼此的超集。 相应地，集合不适宜作为依赖于完全排序的函数的参数（例如如果给出一个集合列表作为 [`min()`](../library/functions.xhtml#min "min"), [`max()`](../library/functions.xhtml#max "max") 和 [`sorted()`](../library/functions.xhtml#sorted "sorted") 的输入将产生未定义的结果）。
集合的比较强制规定其元素的自反射性。
- 大多数其他内置类型没有实现比较方法，因此它们会继承默认的比较行为。
在可能的情况下，用户定义类在定制其比较行为时应当遵循一些一致性规则:
- 相等比较应该是自反射的。 换句话说，相同的对象比较时应该相等:
> `x is y` 意味着 `x == y`
- 比较应该是对称的。 换句话说，下列表达式应该有相同的结果:
> `x == y` 和 `y == x`
>
> `x != y` 和 `y != x`
>
> `x < y` 和 `y > x`
>
> `x <= y` 和 `y >= x`
- 比较应该是可传递的。 下列（简要的）例子显示了这一点:
> `x > y and y > z` 意味着 `x > z`
>
> `x < y and y <= z` 意味着 `x < z`
- 反向比较应该导致布尔值取反。 换句话说，下列表达式应该有相同的结果:
> `x == y` 和 `not x != y`
>
> `x < y` 和 `not x >= y` (对于完全排序)
>
> `x > y` 和 `not x <= y` (对于完全排序)
最后两个表达式适用于完全排序的多项集（即序列而非集合或映射）。 另请参阅 [`total_ordering()`](../library/functools.xhtml#functools.total_ordering "functools.total_ordering") 装饰器。
- [`hash()`](../library/functions.xhtml#hash "hash") 的结果应该与是否相等一致。 相等的对象应该或者具有相同的哈希值，或者标记为不可哈希。
Python 并不强制要求这些一致性规则。 实际上，非数字值就是一个不遵循这些规则的例子。
### 6.10.2. 成员检测运算
运算符 [`in`](#in) 和 [`not in`](#not-in) 用于成员检测。 如果 *x* 是 *s* 的成员则 `x in s` 求值为 `True`，否则为 `False`。 `x not in s` 返回 `x in s` 取反后的值。 所有内置序列和集合类型以及字典都支持此运算，对于字典来说 `in` 检测其是否有给定的键。 对于 list, tuple, set, frozenset, dict 或 collections.deque 这样的容器类型，表达式 `x in y` 等价于 `any(x is e or x == e for e in y)`。
对于字符串和字节串类型来说，当且仅当 *x* 是 *y* 的子串时 `x in y` 为 `True`。 一个等价的检测是 `y.find(x) != -1`。 空字符串总是被视为任何其他字符串的子串，因此 `"" in "abc"` 将返回 `True`。
对于定义了 [`__contains__()`](datamodel.xhtml#object.__contains__ "object.__contains__") 方法的用户自定义类来说，如果 `y.__contains__(x)` 返回真值则 `x in y` 返回 `True`，否则返回 `False`。
对于未定义 [`__contains__()`](datamodel.xhtml#object.__contains__ "object.__contains__") 但定义了 [`__iter__()`](datamodel.xhtml#object.__iter__ "object.__iter__") 的用户自定义类来说，如果在对 `y` 进行迭代时产生了值 `z` 且 `x == z` 则 `x in y` 为 `True`。 如果在迭代期间引发了异常，则等同于 [`in`](#in) 引发了该异常。
最后会尝试旧式的迭代协议：如果一个类定义了 [`__getitem__()`](datamodel.xhtml#object.__getitem__ "object.__getitem__")，则当且仅当存在非负整数索引 *i* 使得 `x == y[i]` 并且所有更小索引未引发 [`IndexError`](../library/exceptions.xhtml#IndexError "IndexError") 异常时 `x in y` 为 `True`。 （如果引发了任何其他异常，则等同于 [`in`](#in) 引发了该异常）。
The operator [`not in`](#not-in) is defined to have the inverse truth value of [`in`](#in).
### 6.10.3. 标识号比较
The operators [`is`](#is) and [`is not`](#is-not) test for an object's identity:
```
x
is y
```
is true if and only if *x* and *y* are the same object. An Object's identity is determined using the [`id()`](../library/functions.xhtml#id "id") function. `x is not y` yields the inverse truth value. [4](#id20)
## 6.11. 布尔运算
```
or_test ::= and_test | or_test "or" and_test
and_test ::= not_test | and_test "and" not_test
not_test ::= comparison | "not" not_test
```
在执行布尔运算的情况下，或是当表达式被用于流程控制语句时，以下值会被解析为假值: `False`, `None`, 所有类型的数字零，以及空字符串和空容器（包括字符串、元组、列表、字典、集合与冻结集合）。 所有其他值都会被解析为真值。 用户自定义对象可通过提供 [`__bool__()`](datamodel.xhtml#object.__bool__ "object.__bool__") 方法来定制其逻辑值。
运算符 [`not`](#not) 将在其参数为假值时产生 `True`，否则产生 `False`。
表达式 `x and y` 首先对 *x* 求值；如果 *x* 为假则返回该值；否则对 *y* 求值并返回其结果值。
表达式 `x or y` 首先对 *x* 求值；如果 *x* 为真则返回该值；否则对 *y* 求值并返回其结果值。
请注意 [`and`](#and) 和 [`or`](#or) 都不限制其返回的值和类型必须为 `False` 和 `True`，而是返回最终求值的参数。 此行为是有必要的，例如假设 `s` 为一个当其为空时应被替换为某个默认值的字符串，表达式 `s or 'foo'` 将产生希望的值。 由于 [`not`](#not) 必须创建一个新值，不论其参数为何种类型它都会返回一个布尔值（例如，`not 'foo'` 结果为 `False` 而非 `''`。）
## 6.12. 条件表达式
```
conditional_expression ::= or_test ["if" or_test "else" expression]
expression ::= conditional_expression | lambda_expr
expression_nocond ::= or_test | lambda_expr_nocond
```
条件表达式（有时称为“三元运算符”）在所有 Python 运算中具有最低的优先级。
表达式 `x if C else y` 首先是对条件 *C* 而非 *x* 求值。 如果 *C* 为真，*x* 将被求值并返回其值；否则将对 *y* 求值并返回其值。
请参阅 [**PEP 308**](https://www.python.org/dev/peps/pep-0308) \[https://www.python.org/dev/peps/pep-0308\] 了解有关条件表达式的详情。
## 6.13. lambda 表达式
```
lambda_expr ::= "lambda" [parameter_list] ":" expression
lambda_expr_nocond ::= "lambda" [parameter_list] ":" expression_nocond
```
lambda 表达式（有时称为 lambda 构型）被用于创建匿名函数。 表达式 `lambda parameters: expression` 会产生一个函数对象 。 该未命名对象的行为类似于用以下方式定义的函数:
```
def <lambda>(parameters):
return expression
```
请参阅 [函数定义](compound_stmts.xhtml#function) 了解有关参数列表的句法。 请注意通过 lambda 表达式创建的函数不能包含语句或标注。
## 6.14. 表达式列表
```
expression_list ::= expression ("," expression)* [","]
starred_list ::= starred_item ("," starred_item)* [","]
starred_expression ::= expression | (starred_item ",")* [starred_item]
starred_item ::= expression | "*" or_expr
```
除了作为列表或集合显示的一部分，包含至少一个逗号的表达式列表将生成一个元组。 元组的长度就是列表中表达式的数量。 表达式将从左至右被求值。
一个星号 `*` 表示 *可迭代拆包*。 其操作数必须为一个 [iterable](../glossary.xhtml#term-iterable)。 该可迭代对象将被拆解为迭代项的序列，并被包含于在拆包位置上新建的元组、列表或集合之中。
3\.5 新版功能: 表达式列表中的可迭代对象拆包，最初由 [**PEP 448**](https://www.python.org/dev/peps/pep-0448) \[https://www.python.org/dev/peps/pep-0448\] 提出。
末尾的逗号仅在创建单独元组 (或称 *单例*) 时需要；在所有其他情况下都是可选项。 没有末尾逗号的单独表达式不会创建一个元组，而是产生该表达式的值。 （要创建一个空元组，应使用一对内容为空的圆括号: `()`。）
## 6.15. 求值顺序
Python 按从左至右的顺序对表达式求值。 但注意在对赋值操作求值时，右侧会先于左侧被求值。
在以下几行中，表达式将按其后缀的算术优先顺序被求值。:
```
expr1, expr2, expr3, expr4
(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2
```
## 6.16. 运算符优先级
下表对 Python 中运算符的优先顺序进行了总结，从最低优先级（最后绑定）到最高优先级（最先绑定）。 相同单元格内的运算符具有相同优先级。 除非句法显式地给出，否则运算符均指二元运算。 相同单元格内的运算符均从左至右分组（除了幂运算是从右至左分组）。
请注意比较、成员检测和标识号检测均为相同优先级，并具有如 [比较运算](#comparisons) 一节所描述的从左至右串连特性。
运算符
描述
[`lambda`](#lambda)
lambda 表达式
[`if`](#if-expr) -- `else`
条件表达式
[`or`](#or)
布尔逻辑或 OR
[`and`](#and)
布尔逻辑与 AND
[`not`](#not)`x`
布尔逻辑非 NOT
[`in`](#in), [`not in`](#not-in), [`is`](#is), [`is not`](#is-not), `<`, `<=`, `>`, `>=`, `!=`, `==`
比较运算，包括成员检测和标识号检测
`|`
按位或 OR
`^`
按位异或 XOR
`&`
按位与 AND
`<<`, `>>`
移位
`+`, `-`
加和减
`*`, `@`, `/`, `//`, `%`
乘，矩阵乘，除，整除，取余 [5](#id21)
`+x`, `-x`, `~x`
正，负，按位非 NOT
`**`
乘方 [6](#id22)
[`await`](#await)`x`
await 表达式
`x[index]`, `x[index:index]`, `x(arguments...)`, `x.attribute`
抽取，切片，调用，属性引用
`(expressions...)`, `[expressions...]`, `{key: value...}`, `{expressions...}`
绑定或元组显示，列表显示，字典显示，集合显示
脚注
[1](#id9)虽然 `abs(x%y) < abs(y)` 在数学中必为真，但对于浮点数而言，由于舍入的存在，其在数值上未必为真。 例如，假设在某个平台上的 Python 浮点数为一个 IEEE 754 双精度数值，为了使 `-1e-100 % 1e100` 具有与 `1e100` 相同的正负性，计算结果将是 `-1e-100 + 1e100`，这在数值上正好等于 `1e100`。 函数 [`math.fmod()`](../library/math.xhtml#math.fmod "math.fmod") 返回的结果则会具有与第一个参数相同的正负性，因此在这种情况下将返回 `-1e-100`。 何种方式更适宜取决于具体的应用。
[2](#id10)如果 x 恰好非常接近于 y 的整数倍，则由于舍入的存在 `x//y` 可能会比 `(x-x%y)//y` 大。 在这种情况下，Python 会返回后一个结果，以便保持令 `divmod(x,y)[0] * y + x % y` 尽量接近 `x`.
[3](#id12)Unicode 标准明确区分 *码位* (例如 U+0041) 和 *抽象字符* (例如 "大写拉丁字母 A")。 虽然 Unicode 中的大多数抽象字符都只用一个码位来代表，但也存在一些抽象字符可使用由多个码位组成的序列来表示。 例如，抽象字符 "带有下加符的大写拉丁字母 C" 可以用 U+00C7 码位上的单个 *预设字符* 来表示，也可以用一个 U+0043 码位上的 *基础字符* (大写拉丁字母 C) 加上一个 U+0327 码位上的 *组合字符* (组合下加符) 组成的序列来表示。
对于字符串，比较运算符会按 Unicode 码位级别进行比较。 这可能会违反人类的直觉。 例如，`"\u00C7" == "\u0043\u0327"` 为 `False`，虽然两个字符串都代表同一个抽象字符 "带有下加符的大写拉丁字母 C"。
要按抽象字符级别（即对人类来说更直观的方式）对字符串进行比较，应使用 [`unicodedata.normalize()`](../library/unicodedata.xhtml#unicodedata.normalize "unicodedata.normalize")。
[4](#id13)由于存在自动垃圾收集、空闲列表以及描述器的动态特性，你可能会注意到在特定情况下使用 [`is`](#is) 运算符会出现看似不正常的行为，例如涉及到实例方法或常量之间的比较时就是如此。 更多信息请查看有关它们的文档。
[5](#id15)`%` 运算符也被用于字符串格式化；在此场合下会使用同样的优先级。
[6](#id16)幂运算符 `**` 绑定的紧密程度低于在其右侧的算术或按位一元运算符，也就是说 `2**-1` 为 `0.5`。
### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](simple_stmts.xhtml "7. 简单语句") |
- [上一页](import.xhtml "5. 导入系统") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 语言参考](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