### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](multiprocessing.xhtml "multiprocessing --- 基于进程的并行") |
- [上一页](concurrency.xhtml "并发执行") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 标准库](index.xhtml) »
- [并发执行](concurrency.xhtml) »
- $('.inline-search').show(0); |
# [`threading`](#module-threading "threading: Thread-based parallelism.") --- 基于线程的并行
**源代码:** [Lib/threading.py](https://github.com/python/cpython/tree/3.7/Lib/threading.py) \[https://github.com/python/cpython/tree/3.7/Lib/threading.py\]
- - - - - -
这个模块在较低级的模块 [`_thread`](_thread.xhtml#module-_thread "_thread: Low-level threading API.") 基础上建立较高级的线程接口。参见： [`queue`](queue.xhtml#module-queue "queue: A synchronized queue class.") 模块。
在 3.7 版更改: 这个模块曾经为可选项，但现在总是可用。
注解
虽然他们没有在下面列出，这个模块仍然支持Python 2.x系列的这个模块下以 `camelCase` （驼峰法）命名的方法和函数。
这个模块定义了以下函数：
`threading.``active_count`()返回当前存活的线程类 [`Thread`](#threading.Thread "threading.Thread") 对象。返回的计数等于 [`enumerate()`](#threading.enumerate "threading.enumerate") 返回的列表长度。
`threading.``current_thread`()返回当前对应调用者的控制线程的 [`Thread`](#threading.Thread "threading.Thread") 对象。如果调用者的控制线程不是利用 [`threading`](#module-threading "threading: Thread-based parallelism.") 创建，会返回一个功能受限的虚拟线程对象。
`threading.``get_ident`()返回当前线程的 “线程标识符”。它是一个非零的整数。它的值没有直接含义，主要是用作 magic cookie，比如作为含有线程相关数据的字典的索引。线程标识符可能会在线程退出，新线程创建时被复用。
3\.3 新版功能.
`threading.``enumerate`()以列表形式返回当前所有存活的 [`Thread`](#threading.Thread "threading.Thread") 对象。 该列表包含守护线程，[`current_thread()`](#threading.current_thread "threading.current_thread") 创建的虚拟线程对象和主线程。它不包含已终结的线程和尚未开始的线程。
`threading.``main_thread`()返回主 [`Thread`](#threading.Thread "threading.Thread") 对象。一般情况下，主线程是Python解释器开始时创建的线程。
3\.4 新版功能.
`threading.``settrace`(*func*)为所有 [`threading`](#module-threading "threading: Thread-based parallelism.") 模块开始的线程设置追踪函数。在每个线程的 [`run()`](#threading.Thread.run "threading.Thread.run") 方法被调用前，*func* 会被传递给 [`sys.settrace()`](sys.xhtml#sys.settrace "sys.settrace") 。
`threading.``setprofile`(*func*)为所有 [`threading`](#module-threading "threading: Thread-based parallelism.") 模块开始的线程设置性能测试函数。在每个线程的 [`run()`](#threading.Thread.run "threading.Thread.run") 方法被调用前，*func* 会被传递给 [`sys.setprofile()`](sys.xhtml#sys.setprofile "sys.setprofile") 。
`threading.``stack_size`(\[*size*\])返回创建线程时用的堆栈大小。可选参数 *size* 指定之后新建的线程的堆栈大小，而且一定要是0（根据平台或者默认配置）或者最小是32,768(32KiB)的一个正整数。如果 *size* 没有指定，默认是0。如果不支持改变线程堆栈大小，会抛出 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 错误。如果指定的堆栈大小不合法，会抛出 [`ValueError`](exceptions.xhtml#ValueError "ValueError") 错误并且不会修改堆栈大小。32KiB是当前最小的能保证解释器有足够堆栈空间的堆栈大小。需要注意的是部分平台对于堆栈大小会有特定的限制，例如要求大于32KiB的堆栈大小或者需要根据系统内存页面的整数倍进行分配 - 应当查阅平台文档有关详细信息（4KiB页面比较普遍，在没有更具体信息的情况下，建议的方法是使用4096的倍数作为堆栈大小）。
[适用于](intro.xhtml#availability): Windows，具有 POSIX 线程的系统。
这个模块同时定义了以下常量：
`threading.``TIMEOUT_MAX`阻塞函数（ [`Lock.acquire()`](#threading.Lock.acquire "threading.Lock.acquire"), [`RLock.acquire()`](#threading.RLock.acquire "threading.RLock.acquire"), [`Condition.wait()`](#threading.Condition.wait "threading.Condition.wait"), ...）中形参 *timeout* 允许的最大值。传入超过这个值的 timeout 会抛出 [`OverflowError`](exceptions.xhtml#OverflowError "OverflowError") 异常。
3\.2 新版功能.
这个模块定义了许多类，详见以下部分。
该模块的设计基于 Java的线程模型。 但是，在Java里面，锁和条件变量是每个对象的基础特性，而在Python里面，这些被独立成了单独的对象。 Python 的 [`Thread`](#threading.Thread "threading.Thread") 类只是 Java 的 Thread 类的一个子集；目前还没有优先级，没有线程组，线程还不能被销毁、停止、暂停、恢复或中断。 Java 的 Thread 类的静态方法在实现时会映射为模块级函数。
下列描述的方法都是自动执行的。
## 线程本地数据
线程本地数据是特定线程的数据。管理线程本地数据，只需要创建一个 [`local`](#threading.local "threading.local") （或者一个子类型）的实例并在实例中储存属性：
```
mydata = threading.local()
mydata.x = 1
```
在不同的线程中，实例的值会不同。
*class* `threading.``local`一个代表线程本地数据的类。
更多相关细节和大量示例，参见 `_threading_local` 模块的文档。
## 线程对象
The [`Thread`](#threading.Thread "threading.Thread") class represents an activity that is run in a separate thread of control. There are two ways to specify the activity: by passing a callable object to the constructor, or by overriding the [`run()`](#threading.Thread.run "threading.Thread.run")method in a subclass. No other methods (except for the constructor) should be overridden in a subclass. In other words, *only* override the `__init__()` and [`run()`](#threading.Thread.run "threading.Thread.run") methods of this class.
当线程对象一但被创建，其活动一定会因调用线程的 [`start()`](#threading.Thread.start "threading.Thread.start") 方法开始。这会在独立的控制线程调用 [`run()`](#threading.Thread.run "threading.Thread.run") 方法。
一旦线程活动开始，该线程会被认为是 '存活的' 。当它的 [`run()`](#threading.Thread.run "threading.Thread.run") 方法终结了（不管是正常的还是抛出未被处理的异常），就不是'存活的'。 [`is_alive()`](#threading.Thread.is_alive "threading.Thread.is_alive") 方法用于检查线程是否存活。
其他线程可以调用一个线程的 [`join()`](#threading.Thread.join "threading.Thread.join") 方法。这会阻塞调用该方法的线程，直到被调用 [`join()`](#threading.Thread.join "threading.Thread.join") 方法的线程终结。
线程有名字。名字可以传递给构造函数，也可以通过 [`name`](#threading.Thread.name "threading.Thread.name") 属性读取或者修改。
一个线程可以被标记成一个 "守护线程" 。这个标志的意义是，只有守护线程都终结，整个Python程序才会退出。初始值继承于创建线程。这个标志可以通过 [`daemon`](#threading.Thread.daemon "threading.Thread.daemon") 特征属性或者 *守护* 构造函数参数来设置。
注解
守护线程在程序关闭时会突然关闭。他们的资源（例如已经打开的文档，数据库事务等等）可能没有被正确释放。如果你想你的线程正常停止，设置他们成为非守护模式并且使用合适的信号机制，例如： [`Event`](#threading.Event "threading.Event")。
有个 "主线程" 对象；这对应Python程序里面初始的控制线程。它不是一个守护线程。
"虚拟线程对象" 是可以被创建的。这些是对应于“外部线程”的线程对象，它们是在线程模块外部启动的控制线程，例如直接来自C代码。虚拟线程对象功能受限；他们总是被认为是存活的和守护模式，不能被 [`join()`](#threading.Thread.join "threading.Thread.join") 。因为无法检测外来线程的终结，它们永远不会被删除。
*class* `threading.``Thread`(*group=None*, *target=None*, *name=None*, *args=()*, *kwargs={}*, *\**, *daemon=None*)调用这个构造函数时，必需带有关键字参数。参数如下：
*group* 应该为 `None`；为了日后扩展 `ThreadGroup` 类实现而保留。
*target* 是用于 [`run()`](#threading.Thread.run "threading.Thread.run") 方法调用的可调用对象。默认是 `None`，表示不需要调用任何方法。
*name* 是线程名称。默认情况下，由 "Thread-*N*" 格式构成一个唯一的名称，其中 *N* 是小的十进制数。
*args* 是用于调用目标函数的参数元组。默认是 `()`。
*kwargs* 是用于调用目标函数的关键字参数字典。默认是 `{}`。
如果不是 `None`，线程将被显式的设置为 *守护模式*，不管该线程是否是守护模式。如果是 `None` (默认值)，线程将继承当前线程的守护模式属性。
如果子类型重载了构造函数，它一定要确保在做任何事前，先发起调用基类构造器(`Thread.__init__()`)。
在 3.3 版更改: 加入 *daemon* 参数。
`start`()开始线程活动。
它在一个线程里最多只能被调用一次。它安排对象的 [`run()`](#threading.Thread.run "threading.Thread.run") 方法在一个独立的控制进程中调用。
如果同一个线程对象中调用这个方法的次数大于一次，会抛出 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 。
`run`()代表线程活动的方法。
你可以在子类型里重载这个方法。 标准的 [`run()`](#threading.Thread.run "threading.Thread.run") 方法会对作为 *target* 参数传递给该对象构造器的可调用对象（如果存在）发起调用，并附带从 *args* 和 *kwargs* 参数分别获取的位置和关键字参数。
`join`(*timeout=None*)等待，直到线程终结。这会阻塞调用这个方法的线程，直到被调用 [`join()`](#threading.Thread.join "threading.Thread.join") 的线程终结 -- 不管是正常终结还是抛出未处理异常 -- 或者直到发生超时，超时选项是可选的。
当 *timeout* 参数存在而且不是 `None` 时，它应该是一个用于指定操作超时的以秒为单位的浮点数（或者分数）。因为 [`join()`](#threading.Thread.join "threading.Thread.join") 总是返回 `None` ，所以你一定要在 [`join()`](#threading.Thread.join "threading.Thread.join") 后调用 [`is_alive()`](#threading.Thread.is_alive "threading.Thread.is_alive") 才能判断是否发生超时 -- 如果线程仍然存货，则 [`join()`](#threading.Thread.join "threading.Thread.join") 超时。
当 *timeout* 参数不存在或者是 `None` ，这个操作会阻塞直到线程终结。
一个线程可以被 [`join()`](#threading.Thread.join "threading.Thread.join") 很多次。
如果尝试加入当前线程会导致死锁， [`join()`](#threading.Thread.join "threading.Thread.join") 会引起 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常。如果尝试 [`join()`](#threading.Thread.join "threading.Thread.join") 一个尚未开始的线程，也会抛出相同的异常。
`name`只用于识别的字符串。它没有语义。多个线程可以赋予相同的名称。 初始名称由构造函数设置。
`getName`()`setName`()旧的 [`name`](#threading.Thread.name "threading.Thread.name") 取值/设值 API；直接当做特征属性使用它。
`ident`这个线程的 '线程标识符'，如果线程尚未开始则为 `None` 。这是个非零整数。参见 [`get_ident()`](#threading.get_ident "threading.get_ident") 函数。当一个线程退出而另外一个线程被创建，线程标识符会被复用。即使线程退出后，仍可得到标识符。
`is_alive`()返回线程是否存活。
当 [`run()`](#threading.Thread.run "threading.Thread.run") 方法刚开始直到 [`run()`](#threading.Thread.run "threading.Thread.run") 方法刚结束，这个方法返回 `True` 。模块函数 [`enumerate()`](#threading.enumerate "threading.enumerate") 返回包含所有存活线程的列表。
`daemon`一个表示这个线程是（True）否（False）守护线程的布尔值。一定要在调用 [`start()`](#threading.Thread.start "threading.Thread.start") 前设置好，不然会抛出 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 。初始值继承于创建线程；主线程不是守护线程，因此主线程创建的所有线程默认都是 [`daemon`](#threading.Thread.daemon "threading.Thread.daemon") = `False`。
当没有存活的非守护线程时，整个Python程序才会退出。
`isDaemon`()`setDaemon`()旧的 [`name`](#threading.Thread.name "threading.Thread.name") 取值/设值 API；建议直接当做特征属性使用它。
**CPython implementation detail:** CPython下，因为 [Global Interpreter Lock](../glossary.xhtml#term-global-interpreter-lock)，一个时刻只有一个线程可以执行Python代码（尽管如此，某些性能导向的库可能会克服这个限制）。如果你想让你的应用更好的利用多核计算机的计算性能，推荐你使用 [`multiprocessing`](multiprocessing.xhtml#module-multiprocessing "multiprocessing: Process-based parallelism.") 或者 [`concurrent.futures.ProcessPoolExecutor`](concurrent.futures.xhtml#concurrent.futures.ProcessPoolExecutor "concurrent.futures.ProcessPoolExecutor") 。但是如果你想同时运行多个I/O绑定任务，线程仍然是一个合适的模型。
## 锁对象
原始锁是一个在锁定时不属于特定线程的同步基元组件。在Python中，它是能用的最低级的同步基元组件，由 [`_thread`](_thread.xhtml#module-_thread "_thread: Low-level threading API.") 扩展模块直接实现。
原始锁处于 "锁定" 或者 "非锁定" 两种状态之一。它被创建时为非锁定状态。它有两个基本方法， [`acquire()`](#threading.Lock.acquire "threading.Lock.acquire") 和 [`release()`](#threading.Lock.release "threading.Lock.release") 。当状态为非锁定时， [`acquire()`](#threading.Lock.acquire "threading.Lock.acquire") 将状态改为 锁定 并立即返回。当状态是锁定时， [`acquire()`](#threading.Lock.acquire "threading.Lock.acquire") 将阻塞至其他线程调用 [`release()`](#threading.Lock.release "threading.Lock.release") 将其改为非锁定状态，然后 [`acquire()`](#threading.Lock.acquire "threading.Lock.acquire") 调用重置其为锁定状态并返回。 [`release()`](#threading.Lock.release "threading.Lock.release") 只在锁定状态下调用； 它将状态改为非锁定并立即返回。如果尝试释放一个非锁定的锁，则会引发 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常。
锁同样支持 [上下文管理协议](#with-locks)。
当多个线程在 [`acquire()`](#threading.Lock.acquire "threading.Lock.acquire") 等待状态转变为未锁定被阻塞，然后 [`release()`](#threading.Lock.release "threading.Lock.release") 重置状态为未锁定时，只有一个线程能继续执行；至于哪个等待线程继续执行没有定义，并且会根据实现而不同。
所有方法都是自动执行的。
*class* `threading.``Lock`实现原始锁对象的类。一旦一个线程获得一个锁，会阻塞随后尝试获得锁的线程，直到它被释放；任何线程都可以释放它。
需要注意的是 `Lock` 其实是一个工厂函数，返回平台支持的具体锁类中最有效的版本的实例。
`acquire`(*blocking=True*, *timeout=-1*)可以阻塞或非阻塞地获得锁。
当调用时参数 *blocking* 设置为 `True` （缺省值），阻塞直到锁被释放，然后将锁锁定并返回 `True` 。
在参数 *blocking* 被设置为 `False` 的情况下调用，将不会发生阻塞。如果调用时 *blocking* 设为 `True` 会阻塞，并立即返回 `False` ；否则，将锁锁定并返回 `True`。
当浮点型 *timeout* 参数被设置为正值调用时，只要无法获得锁，将最多阻塞 *timeout* 设定的秒数。*timeout* 参数被设置为 `-1` 时将无限等待。当 *blocking* 为 false 时，*timeout* 指定的值将被忽略。
如果成功获得锁，则返回 `True`，否则返回 `False` (例如发生 *超时* 的时候)。
在 3.2 版更改: 新的 *timeout* 形参。
在 3.2 版更改: 现在如果底层线程实现支持，则可以通过POSIX上的信号中断锁的获取。
`release`()释放一个锁。这个方法可以在任何线程中调用，不单指获得锁的线程。
当锁被锁定，将它重置为未锁定，并返回。如果其他线程正在等待这个锁解锁而被阻塞，只允许其中一个允许。
在未锁定的锁调用时，会引发 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常。
没有返回值。
## 递归锁对象
重入锁是一个可以被同一个线程多次获取的同步基元组件。在内部，它在基元锁的锁定/非锁定状态上附加了 "所属线程" 和 "递归等级" 的概念。在锁定状态下，某些线程拥有锁 ； 在非锁定状态下， 没有线程拥有它。
若要锁定锁，线程调用其 [`acquire()`](#threading.RLock.acquire "threading.RLock.acquire") 方法；一旦线程拥有了锁，方法将返回。若要解锁，线程调用 [`release()`](#threading.Lock.release "threading.Lock.release") 方法。 [`acquire()`](#threading.Lock.acquire "threading.Lock.acquire")/[`release()`](#threading.Lock.release "threading.Lock.release") 对可以嵌套；只有最终 [`release()`](#threading.Lock.release "threading.Lock.release") (最外面一对的 [`release()`](#threading.Lock.release "threading.Lock.release") ) 将锁解开，才能让其他线程继续处理 [`acquire()`](#threading.Lock.acquire "threading.Lock.acquire") 阻塞。
递归锁也支持 [上下文管理协议](#with-locks)。
*class* `threading.``RLock`此类实现了重入锁对象。重入锁必须由获取它的线程释放。一旦线程获得了重入锁，同一个线程再次获取它将不阻塞；线程必须在每次获取它时释放一次。
需要注意的是 `RLock` 其实是一个工厂函数，返回平台支持的具体递归锁类中最有效的版本的实例。
`acquire`(*blocking=True*, *timeout=-1*)可以阻塞或非阻塞地获得锁。
当无参数调用时： 如果这个线程已经拥有锁，递归级别增加一，并立即返回。否则，如果其他线程拥有该锁，则阻塞至该锁解锁。一旦锁被解锁(不属于任何线程)，则抢夺所有权，设置递归等级为一，并返回。如果多个线程被阻塞，等待锁被解锁，一次只有一个线程能抢到锁的所有权。在这种情况下，没有返回值。
当调用时参数 *blocking* 设置为 `True` ，和没带参数调用一样做同样的事，然后返回 `True` 。
当 *blocking* 参数设置为 false 的情况下调用，不进行阻塞。如果一个无参数的调用已经阻塞，立即返回false；否则，执行和无参数调用一样的操作，并返回true。
当浮点数 *timeout* 参数被设置为正值调用时，只要无法获得锁，将最多阻塞 *timeout* 设定的秒数。 如果锁被获取返回 true，如果超时返回false。
在 3.2 版更改: 新的 *timeout* 形参。
`release`()释放锁，自减递归等级。如果减到零，则将锁重置为非锁定状态(不被任何线程拥有)，并且，如果其他线程正被阻塞着等待锁被解锁，则仅允许其中一个线程继续。如果自减后，递归等级仍然不是零，则锁保持锁定，仍由调用线程拥有。
只有当前线程拥有锁才能调用这个方法。如果锁被释放后调用这个方法，会引起 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常。
没有返回值。
## 条件对象
条件变量总是与某种类型的锁对象相关联，锁对象可以通过传入获得，或者在缺省的情况下自动创建。当多个条件变量需要共享同一个锁时，传入一个锁很有用。锁是条件对象的一部分，你不必单独地跟踪它。
条件变量服从 [上下文管理协议](#with-locks)：使用 `with` 语句会在它包围的代码块内获取关联的锁。 [`acquire()`](#threading.Condition.acquire "threading.Condition.acquire") 和 [`release()`](#threading.Condition.release "threading.Condition.release") 方法也能调用关联锁的相关方法。
其它方法必须在持有关联的锁的情况下调用。 [`wait()`](#threading.Condition.wait "threading.Condition.wait") 方法释放锁，然后阻塞直到其它线程调用 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 方法或 [`notify_all()`](#threading.Condition.notify_all "threading.Condition.notify_all") 方法唤醒它。一旦被唤醒， [`wait()`](#threading.Condition.wait "threading.Condition.wait") 方法重新获取锁并返回。它也可以指定超时时间。
The [`notify()`](#threading.Condition.notify "threading.Condition.notify") method wakes up one of the threads waiting for the condition variable, if any are waiting. The [`notify_all()`](#threading.Condition.notify_all "threading.Condition.notify_all")method wakes up all threads waiting for the condition variable.
注意： [`notify()`](#threading.Condition.notify "threading.Condition.notify") 方法和 [`notify_all()`](#threading.Condition.notify_all "threading.Condition.notify_all") 方法并不会释放锁，这意味着被唤醒的线程不会立即从它们的 [`wait()`](#threading.Condition.wait "threading.Condition.wait") 方法调用中返回，而是会在调用了 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 方法或 [`notify_all()`](#threading.Condition.notify_all "threading.Condition.notify_all") 方法的线程最终放弃了锁的所有权后返回。
使用条件变量的典型编程风格是将锁用于同步某些共享状态的权限，那些对状态的某些特定改变感兴趣的线程，它们重复调用 [`wait()`](#threading.Condition.wait "threading.Condition.wait") 方法，直到看到所期望的改变发生；而对于修改状态的线程，它们将当前状态改变为可能是等待者所期待的新状态后，调用 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 方法或者 [`notify_all()`](#threading.Condition.notify_all "threading.Condition.notify_all") 方法。例如，下面的代码是一个通用的无限缓冲区容量的生产者-消费者情形：
```
# Consume one item
with cv:
while not an_item_is_available():
cv.wait()
get_an_available_item()
# Produce one item
with cv:
make_an_item_available()
cv.notify()
```
使用 `while` 循环检查所要求的条件成立与否是有必要的，因为 [`wait()`](#threading.Condition.wait "threading.Condition.wait") 方法可能要经过不确定长度的时间后才会返回，而此时导致 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 方法调用的那个条件可能已经不再成立。这是多线程编程所固有的问题。 [`wait_for()`](#threading.Condition.wait_for "threading.Condition.wait_for") 方法可自动化条件检查，并简化超时计算。
```
# Consume an item
with cv:
cv.wait_for(an_item_is_available)
get_an_available_item()
```
选择 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 还是 [`notify_all()`](#threading.Condition.notify_all "threading.Condition.notify_all") ，取决于一次状态改变是只能被一个还是能被多个等待线程所用。例如在一个典型的生产者-消费者情形中，添加一个项目到缓冲区只需唤醒一个消费者线程。
*class* `threading.``Condition`(*lock=None*)实现条件变量对象的类。一个条件变量对象允许一个或多个线程在被其它线程所通知之前进行等待。
如果给出了非 `None` 的 *lock* 参数，则它必须为 [`Lock`](#threading.Lock "threading.Lock") 或者 [`RLock`](#threading.RLock "threading.RLock") 对象，并且它将被用作底层锁。否则，将会创建新的 [`RLock`](#threading.RLock "threading.RLock") 对象，并将其用作底层锁。
在 3.3 版更改: 从工厂函数变为类。
`acquire`(*\*args*)请求底层锁。此方法调用底层锁的相应方法，返回值是底层锁相应方法的返回值。
`release`()释放底层锁。此方法调用底层锁的相应方法。没有返回值。
`wait`(*timeout=None*)等待直到被通知或发生超时。如果线程在调用此方法时没有获得锁，将会引发 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常。
这个方法释放底层锁，然后阻塞，直到在另外一个线程中调用同一个条件变量的 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 或 [`notify_all()`](#threading.Condition.notify_all "threading.Condition.notify_all") 唤醒它，或者直到可选的超时发生。一旦被唤醒或者超时，它重新获得锁并返回。
当提供了 *timeout* 参数且不是 `None` 时，它应该是一个浮点数，代表操作的超时时间，以秒为单位（可以为小数）。
当底层锁是个 [`RLock`](#threading.RLock "threading.RLock") ，不会使用它的 [`release()`](#threading.Condition.release "threading.Condition.release") 方法释放锁，因为当它被递归多次获取时，实际上可能无法解锁。相反，使用了 [`RLock`](#threading.RLock "threading.RLock") 类的内部接口，即使多次递归获取它也能解锁它。 然后，在重新获取锁时，使用另一个内部接口来恢复递归级别。
返回 `True` ，除非提供的 *timeout* 过期，这种情况下返回 `False`。
在 3.2 版更改: 很明显，方法总是返回 `None`。
`wait_for`(*predicate*, *timeout=None*)等待，直到条件计算为真。 *predicate* 应该是一个可调用对象而且它的返回值可被解释为一个布尔值。可以提供 *timeout* 参数给出最大等待时间。
这个实用方法会重复地调用 [`wait()`](#threading.Condition.wait "threading.Condition.wait") 直到满足判断式或者发生超时。返回值是判断式最后一个返回值，而且如果方法发生超时会返回 `False` 。
忽略超时功能，调用此方法大致相当于编写:
```
while not predicate():
cv.wait()
```
因此，规则同样适用于 [`wait()`](#threading.Condition.wait "threading.Condition.wait") ：锁必须在被调用时保持获取，并在返回时重新获取。 随着锁定执行判断式。
3\.2 新版功能.
`notify`(*n=1*)默认唤醒一个等待这个条件的线程。如果调用线程在没有获得锁的情况下调用这个方法，会引发 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常。
这个方法唤醒最多 *n* 个正在等待这个条件变量的线程；如果没有线程在等待，这是一个空操作。
当前实现中，如果至少有 *n* 个线程正在等待，准确唤醒 *n* 个线程。但是依赖这个行为并不安全。未来，优化的实现有时会唤醒超过 *n* 个线程。
注意：被唤醒的线程实际上不会返回它调用的 [`wait()`](#threading.Condition.wait "threading.Condition.wait") ，直到它可以重新获得锁。因为 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 不会释放锁，只有它的调用者应该这样做。
`notify_all`()唤醒所有正在等待这个条件的线程。这个方法行为与 [`notify()`](#threading.Condition.notify "threading.Condition.notify") 相似，但并不只唤醒单一线程，而是唤醒所有等待线程。如果调用线程在调用这个方法时没有获得锁，会引发 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常。
## 信号量对象
这是计算机科学史上最古老的同步原语之一，早期的荷兰科学家 Edsger W. Dijkstra 发明了它。（他使用名称 `P()` 和 `V()` 而不是 [`acquire()`](#threading.Semaphore.acquire "threading.Semaphore.acquire") 和 [`release()`](#threading.Semaphore.release "threading.Semaphore.release") ）。
一个信号量管理一个内部计数器，该计数器因 [`acquire()`](#threading.Semaphore.acquire "threading.Semaphore.acquire") 方法的调用而递减，因 [`release()`](#threading.Semaphore.release "threading.Semaphore.release") 方法的调用而递增。 计数器的值永远不会小于零；当 [`acquire()`](#threading.Semaphore.acquire "threading.Semaphore.acquire") 方法发现计数器为零时，将会阻塞，直到其它线程调用 [`release()`](#threading.Semaphore.release "threading.Semaphore.release") 方法。
信号量对象也支持 [上下文管理协议](#with-locks) 。
*class* `threading.``Semaphore`(*value=1*)该类实现信号量对象。信号量对象管理一个原子性的计数器，代表 [`release()`](#threading.Semaphore.release "threading.Semaphore.release") 方法的调用次数减去 [`acquire()`](#threading.Semaphore.acquire "threading.Semaphore.acquire") 的调用次数再加上一个初始值。如果需要， [`acquire()`](#threading.Semaphore.acquire "threading.Semaphore.acquire") 方法将会阻塞直到可以返回而不会使得计数器变成负数。在没有显式给出 *value* 的值时，默认为1。
可选参数 *value* 赋予内部计数器初始值，默认值为 `1` 。如果 *value* 被赋予小于0的值，将会引发 [`ValueError`](exceptions.xhtml#ValueError "ValueError") 异常。
在 3.3 版更改: 从工厂函数变为类。
`acquire`(*blocking=True*, *timeout=None*)获取一个信号量。
在不带参数的情况下调用时：
- 如果在进入时，内部计数器的值大于0，将其减1并立即返回true。
- 如果在进入时，内部计数器的值为0，将会阻塞直到被 [`release()`](#threading.Semaphore.release "threading.Semaphore.release") 方法的调用唤醒。一旦被唤醒（并且计数器值大于0），将计数器值减少1并返回true。线程会被每次 [`release()`](#threading.Semaphore.release "threading.Semaphore.release") 方法的调用唤醒。线程被唤醒的次序是不确定的。
在参数 *blocking* 被设置为false的情况下调用，将不会发生阻塞。如果不带参数的调用会发生阻塞的话，带参数的调用在相同情况下将会立即返回false。否则，执行和不带参数的调用一样的操作并返回true。
当参数 *timeout* 不为 `None` 时，将最多阻塞 *timeout* 秒。如果未能在时间间隔内成功获取信号量，将返回false，否则返回true。
在 3.2 版更改: 新的 *timeout* 形参。
`release`()释放一个信号量，将内部计数器的值增加1。当计数器原先的值为0且有其它线程正在等待它再次大于0时，唤醒正在等待的线程。
*class* `threading.``BoundedSemaphore`(*value=1*)该类实现有界信号量。有界信号量通过检查以确保它当前的值不会超过初始值。如果超过了初始值，将会引发 [`ValueError`](exceptions.xhtml#ValueError "ValueError") 异常。在大多情况下，信号量用于保护数量有限的资源。如果信号量被释放的次数过多，则表明出现了错误。没有指定时， *value* 的值默认为1。
在 3.3 版更改: 从工厂函数变为类。
### [`Semaphore`](#threading.Semaphore "threading.Semaphore") 例子
信号量通常用于保护数量有限的资源，例如数据库服务器。在资源数量固定的任何情况下，都应该使用有界信号量。在生成任何工作线程前，应该在主线程中初始化信号量。
```
maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)
```
工作线程生成后，当需要连接服务器时，这些线程将调用信号量的 acquire 和 release 方法：
```
with pool_sema:
conn = connectdb()
try:
# ... use connection ...
finally:
conn.close()
```
使用有界信号量能减少这种编程错误：信号量的释放次数多于其请求次数。
## 事件对象
这是线程之间通信的最简单机制之一：一个线程发出事件信号，而其他线程等待该信号。
一个事件对象管理一个内部标志，调用 [`set()`](#threading.Event.set "threading.Event.set") 方法可将其设置为true，调用 [`clear()`](#threading.Event.clear "threading.Event.clear") 方法可将其设置为false，调用 [`wait()`](#threading.Event.wait "threading.Event.wait") 方法将进入阻塞直到标志为true。
*class* `threading.``Event`实现事件对象的类。事件对象管理一个内部标志，调用 [`set()`](#threading.Event.set "threading.Event.set") 方法可将其设置为true。调用 [`clear()`](#threading.Event.clear "threading.Event.clear") 方法可将其设置为false。调用 [`wait()`](#threading.Event.wait "threading.Event.wait") 方法将进入阻塞直到标志为true。这个标志初始时为false。
在 3.3 版更改: 从工厂函数变为类。
`is_set`()当且仅当内部标志为true时返回true。
`set`()将内部标志设置为true。所有正在等待这个事件的线程将被唤醒。当标志为true时，调用 [`wait()`](#threading.Event.wait "threading.Event.wait") 方法的线程不会被被阻塞。
`clear`()将内部标志设置为false。之后调用 [`wait()`](#threading.Event.wait "threading.Event.wait") 方法的线程将会被阻塞，直到调用 [`set()`](#threading.Event.set "threading.Event.set") 方法将内部标志再次设置为true。
`wait`(*timeout=None*)阻塞线程直到内部变量为true。如果调用时内部标志为true，将立即返回。否则将阻塞线程，直到调用 [`set()`](#threading.Event.set "threading.Event.set") 方法将标志设置为true或者发生可选的超时。
当提供了timeout参数且不是 `None` 时，它应该是一个浮点数，代表操作的超时时间，以秒为单位（可以为小数）。
当内部标志在调用wait进入阻塞后被设置为true，或者调用wait时已经被设置为true时，方法返回true。 也就是说，除非设定了超时且发生了超时的情况下将会返回false，其他情况该方法都将返回 `True` 。
在 3.1 版更改: 很明显，方法总是返回 `None`。
## 定时器对象
此类表示一个操作应该在等待一定的时间之后运行 --- 相当于一个定时器。 [`Timer`](#threading.Timer "threading.Timer") 类是 [`Thread`](#threading.Thread "threading.Thread") 类的子类，因此可以像一个自定义线程一样工作。
与线程一样，通过调用 `start()` 方法启动定时器。而 [`cancel()`](#threading.Timer.cancel "threading.Timer.cancel") 方法可以停止计时器（在计时结束前）， 定时器在执行其操作之前等待的时间间隔可能与用户指定的时间间隔不完全相同。
例如:
```
def hello():
print("hello, world")
t = Timer(30.0, hello)
t.start() # after 30 seconds, "hello, world" will be printed
```
*class* `threading.``Timer`(*interval*, *function*, *args=None*, *kwargs=None*)创建一个定时器，在经过 *interval* 秒的间隔事件后，将会用参数 *args* 和关键字参数 *kwargs* 调用 *function*。如果 *args* 为 `None` （默认值），则会使用一个空列表。如果 *kwargs* 为 `None` （默认值），则会使用一个空字典。
在 3.3 版更改: 从工厂函数变为类。
`cancel`()停止定时器并取消执行计时器将要执行的操作。仅当计时器仍处于等待状态时有效。
## 栅栏对象
3\.2 新版功能.
栅栏类提供一个简单的同步原语，用于应对固定数量的线程需要彼此相互等待的情况。线程调用 [`wait()`](#threading.Barrier.wait "threading.Barrier.wait") 方法后将阻塞，直到所有线程都调用了 [`wait()`](#threading.Barrier.wait "threading.Barrier.wait") 方法。此时所有线程将被同时释放。
栅栏对象可以被多次使用，但进程的数量不能改变。
这是一个使用简便的方法实现客户端进程与服务端进程同步的例子：
```
b = Barrier(2, timeout=5)
def server():
start_server()
b.wait()
while True:
connection = accept_connection()
process_server_connection(connection)
def client():
b.wait()
while True:
connection = make_connection()
process_client_connection(connection)
```
*class* `threading.``Barrier`(*parties*, *action=None*, *timeout=None*)创建一个需要 *parties* 个线程的栅栏对象。如果提供了可调用的 *action* 参数，它会在所有线程被释放时在其中一个线程中自动调用。 *timeout* 是默认的超时时间，如果没有在 [`wait()`](#threading.Barrier.wait "threading.Barrier.wait") 方法中指定超时时间的话。
`wait`(*timeout=None*)冲出栅栏。当栅栏中所有线程都已经调用了这个函数，它们将同时被释放。如果提供了 *timeout* 参数，这里的 *timeout* 参数优先于创建栅栏对象时提供的 *timeout* 参数。
函数返回值是一个整数，取值范围在0到 *parties* -- 1，在每个线程中的返回值不相同。可用于从所有线程中选择唯一的一个线程执行一些特别的工作。例如：
```
i = barrier.wait()
if i == 0:
# Only one thread needs to print this
print("passed the barrier")
```
如果创建栅栏对象时在构造函数中提供了 *action* 参数，它将在其中一个线程释放前被调用。如果此调用引发了异常，栅栏对象将进入损坏态。
如果发生了超时，栅栏对象将进入破损态。
如果栅栏对象进入破损态，或重置栅栏时仍有线程等待释放，将会引发 [`BrokenBarrierError`](#threading.BrokenBarrierError "threading.BrokenBarrierError") 异常。
`reset`()重置栅栏为默认的初始态。如果栅栏中仍有线程等待释放，这些线程将会收到 [`BrokenBarrierError`](#threading.BrokenBarrierError "threading.BrokenBarrierError") 异常。
注意使用此函数时，如果有某些线程状态未知，则可能需其它的同步来确保线程已被释放。如果栅栏进入了破损态，最好废弃它并新建一个栅栏。
`abort`()使栅栏进入破损态。这将导致所有已经调用和未来调用的 [`wait()`](#threading.Barrier.wait "threading.Barrier.wait") 方法中引发 [`BrokenBarrierError`](#threading.BrokenBarrierError "threading.BrokenBarrierError") 异常。使用这个方法的一种情况是需要中止程序以避免死锁。
更好的方式是：创建栅栏时提供一个合理的超时时间，来自动避免某个线程出错。
`parties`冲出栅栏所需要的线程数量。
`n_waiting`当前时刻正在栅栏中阻塞的线程数量。
`broken`一个布尔值，值为 `True` 表明栅栏为破损态。
*exception* `threading.``BrokenBarrierError`异常类，是 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 异常的子类，在 [`Barrier`](#threading.Barrier "threading.Barrier") 对象重置时仍有线程阻塞时和对象进入破损态时被引发。
## 在 `with` 语句中使用锁、条件和信号量
这个模块提供的带有 `acquire()` 和 `release()` 方法的对象，可以被用作 [`with`](../reference/compound_stmts.xhtml#with) 语句的上下文管理器。当进入语句块时 `acquire()` 方法会被调用，退出语句块时 `release()` 会被调用。因此，以下片段:
```
with some_lock:
# do something...
```
相当于:
```
some_lock.acquire()
try:
# do something...
finally:
some_lock.release()
```
现在 [`Lock`](#threading.Lock "threading.Lock") 、 [`RLock`](#threading.RLock "threading.RLock") 、 [`Condition`](#threading.Condition "threading.Condition") 、 [`Semaphore`](#threading.Semaphore "threading.Semaphore") 和 [`BoundedSemaphore`](#threading.BoundedSemaphore "threading.BoundedSemaphore") 对象可以用作 [`with`](../reference/compound_stmts.xhtml#with) 语句的上下文管理器。
### 导航
- [索引](../genindex.xhtml "总目录")
- [模块](../py-modindex.xhtml "Python 模块索引") |
- [下一页](multiprocessing.xhtml "multiprocessing --- 基于进程的并行") |
- [上一页](concurrency.xhtml "并发执行") |
- 
- [Python](https://www.python.org/) »
- zh\_CN 3.7.3 [文档](../index.xhtml) »
- [Python 标准库](index.xhtml) »
- [并发执行](concurrency.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