### 導航
- [索引](../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