### 導航
- [索引](../genindex.xhtml "總目錄")
- [模塊](../py-modindex.xhtml "Python 模塊索引") |
- [下一頁](extending.xhtml "擴展/嵌入常見問題") |
- [上一頁](design.xhtml "設計和歷史常見問題") |
- 
- [Python](https://www.python.org/) ?
- zh\_CN 3.7.3 [文檔](../index.xhtml) ?
- [Python 常見問題](index.xhtml) ?
- $('.inline-search').show(0); |
# [代碼庫和插件 FAQ](#id2)
目錄
- [代碼庫和插件 FAQ](#library-and-extension-faq)
- [通用的代碼庫問題](#general-library-questions)
- [如何找到可以用來做 XXX 的模塊或應用?](#how-do-i-find-a-module-or-application-to-perform-task-x)
- [math.py(socket.py,regex.py 等)的源文件在哪?](#where-is-the-math-py-socket-py-regex-py-etc-source-file)
- [在 Unix 中怎樣讓 Python 腳本可執行?](#how-do-i-make-a-python-script-executable-on-unix)
- [Python 中有 curses/termcap 包嗎?](#is-there-a-curses-termcap-package-for-python)
- [Python 中存在類似 C 的 onexit() 函數的東西嗎?](#is-there-an-equivalent-to-c-s-onexit-in-python)
- [為什么我的信號處理函數不能工作?](#why-don-t-my-signal-handlers-work)
- [通用任務](#common-tasks)
- [怎樣測試 Python 程序或組件?](#how-do-i-test-a-python-program-or-component)
- [怎樣用 docstring 創建文檔?](#how-do-i-create-documentation-from-doc-strings)
- [怎樣一次只獲取一個按鍵?](#how-do-i-get-a-single-keypress-at-a-time)
- [線程相關](#threads)
- [程序中怎樣使用線程?](#how-do-i-program-using-threads)
- [我的線程都沒有運行,為什么?](#none-of-my-threads-seem-to-run-why)
- [如何將任務分配給多個工作線程?](#how-do-i-parcel-out-work-among-a-bunch-of-worker-threads)
- [怎樣修改全局變量是線程安全的?](#what-kinds-of-global-value-mutation-are-thread-safe)
- [不能刪除全局解釋器鎖嗎?](#can-t-we-get-rid-of-the-global-interpreter-lock)
- [輸入輸出](#input-and-output)
- [怎樣刪除文件?(以及其他文件相關的問題……)](#how-do-i-delete-a-file-and-other-file-questions)
- [怎樣復制文件?](#how-do-i-copy-a-file)
- [怎樣讀取(或寫入)二進制數據?](#how-do-i-read-or-write-binary-data)
- [似乎 os.popen() 創建的管道不能使用 os.read(),這是為什么?](#i-can-t-seem-to-use-os-read-on-a-pipe-created-with-os-popen-why)
- [怎樣訪問(RS232)串口?](#how-do-i-access-the-serial-rs232-port)
- [為什么關閉 sys.stdout(stdin,stderr)并不會真正關掉它?](#why-doesn-t-closing-sys-stdout-stdin-stderr-really-close-it)
- [網絡 / Internet 編程](#network-internet-programming)
- [Python 中的 WWW 工具是什么?](#what-www-tools-are-there-for-python)
- [怎樣模擬發送 CGI 表單(METHOD=POST)?](#how-can-i-mimic-cgi-form-submission-method-post)
- [生成 HTML 需要使用什么模塊?](#what-module-should-i-use-to-help-with-generating-html)
- [怎樣使用 Python 腳本發送郵件?](#how-do-i-send-mail-from-a-python-script)
- [socket 的 connect() 方法怎樣避免阻塞?](#how-do-i-avoid-blocking-in-the-connect-method-of-a-socket)
- [數據庫](#databases)
- [Python 中有數據庫包的接口嗎?](#are-there-any-interfaces-to-database-packages-in-python)
- [在 Python 中如何實現持久化對象?](#how-do-you-implement-persistent-objects-in-python)
- [數學和數字](#mathematics-and-numerics)
- [Python 中怎樣生成隨機數?](#how-do-i-generate-random-numbers-in-python)
## [通用的代碼庫問題](#id3)
### [如何找到可以用來做 XXX 的模塊或應用?](#id4)
在 [代碼庫參考](../library/index.xhtml#library-index) 中查找是否有適合的標準庫模塊。(如果你已經了解標準庫的內容,可以跳過這一步)
對于第三方軟件包,請搜索 [Python Package Index](https://pypi.org) \[https://pypi.org\] 或是 [Google](https://www.google.com) \[https://www.google.com\] 等其他搜索引擎。用“Python”加上一兩個你需要的關鍵字通常會找到有用的東西。
### [math.py(socket.py,regex.py 等)的源文件在哪?](#id5)
如果找不到模塊的源文件,可能它是一個內建的模塊,或是使用 C,C++ 或其他編譯型語言實現的動態加載模塊。這種情況下可能是沒有源碼文件的,類似 `mathmodule.c` 這樣的文件會存放在 C 代碼目錄中(但不在 Python 目錄中)。
Python 中(至少)有三類模塊:
1. 使用 Python 編寫的模塊(.py);
2. 使用 C 編寫的動態加載模塊(.dll,.pyd,.so,.sl 等);
3. 使用 C 編寫并鏈接到解釋器的模塊,要獲取此列表,輸入:
```
import sys
print(sys.builtin_module_names)
```
### [在 Unix 中怎樣讓 Python 腳本可執行?](#id6)
你需要做兩件事:文件必須是可執行的,并且第一行需要以 `#!` 開頭,后面跟上 Python 解釋器的路徑。
第一點可以用執行 `chmod +x scriptfile` 或是 `chmod 755 scriptfile` 做到。
第二點有很多種做法,最直接的方式是:
```
#!/usr/local/bin/python
```
在文件第一行,使用你所在平臺上的 Python 解釋器的路徑。
如果你希望腳本不依賴 Python 解釋器的具體路徑,你也可以使用 **env** 程序。假設你的 Python 解釋器所在目錄已經添加到了 `PATH` 環境變量中,幾乎所有的類 Unix 系統都支持下面的寫法:
```
#!/usr/bin/env python
```
*不要* 在 CGI 腳本中這樣做。CGI 腳本的 `PATH` 環境變量通常會非常精簡,所以你必須使用解釋器的完整絕對路徑。
有時候,用戶的環境變量如果太長,可能會導致 **/usr/bin/env** 執行失敗;又或者甚至根本就不存在 env 程序。在這種情況下,你可以嘗試使用下面的 hack 方法(來自 Alex Rezinsky):
```
#! /bin/sh
""":"
exec python $0 ${1+"$@"}
"""
```
這樣做有一個小小的缺點,它會定義腳本的 \_\_doc\_\_ 字符串。不過可以這樣修復:
```
__doc__ = """...Whatever..."""
```
### [Python 中有 curses/termcap 包嗎?](#id7)
對于類 Unix 系統:標準 Python 源碼發行版會在 [Modules](https://github.com/python/cpython/tree/3.7/Modules) \[https://github.com/python/cpython/tree/3.7/Modules\] 子目錄中附帶 curses 模塊,但默認并不會編譯。(注意:在 Windows 平臺下不可用 —— Windows 中沒有 curses 模塊。)
[`curses`](../library/curses.xhtml#module-curses "curses: An interface to the curses library, providing portable terminal handling. (Unix)") 模塊支持基本的 curses 特性,同時也支持 ncurses 和 SYSV curses 中的很多額外功能,比如顏色、不同的字符集支持、填充和鼠標支持。這意味著這個模塊不兼容只有 BSD curses 模塊的操作系統,但是目前仍在維護的系統應該都不會存在這種情況。
對于 Windows 平臺:使用 [consolelib 模塊](http://effbot.org/zone/console-index.htm) \[http://effbot.org/zone/console-index.htm\].
### [Python 中存在類似 C 的 onexit() 函數的東西嗎?](#id8)
[`atexit`](../library/atexit.xhtml#module-atexit "atexit: Register and execute cleanup functions.") 模塊提供了一個與 C 的 `onexit()` 函數類似的注冊函數。
### [為什么我的信號處理函數不能工作?](#id9)
最常見的問題是信號處理函數沒有正確定義參數列表。它會被這樣調用:
```
handler(signum, frame)
```
因此函數應該定義兩個參數:
```
def handler(signum, frame):
...
```
## [通用任務](#id10)
### [怎樣測試 Python 程序或組件?](#id11)
Python 帶有兩個測試框架。[`doctest`](../library/doctest.xhtml#module-doctest "doctest: Test pieces of code within docstrings.") 模塊從模塊的 docstring 中尋找示例并執行,對比輸出是否與 docstring 中給出的是否一致。
[`unittest`](../library/unittest.xhtml#module-unittest "unittest: Unit testing framework for Python.") 模塊是一個模仿 Java 和 Smalltalk 測試框架的更棒的測試框架。
為了使測試更容易,你應該在程序中使用良好的模塊化設計。程序中的絕大多數功能都應該用函數或類方法封裝 —— 有時這樣做會有額外驚喜,程序會運行得更快(因為局部變量比全局變量訪問要快)。除此之外,程序應該避免依賴可變的局部變量,這會使得測試困難許多。
程序的“全局主邏輯”應該盡量簡單:
```
if __name__ == "__main__":
main_logic()
```
并放置在程序主模塊的最后面。
一旦你的程序已經用函數和類完善地組織起來,你就應該編寫測試函數來測試其行為。可以使用自動執行一系列測試函數的測試集與每個模塊進行關聯。聽起來似乎需要大量的工作,但是因為 Python 非常簡潔和靈活,所以實際上會相當簡單。在編寫“生產代碼”的同時別忘了也要編寫測試函數,你會發現編程會變得更愉快、更有趣,因為這樣會使得發現 bug 和設計缺陷更加容易。
程序主模塊之外的其他“輔助模塊”中可以增加自測試的入口。
```
if __name__ == "__main__":
self_test()
```
通過使用 Python 實現的“假”接口,即使是需要與復雜的外部接口交互的程序也可以在外部接口不可用時進行測試。
### [怎樣用 docstring 創建文檔?](#id12)
[`pydoc`](../library/pydoc.xhtml#module-pydoc "pydoc: Documentation generator and online help system.") 模塊可以用 Python 源碼中的 docstring 創建 HTML 文件。也可以使用 [epydoc](http://epydoc.sourceforge.net/) \[http://epydoc.sourceforge.net/\] 來只通過 docstring 創建 API 文檔。[Sphinx](http://sphinx-doc.org) \[http://sphinx-doc.org\] 也可以引入 docstring 的內容。
### [怎樣一次只獲取一個按鍵?](#id13)
在類 Unix 系統中有多種方案。最直接的方法是使用 curses,但是 curses 模塊太大了,難以學習。
## [線程相關](#id14)
### [程序中怎樣使用線程?](#id15)
一定要使用 [`threading`](../library/threading.xhtml#module-threading "threading: Thread-based parallelism.") 模塊,不要使用 [`_thread`](../library/_thread.xhtml#module-_thread "_thread: Low-level threading API.") 模塊。[`threading`](../library/threading.xhtml#module-threading "threading: Thread-based parallelism.") 模塊對 [`_thread`](../library/_thread.xhtml#module-_thread "_thread: Low-level threading API.") 模塊提供的底層線程原語做了更易用的抽象。
Aahz 的非常實用的 threading 教程中有一些幻燈片;可以參閱 <http://www.pythoncraft.com/OSCON2001/> 。
### [我的線程都沒有運行,為什么?](#id16)
一旦主線程退出,所有的子線程都會被殺掉。你的主線程運行得太快了,子線程還沒來得及工作。
簡單的解決方法是在程序中加一個時間足夠長的 sleep,讓子線程能夠完成運行。
```
import threading, time
def thread_task(name, n):
for i in range(n):
print(name, i)
for i in range(10):
T = threading.Thread(target=thread_task, args=(str(i), i))
T.start()
time.sleep(10) # <---------------------------!
```
但目前(在許多平臺上)線程不是并行運行的,而是按順序依次執行!原因是系統線程調度器在前一個線程阻塞之前不會啟動新線程。
簡單的解決方法是在運行函數的開始處加一個時間很短的 sleep。
```
def thread_task(name, n):
time.sleep(0.001) # <--------------------!
for i in range(n):
print(name, i)
for i in range(10):
T = threading.Thread(target=thread_task, args=(str(i), i))
T.start()
time.sleep(10)
```
比起用 [`time.sleep()`](../library/time.xhtml#time.sleep "time.sleep") 猜一個合適的等待時間,使用信號量機制會更好些。有一個辦法是使用 [`queue`](../library/queue.xhtml#module-queue "queue: A synchronized queue class.") 模塊創建一個 queue 對象,讓每一個線程在運行結束時 append 一個令牌到 queue 對象中,主線程中從 queue 對象中讀取與線程數量一致的令牌數量即可。
### [如何將任務分配給多個工作線程?](#id17)
最簡單的方法是使用新的 [`concurrent.futures`](../library/concurrent.futures.xhtml#module-concurrent.futures "concurrent.futures: Execute computations concurrently using threads or processes.") 模塊,尤其是其中的 [`ThreadPoolExecutor`](../library/concurrent.futures.xhtml#concurrent.futures.ThreadPoolExecutor "concurrent.futures.ThreadPoolExecutor") 類。
或者,如果你想更好地控制分發算法,你也可以自己寫邏輯實現。使用 [`queue`](../library/queue.xhtml#module-queue "queue: A synchronized queue class.") 模塊來創建任務列表隊列。[`Queue`](../library/queue.xhtml#queue.Queue "queue.Queue") 類維護一個了一個存有對象的列表,提供了 `.put(obj)` 方法添加元素,并且可以用 `.get()` 方法獲取元素。這個類會使用必要的加鎖操作,以此確保每個任務只會執行一次。
這是一個簡單的例子:
```
import threading, queue, time
# The worker thread gets jobs off the queue. When the queue is empty, it
# assumes there will be no more work and exits.
# (Realistically workers will run until terminated.)
def worker():
print('Running worker')
time.sleep(0.1)
while True:
try:
arg = q.get(block=False)
except queue.Empty:
print('Worker', threading.currentThread(), end=' ')
print('queue empty')
break
else:
print('Worker', threading.currentThread(), end=' ')
print('running with argument', arg)
time.sleep(0.5)
# Create queue
q = queue.Queue()
# Start a pool of 5 workers
for i in range(5):
t = threading.Thread(target=worker, name='worker %i' % (i+1))
t.start()
# Begin adding work to the queue
for i in range(50):
q.put(i)
# Give threads time to run
print('Main thread sleeping')
time.sleep(5)
```
運行時會產生如下輸出:
```
Running worker
Running worker
Running worker
Running worker
Running worker
Main thread sleeping
Worker <Thread(worker 1, started 130283832797456)> running with argument 0
Worker <Thread(worker 2, started 130283824404752)> running with argument 1
Worker <Thread(worker 3, started 130283816012048)> running with argument 2
Worker <Thread(worker 4, started 130283807619344)> running with argument 3
Worker <Thread(worker 5, started 130283799226640)> running with argument 4
Worker <Thread(worker 1, started 130283832797456)> running with argument 5
...
```
查看模塊的文檔以獲取更多信息;[`Queue`](../library/queue.xhtml#queue.Queue "queue.Queue") 類提供了多種接口。
### [怎樣修改全局變量是線程安全的?](#id18)
Python VM 內部會使用 [global interpreter lock](../glossary.xhtml#term-global-interpreter-lock) (GIL)來確保同一時間只有一個線程運行。通常 Python 只會在字節碼指令之間切換線程;切換的頻率可以通過設置 [`sys.setswitchinterval()`](../library/sys.xhtml#sys.setswitchinterval "sys.setswitchinterval") 指定。從 Python 程序的角度來看,每一條字節碼指令以及每一條指令對應的 C 代碼實現都是原子的。
理論上說,具體的結果要看具體的 PVM 字節碼實現對指令的解釋。而實際上,對內建類型(int,list,dict 等)的共享變量的“類原子”操作都是原子的。
舉例來說,下面的操作是原子的(L、L1、L2 是列表,D、D1、D2 是字典,x、y 是對象,i,j 是 int 變量):
```
L.append(x)
L1.extend(L2)
x = L[i]
x = L.pop()
L1[i:j] = L2
L.sort()
x = y
x.field = y
D[x] = y
D1.update(D2)
D.keys()
```
這些不是原子的:
```
i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1
```
覆蓋其他對象的操作會在其他對象的引用計數變成 0 時觸發其 [`__del__()`](../reference/datamodel.xhtml#object.__del__ "object.__del__") 方法,這可能會產生一些影響。對字典和列表進行大量操作時尤其如此。如果有疑問的話,使用互斥鎖!
### [不能刪除全局解釋器鎖嗎?](#id19)
[global interpreter lock](../glossary.xhtml#term-global-interpreter-lock) (GIL)通常被視為 Python 在高端多核服務器上開發時的阻力,因為(幾乎)所有 Python 代碼只有在獲取到 GIL 時才能運行,所以多線程的 Python 程序只能有效地使用一個 CPU。
在 Python 1.5 時代,Greg Stein 開發了一個完整的補丁包(“free threadings” 補丁),移除了 GIL,并用粒度更合適的鎖來代替。Adam Olsen 最近也在他的 [python-safethread](https://code.google.com/archive/p/python-safethread) \[https://code.google.com/archive/p/python-safethread\] 項目里做了類似的實驗。不幸的是,由于為了移除 GIL 而使用了大量細粒度的鎖,這兩個實驗在單線程測試中的性能都有明顯的下降(至少慢 30%)。
但這并意味著你不能在多核機器上很好地使用 Python!你只需將任務劃分為多\*進程\*,而不是多\*線程\*。新的 [`concurrent.futures`](../library/concurrent.futures.xhtml#module-concurrent.futures "concurrent.futures: Execute computations concurrently using threads or processes.") 模塊中的 [`ProcessPoolExecutor`](../library/concurrent.futures.xhtml#concurrent.futures.ProcessPoolExecutor "concurrent.futures.ProcessPoolExecutor") 類提供了一個簡單的方法;如果你想對任務分發做更多控制,可以使用 [`multiprocessing`](../library/multiprocessing.xhtml#module-multiprocessing "multiprocessing: Process-based parallelism.") 模塊提供的底層 API。
恰當地使用 C 拓展也很有用;使用 C 拓展處理耗時較久的任務時,拓展可以在線程執行 C 代碼時釋放 GIL,讓其他線程執行。[`zlib`](../library/zlib.xhtml#module-zlib "zlib: Low-level interface to compression and decompression routines compatible with gzip.") 和 [`hashlib`](../library/hashlib.xhtml#module-hashlib "hashlib: Secure hash and message digest algorithms.") 等標準庫模塊已經這樣做了。
也有建議說 GIL 應該是解釋器狀態鎖,而不是完全的全局鎖;解釋器不應該共享對象。不幸的是,這也不可能發生。由于目前許多對象的實現都有全局的狀態,因此這是一個艱巨的工作。舉例來說,小整型數和短字符串會緩存起來,這些緩存將不得不移動到解釋器狀態中。其他對象類型都有自己的自由變量列表,這些自由變量列表也必須移動到解釋器狀態中。等等。
我甚至懷疑這些工作是否可能在優先的時間內完成,因為同樣的問題在第三方拓展中也會存在。第三方拓展編寫的速度可比你將它們轉換為把全局狀態存入解釋器狀態中的速度快得多。
最后,假設多個解釋器不共享任何狀態,那么這樣做比每個進程一個解釋器好在哪里呢?
## [輸入輸出](#id20)
### [怎樣刪除文件?(以及其他文件相關的問題……)](#id21)
使用 `os.remove(filename)` 或 `os.unlink(filename)`。查看 [`os`](../library/os.xhtml#module-os "os: Miscellaneous operating system interfaces.") 模塊以獲取更多文檔。這兩個函數是一樣的,[`unlink()`](../library/os.xhtml#os.unlink "os.unlink") 是這個函數在 Unix 系統調用中的名字。
如果要刪除目錄,應該使用 [`os.rmdir()`](../library/os.xhtml#os.rmdir "os.rmdir");使用 [`os.mkdir()`](../library/os.xhtml#os.mkdir "os.mkdir") 創建目錄。`os.makedirs(path)` 會創建 `path` 中任何不存在的目錄。`os.removedirs(path)` 則會刪除其中的目錄,只要它們都是空的;如果你想刪除整個目錄以及其中的內容,可以使用 [`shutil.rmtree()`](../library/shutil.xhtml#shutil.rmtree "shutil.rmtree")。
重命名文件可以使用 `os.rename(old_path, new_path)`。
如果需要截斷文件,使用 `f = open(filename, "rb+")` 打開文件,然后使用 `f.truncate(offset)`;offset 默認是當前的搜索位置。也可以對使用 [`os.open()`](../library/os.xhtml#os.open "os.open") 打開的文件使用 `os.ftruncate(fd, offset)`,其中 *fd* 是文件描述符(一個小的整型數)。
[`shutil`](../library/shutil.xhtml#module-shutil "shutil: High-level file operations, including copying.") 模塊也包含了一些處理文件的函數,包括 [`copyfile()`](../library/shutil.xhtml#shutil.copyfile "shutil.copyfile"),[`copytree()`](../library/shutil.xhtml#shutil.copytree "shutil.copytree") 和 [`rmtree()`](../library/shutil.xhtml#shutil.rmtree "shutil.rmtree")。
### [怎樣復制文件?](#id22)
[`shutil`](../library/shutil.xhtml#module-shutil "shutil: High-level file operations, including copying.") 模塊有一個 [`copyfile()`](../library/shutil.xhtml#shutil.copyfile "shutil.copyfile") 函數。注意在 MacOS 9 中不會復制 resource fork 和 Finder info。
### [怎樣讀取(或寫入)二進制數據?](#id23)
要讀寫復雜的二進制數據格式,最好使用 [`struct`](../library/struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 模塊。該模塊可以讀取包含二進制數據(通常是數字)的字符串并轉換為 Python 對象,反之亦然。
舉例來說,下面的代碼會從文件中以大端序格式讀取一個 2 字節的整型和一個 4 字節的整型:
```
import struct
with open(filename, "rb") as f:
s = f.read(8)
x, y, z = struct.unpack(">hhl", s)
```
格式字符串中的 ‘>’ 強制以大端序讀取數據;字母 ‘h’ 從字符串中讀取一個“短整型”(2 字節),字母 ‘l’ 讀取一個“長整型”(4 字節)。
對于更常規的數據(例如整型或浮點類型的列表),你也可以使用 [`array`](../library/array.xhtml#module-array "array: Space efficient arrays of uniformly typed numeric values.") 模塊。
注解
要讀寫二進制數據的話,需要強制以二進制模式打開文件(這里為 [`open()`](../library/functions.xhtml#open "open") 函數傳入 `"rb"`)。如果(默認)傳入 `"r"` 的話,文件會以文本模式打開,`f.read()` 會返回 [`str`](../library/stdtypes.xhtml#str "str") 對象,而不是 [`bytes`](../library/stdtypes.xhtml#bytes "bytes") 對象。
### [似乎 os.popen() 創建的管道不能使用 os.read(),這是為什么?](#id24)
[`os.read()`](../library/os.xhtml#os.read "os.read") 是一個底層函數,它接收的是文件描述符 —— 用小整型數表示的打開的文件。[`os.popen()`](../library/os.xhtml#os.popen "os.popen") 創建的是一個高級文件對象,和內建的 [`open()`](../library/functions.xhtml#open "open") 方法返回的類型一樣。因此,如果要從 [`os.popen()`](../library/os.xhtml#os.popen "os.popen") 創建的管道 *p* 中讀取 *n* 個字節的話,你應該使用 `p.read(n)`。
### [怎樣訪問(RS232)串口?](#id25)
對于 Win32,POSIX(Linux,BSD 等),Jython:
> <http://pyserial.sourceforge.net>
對于 Unix,查看 Mitch Chapman 發布的帖子:
> <https://groups.google.com/groups?selm=34A04430.CF9@ohioee.com>
### [為什么關閉 sys.stdout(stdin,stderr)并不會真正關掉它?](#id26)
Python [文件對象](../glossary.xhtml#term-file-object) 是一個對底層 C 文件描述符的高層抽象。
對于在 Python 中通過內建的 [`open()`](../library/functions.xhtml#open "open") 函數創建的多數文件對象來說,`f.close()` 從 Python 的角度將其標記為已關閉,并且會關閉底層的 C 文件描述符。在 `f` 被垃圾回收的時候,析構函數中也會自動處理。
但由于 stdin,stdout 和 stderr 在 C 中的特殊地位,在 Python 中也會對它們做特殊處理。運行 `sys.stdout.close()` 會將 Python 的文件對象標記為已關閉,但是\*不會\*關閉與之關聯的文件描述符。
要關閉這三者的 C 文件描述符的話,首先你應該確認確實需要關閉它(比如,這可能會影響到處理 I/O 的拓展)。如果確實需要這么做的話,使用 [`os.close()`](../library/os.xhtml#os.close "os.close"):
```
os.close(stdin.fileno())
os.close(stdout.fileno())
os.close(stderr.fileno())
```
或者也可以使用常量 0,1,2 代替。
## [網絡 / Internet 編程](#id27)
### [Python 中的 WWW 工具是什么?](#id28)
參閱代碼庫參考手冊中 [互聯網協議和支持](../library/internet.xhtml#internet) 和 [互聯網數據處理](../library/netdata.xhtml#netdata) 這兩章的內容。Python 有大量模塊來幫助你構建服務端和客戶端 web 系統。
Paul Boddie 維護了一份可用框架的概覽,見 <https://wiki.python.org/moin/WebProgramming> 。
Cameron Laird 維護了一份關于 Python web 技術的實用網頁的集合,見 [http://phaseit.net/claird/comp.lang.python/web\_python](http://phaseit.net/claird/comp.lang.python/web_python) 。
### [怎樣模擬發送 CGI 表單(METHOD=POST)?](#id29)
我需要通過 POST 表單獲取網頁,有什么代碼能簡單做到嗎?
是的,這里有一個使用 urllib.request 的簡單例子:
```
#!/usr/local/bin/python
import urllib.request
# build the query string
qs = "First=Josephine&MI=Q&Last=Public"
# connect and send the server a path
req = urllib.request.urlopen('http://www.some-server.out-there'
'/cgi-bin/some-cgi-script', data=qs)
with req:
msg, hdrs = req.read(), req.info()
```
注意,通常在百分號編碼的 POST 操作中,查詢字符串必須使用 [`urllib.parse.urlencode()`](../library/urllib.parse.xhtml#urllib.parse.urlencode "urllib.parse.urlencode") 處理一下。舉個例子,如果要發送 `name=Guy Steele, Jr.` 的話:
```
>>> import urllib.parse
>>> urllib.parse.urlencode({'name': 'Guy Steele, Jr.'})
'name=Guy+Steele%2C+Jr.'
```
參見
查看 [如何使用urllib包獲取網絡資源](../howto/urllib2.xhtml#urllib-howto) 獲取更多示例。
### [生成 HTML 需要使用什么模塊?](#id30)
你可以在 [Web 編程 wiki 頁面](https://wiki.python.org/moin/WebProgramming) \[https://wiki.python.org/moin/WebProgramming\] 找到許多有用的鏈接。
### [怎樣使用 Python 腳本發送郵件?](#id31)
使用 [`smtplib`](../library/smtplib.xhtml#module-smtplib "smtplib: SMTP protocol client (requires sockets).") 標準庫模塊。
下面是一個很簡單的交互式發送郵件的代碼。這個方法適用于任何支持 SMTP 協議的主機。
```
import sys, smtplib
fromaddr = input("From: ")
toaddrs = input("To: ").split(',')
print("Enter message, end with ^D:")
msg = ''
while True:
line = sys.stdin.readline()
if not line:
break
msg += line
# The actual mail send
server = smtplib.SMTP('localhost')
server.sendmail(fromaddr, toaddrs, msg)
server.quit()
```
在 Unix 系統中還可以使用 sendmail。sendmail 程序的位置在不同系統中不一樣,有時是在 `/usr/lib/sendmail`,有時是在 `/usr/sbin/sendmail`。sendmail 手冊頁面會對你有所幫助。以下是示例代碼:
```
import os
SENDMAIL = "/usr/sbin/sendmail" # sendmail location
p = os.popen("%s -t -i" % SENDMAIL, "w")
p.write("To: receiver@example.com\n")
p.write("Subject: test\n")
p.write("\n") # blank line separating headers from body
p.write("Some text\n")
p.write("some more text\n")
sts = p.close()
if sts != 0:
print("Sendmail exit status", sts)
```
### [socket 的 connect() 方法怎樣避免阻塞?](#id32)
通常會用 [`select`](../library/select.xhtml#module-select "select: Wait for I/O completion on multiple streams.") 模塊處理 socket 異步 I/O。
要避免 TCP 連接阻塞,你可以設置將 socket 設置為非阻塞模式。此時當調用 `connect()` 時,要么連接會立刻建立好(幾乎不可能),要么會收到一個包含了錯誤碼 `.error` 的異常。`errno.EINPROGRESS` 表示連接正在進行,但還沒有完成。不同的系統會返回不同的值,所以你需要確認你使用的系統會返回什么。
你可以使用 `connect_ex()` 方法來避免產生異常。這個方法只會返回錯誤碼。如果需要輪詢的話,你可以再次調用 `connect_ex()` —— `0` 或 `errno.EISCONN` 表示連接已建立,或者你也可以用 select 檢查這個 socket 是否可寫。
注解
[`asyncore`](../library/asyncore.xhtml#module-asyncore "asyncore: A base class for developing asynchronous socket handling services.") 模塊提供了編寫非阻塞網絡代碼框架性的方法。第三方的 [Twisted](https://twistedmatrix.com/trac/) \[https://twistedmatrix.com/trac/\] 庫也很常用且功能強大。
## [數據庫](#id33)
### [Python 中有數據庫包的接口嗎?](#id34)
當然。
標準 Python 還包含了基于磁盤的哈希接口例如 [`DBM`](../library/dbm.xhtml#module-dbm.ndbm "dbm.ndbm: The standard "database" interface, based on ndbm. (Unix)") 和 [`GDBM`](../library/dbm.xhtml#module-dbm.gnu "dbm.gnu: GNU's reinterpretation of dbm. (Unix)") 。除此之外還有 [`sqlite3`](../library/sqlite3.xhtml#module-sqlite3 "sqlite3: A DB-API 2.0 implementation using SQLite 3.x.") 模塊,該模塊提供了一個輕量級的基于磁盤的關系型數據庫。
大多數關系型數據庫都已經支持。查看 [數據庫編程 wiki 頁面](https://wiki.python.org/moin/DatabaseProgramming) \[https://wiki.python.org/moin/DatabaseProgramming\] 獲取更多信息。
### [在 Python 中如何實現持久化對象?](#id35)
[`pickle`](../library/pickle.xhtml#module-pickle "pickle: Convert Python objects to streams of bytes and back.") 庫模塊以一種非常通用的方式解決了這個問題(雖然你依然不能用它保存打開的文件、套接字或窗口之類的東西),此外 [`shelve`](../library/shelve.xhtml#module-shelve "shelve: Python object persistence.") 庫模塊可使用 pickle 和 (g)dbm 來創建包含任意 Python 對象的持久化映射。
## [數學和數字](#id36)
### [Python 中怎樣生成隨機數?](#id37)
[`random`](../library/random.xhtml#module-random "random: Generate pseudo-random numbers with various common distributions.") 標準庫模塊實現了隨機數生成器,使用起來非常簡單:
```
import random
random.random()
```
這個函數會返回 \[0, 1) 之間的隨機浮點數。
該模塊中還有許多其他的專門的生成器,例如:
- `randrange(a, b)` 返回 \[a, b) 區間內的一個整型數。
- `uniform(a, b)` 返回 \[a, b) 區間之間的浮點數。
- `normalvariate(mean, sdev)` 使用正態(高斯)分布采樣。
還有一些高級函數直接對序列進行操作,例如:
- `choice(S)` 從給定的序列中隨機選擇一個元素。
- `shuffle(L)` 對列表進行原地重排,也就是說隨機打亂。
還有 `Random` 類,你可以將其實例化,用來創建多個獨立的隨機數生成器。
### 導航
- [索引](../genindex.xhtml "總目錄")
- [模塊](../py-modindex.xhtml "Python 模塊索引") |
- [下一頁](extending.xhtml "擴展/嵌入常見問題") |
- [上一頁](design.xhtml "設計和歷史常見問題") |
- 
- [Python](https://www.python.org/) ?
- zh\_CN 3.7.3 [文檔](../index.xhtml) ?
- [Python 常見問題](index.xhtml) ?
- $('.inline-search').show(0); |
? [版權所有](../copyright.xhtml) 2001-2019, Python Software Foundation.
Python 軟件基金會是一個非盈利組織。 [請捐助。](https://www.python.org/psf/donations/)
最后更新于 5月 21, 2019. [發現了問題](../bugs.xhtml)?
使用[Sphinx](http://sphinx.pocoo.org/)1.8.4 創建。
- Python文檔內容
- Python 有什么新變化?
- Python 3.7 有什么新變化
- 摘要 - 發布重點
- 新的特性
- 其他語言特性修改
- 新增模塊
- 改進的模塊
- C API 的改變
- 構建的改變
- 性能優化
- 其他 CPython 實現的改變
- 已棄用的 Python 行為
- 已棄用的 Python 模塊、函數和方法
- 已棄用的 C API 函數和類型
- 平臺支持的移除
- API 與特性的移除
- 移除的模塊
- Windows 專屬的改變
- 移植到 Python 3.7
- Python 3.7.1 中的重要變化
- Python 3.7.2 中的重要變化
- Python 3.6 有什么新變化A
- 摘要 - 發布重點
- 新的特性
- 其他語言特性修改
- 新增模塊
- 改進的模塊
- 性能優化
- Build and C API Changes
- 其他改進
- 棄用
- 移除
- 移植到Python 3.6
- Python 3.6.2 中的重要變化
- Python 3.6.4 中的重要變化
- Python 3.6.5 中的重要變化
- Python 3.6.7 中的重要變化
- Python 3.5 有什么新變化
- 摘要 - 發布重點
- 新的特性
- 其他語言特性修改
- 新增模塊
- 改進的模塊
- Other module-level changes
- 性能優化
- Build and C API Changes
- 棄用
- 移除
- Porting to Python 3.5
- Notable changes in Python 3.5.4
- What's New In Python 3.4
- 摘要 - 發布重點
- 新的特性
- 新增模塊
- 改進的模塊
- CPython Implementation Changes
- 棄用
- 移除
- Porting to Python 3.4
- Changed in 3.4.3
- What's New In Python 3.3
- 摘要 - 發布重點
- PEP 405: Virtual Environments
- PEP 420: Implicit Namespace Packages
- PEP 3118: New memoryview implementation and buffer protocol documentation
- PEP 393: Flexible String Representation
- PEP 397: Python Launcher for Windows
- PEP 3151: Reworking the OS and IO exception hierarchy
- PEP 380: Syntax for Delegating to a Subgenerator
- PEP 409: Suppressing exception context
- PEP 414: Explicit Unicode literals
- PEP 3155: Qualified name for classes and functions
- PEP 412: Key-Sharing Dictionary
- PEP 362: Function Signature Object
- PEP 421: Adding sys.implementation
- Using importlib as the Implementation of Import
- 其他語言特性修改
- A Finer-Grained Import Lock
- Builtin functions and types
- 新增模塊
- 改進的模塊
- 性能優化
- Build and C API Changes
- 棄用
- Porting to Python 3.3
- What's New In Python 3.2
- PEP 384: Defining a Stable ABI
- PEP 389: Argparse Command Line Parsing Module
- PEP 391: Dictionary Based Configuration for Logging
- PEP 3148: The concurrent.futures module
- PEP 3147: PYC Repository Directories
- PEP 3149: ABI Version Tagged .so Files
- PEP 3333: Python Web Server Gateway Interface v1.0.1
- 其他語言特性修改
- New, Improved, and Deprecated Modules
- 多線程
- 性能優化
- Unicode
- Codecs
- 文檔
- IDLE
- Code Repository
- Build and C API Changes
- Porting to Python 3.2
- What's New In Python 3.1
- PEP 372: Ordered Dictionaries
- PEP 378: Format Specifier for Thousands Separator
- 其他語言特性修改
- New, Improved, and Deprecated Modules
- 性能優化
- IDLE
- Build and C API Changes
- Porting to Python 3.1
- What's New In Python 3.0
- Common Stumbling Blocks
- Overview Of Syntax Changes
- Changes Already Present In Python 2.6
- Library Changes
- PEP 3101: A New Approach To String Formatting
- Changes To Exceptions
- Miscellaneous Other Changes
- Build and C API Changes
- 性能
- Porting To Python 3.0
- What's New in Python 2.7
- The Future for Python 2.x
- Changes to the Handling of Deprecation Warnings
- Python 3.1 Features
- PEP 372: Adding an Ordered Dictionary to collections
- PEP 378: Format Specifier for Thousands Separator
- PEP 389: The argparse Module for Parsing Command Lines
- PEP 391: Dictionary-Based Configuration For Logging
- PEP 3106: Dictionary Views
- PEP 3137: The memoryview Object
- 其他語言特性修改
- New and Improved Modules
- Build and C API Changes
- Other Changes and Fixes
- Porting to Python 2.7
- New Features Added to Python 2.7 Maintenance Releases
- Acknowledgements
- Python 2.6 有什么新變化
- Python 3.0
- Changes to the Development Process
- PEP 343: The 'with' statement
- PEP 366: Explicit Relative Imports From a Main Module
- PEP 370: Per-user site-packages Directory
- PEP 371: The multiprocessing Package
- PEP 3101: Advanced String Formatting
- PEP 3105: print As a Function
- PEP 3110: Exception-Handling Changes
- PEP 3112: Byte Literals
- PEP 3116: New I/O Library
- PEP 3118: Revised Buffer Protocol
- PEP 3119: Abstract Base Classes
- PEP 3127: Integer Literal Support and Syntax
- PEP 3129: Class Decorators
- PEP 3141: A Type Hierarchy for Numbers
- 其他語言特性修改
- New and Improved Modules
- Deprecations and Removals
- Build and C API Changes
- Porting to Python 2.6
- Acknowledgements
- What's New in Python 2.5
- PEP 308: Conditional Expressions
- PEP 309: Partial Function Application
- PEP 314: Metadata for Python Software Packages v1.1
- PEP 328: Absolute and Relative Imports
- PEP 338: Executing Modules as Scripts
- PEP 341: Unified try/except/finally
- PEP 342: New Generator Features
- PEP 343: The 'with' statement
- PEP 352: Exceptions as New-Style Classes
- PEP 353: Using ssize_t as the index type
- PEP 357: The 'index' method
- 其他語言特性修改
- New, Improved, and Removed Modules
- Build and C API Changes
- Porting to Python 2.5
- Acknowledgements
- What's New in Python 2.4
- PEP 218: Built-In Set Objects
- PEP 237: Unifying Long Integers and Integers
- PEP 289: Generator Expressions
- PEP 292: Simpler String Substitutions
- PEP 318: Decorators for Functions and Methods
- PEP 322: Reverse Iteration
- PEP 324: New subprocess Module
- PEP 327: Decimal Data Type
- PEP 328: Multi-line Imports
- PEP 331: Locale-Independent Float/String Conversions
- 其他語言特性修改
- New, Improved, and Deprecated Modules
- Build and C API Changes
- Porting to Python 2.4
- Acknowledgements
- What's New in Python 2.3
- PEP 218: A Standard Set Datatype
- PEP 255: Simple Generators
- PEP 263: Source Code Encodings
- PEP 273: Importing Modules from ZIP Archives
- PEP 277: Unicode file name support for Windows NT
- PEP 278: Universal Newline Support
- PEP 279: enumerate()
- PEP 282: The logging Package
- PEP 285: A Boolean Type
- PEP 293: Codec Error Handling Callbacks
- PEP 301: Package Index and Metadata for Distutils
- PEP 302: New Import Hooks
- PEP 305: Comma-separated Files
- PEP 307: Pickle Enhancements
- Extended Slices
- 其他語言特性修改
- New, Improved, and Deprecated Modules
- Pymalloc: A Specialized Object Allocator
- Build and C API Changes
- Other Changes and Fixes
- Porting to Python 2.3
- Acknowledgements
- What's New in Python 2.2
- 概述
- PEPs 252 and 253: Type and Class Changes
- PEP 234: Iterators
- PEP 255: Simple Generators
- PEP 237: Unifying Long Integers and Integers
- PEP 238: Changing the Division Operator
- Unicode Changes
- PEP 227: Nested Scopes
- New and Improved Modules
- Interpreter Changes and Fixes
- Other Changes and Fixes
- Acknowledgements
- What's New in Python 2.1
- 概述
- PEP 227: Nested Scopes
- PEP 236: future Directives
- PEP 207: Rich Comparisons
- PEP 230: Warning Framework
- PEP 229: New Build System
- PEP 205: Weak References
- PEP 232: Function Attributes
- PEP 235: Importing Modules on Case-Insensitive Platforms
- PEP 217: Interactive Display Hook
- PEP 208: New Coercion Model
- PEP 241: Metadata in Python Packages
- New and Improved Modules
- Other Changes and Fixes
- Acknowledgements
- What's New in Python 2.0
- 概述
- What About Python 1.6?
- New Development Process
- Unicode
- 列表推導式
- Augmented Assignment
- 字符串的方法
- Garbage Collection of Cycles
- Other Core Changes
- Porting to 2.0
- Extending/Embedding Changes
- Distutils: Making Modules Easy to Install
- XML Modules
- Module changes
- New modules
- IDLE Improvements
- Deleted and Deprecated Modules
- Acknowledgements
- 更新日志
- Python 下一版
- Python 3.7.3 最終版
- Python 3.7.3 發布候選版 1
- Python 3.7.2 最終版
- Python 3.7.2 發布候選版 1
- Python 3.7.1 最終版
- Python 3.7.1 RC 2版本
- Python 3.7.1 發布候選版 1
- Python 3.7.0 正式版
- Python 3.7.0 release candidate 1
- Python 3.7.0 beta 5
- Python 3.7.0 beta 4
- Python 3.7.0 beta 3
- Python 3.7.0 beta 2
- Python 3.7.0 beta 1
- Python 3.7.0 alpha 4
- Python 3.7.0 alpha 3
- Python 3.7.0 alpha 2
- Python 3.7.0 alpha 1
- Python 3.6.6 final
- Python 3.6.6 RC 1
- Python 3.6.5 final
- Python 3.6.5 release candidate 1
- Python 3.6.4 final
- Python 3.6.4 release candidate 1
- Python 3.6.3 final
- Python 3.6.3 release candidate 1
- Python 3.6.2 final
- Python 3.6.2 release candidate 2
- Python 3.6.2 release candidate 1
- Python 3.6.1 final
- Python 3.6.1 release candidate 1
- Python 3.6.0 final
- Python 3.6.0 release candidate 2
- Python 3.6.0 release candidate 1
- Python 3.6.0 beta 4
- Python 3.6.0 beta 3
- Python 3.6.0 beta 2
- Python 3.6.0 beta 1
- Python 3.6.0 alpha 4
- Python 3.6.0 alpha 3
- Python 3.6.0 alpha 2
- Python 3.6.0 alpha 1
- Python 3.5.5 final
- Python 3.5.5 release candidate 1
- Python 3.5.4 final
- Python 3.5.4 release candidate 1
- Python 3.5.3 final
- Python 3.5.3 release candidate 1
- Python 3.5.2 final
- Python 3.5.2 release candidate 1
- Python 3.5.1 final
- Python 3.5.1 release candidate 1
- Python 3.5.0 final
- Python 3.5.0 release candidate 4
- Python 3.5.0 release candidate 3
- Python 3.5.0 release candidate 2
- Python 3.5.0 release candidate 1
- Python 3.5.0 beta 4
- Python 3.5.0 beta 3
- Python 3.5.0 beta 2
- Python 3.5.0 beta 1
- Python 3.5.0 alpha 4
- Python 3.5.0 alpha 3
- Python 3.5.0 alpha 2
- Python 3.5.0 alpha 1
- Python 教程
- 課前甜點
- 使用 Python 解釋器
- 調用解釋器
- 解釋器的運行環境
- Python 的非正式介紹
- Python 作為計算器使用
- 走向編程的第一步
- 其他流程控制工具
- if 語句
- for 語句
- range() 函數
- break 和 continue 語句,以及循環中的 else 子句
- pass 語句
- 定義函數
- 函數定義的更多形式
- 小插曲:編碼風格
- 數據結構
- 列表的更多特性
- del 語句
- 元組和序列
- 集合
- 字典
- 循環的技巧
- 深入條件控制
- 序列和其它類型的比較
- 模塊
- 有關模塊的更多信息
- 標準模塊
- dir() 函數
- 包
- 輸入輸出
- 更漂亮的輸出格式
- 讀寫文件
- 錯誤和異常
- 語法錯誤
- 異常
- 處理異常
- 拋出異常
- 用戶自定義異常
- 定義清理操作
- 預定義的清理操作
- 類
- 名稱和對象
- Python 作用域和命名空間
- 初探類
- 補充說明
- 繼承
- 私有變量
- 雜項說明
- 迭代器
- 生成器
- 生成器表達式
- 標準庫簡介
- 操作系統接口
- 文件通配符
- 命令行參數
- 錯誤輸出重定向和程序終止
- 字符串模式匹配
- 數學
- 互聯網訪問
- 日期和時間
- 數據壓縮
- 性能測量
- 質量控制
- 自帶電池
- 標準庫簡介 —— 第二部分
- 格式化輸出
- 模板
- 使用二進制數據記錄格式
- 多線程
- 日志
- 弱引用
- 用于操作列表的工具
- 十進制浮點運算
- 虛擬環境和包
- 概述
- 創建虛擬環境
- 使用pip管理包
- 接下來?
- 交互式編輯和編輯歷史
- Tab 補全和編輯歷史
- 默認交互式解釋器的替代品
- 浮點算術:爭議和限制
- 表示性錯誤
- 附錄
- 交互模式
- 安裝和使用 Python
- 命令行與環境
- 命令行
- 環境變量
- 在Unix平臺中使用Python
- 獲取最新版本的Python
- 構建Python
- 與Python相關的路徑和文件
- 雜項
- 編輯器和集成開發環境
- 在Windows上使用 Python
- 完整安裝程序
- Microsoft Store包
- nuget.org 安裝包
- 可嵌入的包
- 替代捆綁包
- 配置Python
- 適用于Windows的Python啟動器
- 查找模塊
- 附加模塊
- 在Windows上編譯Python
- 其他平臺
- 在蘋果系統上使用 Python
- 獲取和安裝 MacPython
- IDE
- 安裝額外的 Python 包
- Mac 上的圖形界面編程
- 在 Mac 上分發 Python 應用程序
- 其他資源
- Python 語言參考
- 概述
- 其他實現
- 標注
- 詞法分析
- 行結構
- 其他形符
- 標識符和關鍵字
- 字面值
- 運算符
- 分隔符
- 數據模型
- 對象、值與類型
- 標準類型層級結構
- 特殊方法名稱
- 協程
- 執行模型
- 程序的結構
- 命名與綁定
- 異常
- 導入系統
- importlib
- 包
- 搜索
- 加載
- 基于路徑的查找器
- 替換標準導入系統
- Package Relative Imports
- 有關 main 的特殊事項
- 開放問題項
- 參考文獻
- 表達式
- 算術轉換
- 原子
- 原型
- await 表達式
- 冪運算符
- 一元算術和位運算
- 二元算術運算符
- 移位運算
- 二元位運算
- 比較運算
- 布爾運算
- 條件表達式
- lambda 表達式
- 表達式列表
- 求值順序
- 運算符優先級
- 簡單語句
- 表達式語句
- 賦值語句
- assert 語句
- pass 語句
- del 語句
- return 語句
- yield 語句
- raise 語句
- break 語句
- continue 語句
- import 語句
- global 語句
- nonlocal 語句
- 復合語句
- if 語句
- while 語句
- for 語句
- try 語句
- with 語句
- 函數定義
- 類定義
- 協程
- 最高層級組件
- 完整的 Python 程序
- 文件輸入
- 交互式輸入
- 表達式輸入
- 完整的語法規范
- Python 標準庫
- 概述
- 可用性注釋
- 內置函數
- 內置常量
- 由 site 模塊添加的常量
- 內置類型
- 邏輯值檢測
- 布爾運算 — and, or, not
- 比較
- 數字類型 — int, float, complex
- 迭代器類型
- 序列類型 — list, tuple, range
- 文本序列類型 — str
- 二進制序列類型 — bytes, bytearray, memoryview
- 集合類型 — set, frozenset
- 映射類型 — dict
- 上下文管理器類型
- 其他內置類型
- 特殊屬性
- 內置異常
- 基類
- 具體異常
- 警告
- 異常層次結構
- 文本處理服務
- string — 常見的字符串操作
- re — 正則表達式操作
- 模塊 difflib 是一個計算差異的助手
- textwrap — Text wrapping and filling
- unicodedata — Unicode 數據庫
- stringprep — Internet String Preparation
- readline — GNU readline interface
- rlcompleter — GNU readline的完成函數
- 二進制數據服務
- struct — Interpret bytes as packed binary data
- codecs — Codec registry and base classes
- 數據類型
- datetime — 基礎日期/時間數據類型
- calendar — General calendar-related functions
- collections — 容器數據類型
- collections.abc — 容器的抽象基類
- heapq — 堆隊列算法
- bisect — Array bisection algorithm
- array — Efficient arrays of numeric values
- weakref — 弱引用
- types — Dynamic type creation and names for built-in types
- copy — 淺層 (shallow) 和深層 (deep) 復制操作
- pprint — 數據美化輸出
- reprlib — Alternate repr() implementation
- enum — Support for enumerations
- 數字和數學模塊
- numbers — 數字的抽象基類
- math — 數學函數
- cmath — Mathematical functions for complex numbers
- decimal — 十進制定點和浮點運算
- fractions — 分數
- random — 生成偽隨機數
- statistics — Mathematical statistics functions
- 函數式編程模塊
- itertools — 為高效循環而創建迭代器的函數
- functools — 高階函數和可調用對象上的操作
- operator — 標準運算符替代函數
- 文件和目錄訪問
- pathlib — 面向對象的文件系統路徑
- os.path — 常見路徑操作
- fileinput — Iterate over lines from multiple input streams
- stat — Interpreting stat() results
- filecmp — File and Directory Comparisons
- tempfile — Generate temporary files and directories
- glob — Unix style pathname pattern expansion
- fnmatch — Unix filename pattern matching
- linecache — Random access to text lines
- shutil — High-level file operations
- macpath — Mac OS 9 路徑操作函數
- 數據持久化
- pickle —— Python 對象序列化
- copyreg — Register pickle support functions
- shelve — Python object persistence
- marshal — Internal Python object serialization
- dbm — Interfaces to Unix “databases”
- sqlite3 — SQLite 數據庫 DB-API 2.0 接口模塊
- 數據壓縮和存檔
- zlib — 與 gzip 兼容的壓縮
- gzip — 對 gzip 格式的支持
- bz2 — 對 bzip2 壓縮算法的支持
- lzma — 用 LZMA 算法壓縮
- zipfile — 在 ZIP 歸檔中工作
- tarfile — Read and write tar archive files
- 文件格式
- csv — CSV 文件讀寫
- configparser — Configuration file parser
- netrc — netrc file processing
- xdrlib — Encode and decode XDR data
- plistlib — Generate and parse Mac OS X .plist files
- 加密服務
- hashlib — 安全哈希與消息摘要
- hmac — 基于密鑰的消息驗證
- secrets — Generate secure random numbers for managing secrets
- 通用操作系統服務
- os — 操作系統接口模塊
- io — 處理流的核心工具
- time — 時間的訪問和轉換
- argparse — 命令行選項、參數和子命令解析器
- getopt — C-style parser for command line options
- 模塊 logging — Python 的日志記錄工具
- logging.config — 日志記錄配置
- logging.handlers — Logging handlers
- getpass — 便攜式密碼輸入工具
- curses — 終端字符單元顯示的處理
- curses.textpad — Text input widget for curses programs
- curses.ascii — Utilities for ASCII characters
- curses.panel — A panel stack extension for curses
- platform — Access to underlying platform's identifying data
- errno — Standard errno system symbols
- ctypes — Python 的外部函數庫
- 并發執行
- threading — 基于線程的并行
- multiprocessing — 基于進程的并行
- concurrent 包
- concurrent.futures — 啟動并行任務
- subprocess — 子進程管理
- sched — 事件調度器
- queue — 一個同步的隊列類
- _thread — 底層多線程 API
- _dummy_thread — _thread 的替代模塊
- dummy_threading — 可直接替代 threading 模塊。
- contextvars — Context Variables
- Context Variables
- Manual Context Management
- asyncio support
- 網絡和進程間通信
- asyncio — 異步 I/O
- socket — 底層網絡接口
- ssl — TLS/SSL wrapper for socket objects
- select — Waiting for I/O completion
- selectors — 高級 I/O 復用庫
- asyncore — 異步socket處理器
- asynchat — 異步 socket 指令/響應 處理器
- signal — Set handlers for asynchronous events
- mmap — Memory-mapped file support
- 互聯網數據處理
- email — 電子郵件與 MIME 處理包
- json — JSON 編碼和解碼器
- mailcap — Mailcap file handling
- mailbox — Manipulate mailboxes in various formats
- mimetypes — Map filenames to MIME types
- base64 — Base16, Base32, Base64, Base85 數據編碼
- binhex — 對binhex4文件進行編碼和解碼
- binascii — 二進制和 ASCII 碼互轉
- quopri — Encode and decode MIME quoted-printable data
- uu — Encode and decode uuencode files
- 結構化標記處理工具
- html — 超文本標記語言支持
- html.parser — 簡單的 HTML 和 XHTML 解析器
- html.entities — HTML 一般實體的定義
- XML處理模塊
- xml.etree.ElementTree — The ElementTree XML API
- xml.dom — The Document Object Model API
- xml.dom.minidom — Minimal DOM implementation
- xml.dom.pulldom — Support for building partial DOM trees
- xml.sax — Support for SAX2 parsers
- xml.sax.handler — Base classes for SAX handlers
- xml.sax.saxutils — SAX Utilities
- xml.sax.xmlreader — Interface for XML parsers
- xml.parsers.expat — Fast XML parsing using Expat
- 互聯網協議和支持
- webbrowser — 方便的Web瀏覽器控制器
- cgi — Common Gateway Interface support
- cgitb — Traceback manager for CGI scripts
- wsgiref — WSGI Utilities and Reference Implementation
- urllib — URL 處理模塊
- urllib.request — 用于打開 URL 的可擴展庫
- urllib.response — Response classes used by urllib
- urllib.parse — Parse URLs into components
- urllib.error — Exception classes raised by urllib.request
- urllib.robotparser — Parser for robots.txt
- http — HTTP 模塊
- http.client — HTTP協議客戶端
- ftplib — FTP protocol client
- poplib — POP3 protocol client
- imaplib — IMAP4 protocol client
- nntplib — NNTP protocol client
- smtplib —SMTP協議客戶端
- smtpd — SMTP Server
- telnetlib — Telnet client
- uuid — UUID objects according to RFC 4122
- socketserver — A framework for network servers
- http.server — HTTP 服務器
- http.cookies — HTTP state management
- http.cookiejar — Cookie handling for HTTP clients
- xmlrpc — XMLRPC 服務端與客戶端模塊
- xmlrpc.client — XML-RPC client access
- xmlrpc.server — Basic XML-RPC servers
- ipaddress — IPv4/IPv6 manipulation library
- 多媒體服務
- audioop — Manipulate raw audio data
- aifc — Read and write AIFF and AIFC files
- sunau — 讀寫 Sun AU 文件
- wave — 讀寫WAV格式文件
- chunk — Read IFF chunked data
- colorsys — Conversions between color systems
- imghdr — 推測圖像類型
- sndhdr — 推測聲音文件的類型
- ossaudiodev — Access to OSS-compatible audio devices
- 國際化
- gettext — 多語種國際化服務
- locale — 國際化服務
- 程序框架
- turtle — 海龜繪圖
- cmd — 支持面向行的命令解釋器
- shlex — Simple lexical analysis
- Tk圖形用戶界面(GUI)
- tkinter — Tcl/Tk的Python接口
- tkinter.ttk — Tk themed widgets
- tkinter.tix — Extension widgets for Tk
- tkinter.scrolledtext — 滾動文字控件
- IDLE
- 其他圖形用戶界面(GUI)包
- 開發工具
- typing — 類型標注支持
- pydoc — Documentation generator and online help system
- doctest — Test interactive Python examples
- unittest — 單元測試框架
- unittest.mock — mock object library
- unittest.mock 上手指南
- 2to3 - 自動將 Python 2 代碼轉為 Python 3 代碼
- test — Regression tests package for Python
- test.support — Utilities for the Python test suite
- test.support.script_helper — Utilities for the Python execution tests
- 調試和分析
- bdb — Debugger framework
- faulthandler — Dump the Python traceback
- pdb — The Python Debugger
- The Python Profilers
- timeit — 測量小代碼片段的執行時間
- trace — Trace or track Python statement execution
- tracemalloc — Trace memory allocations
- 軟件打包和分發
- distutils — 構建和安裝 Python 模塊
- ensurepip — Bootstrapping the pip installer
- venv — 創建虛擬環境
- zipapp — Manage executable Python zip archives
- Python運行時服務
- sys — 系統相關的參數和函數
- sysconfig — Provide access to Python's configuration information
- builtins — 內建對象
- main — 頂層腳本環境
- warnings — Warning control
- dataclasses — 數據類
- contextlib — Utilities for with-statement contexts
- abc — 抽象基類
- atexit — 退出處理器
- traceback — Print or retrieve a stack traceback
- future — Future 語句定義
- gc — 垃圾回收器接口
- inspect — 檢查對象
- site — Site-specific configuration hook
- 自定義 Python 解釋器
- code — Interpreter base classes
- codeop — Compile Python code
- 導入模塊
- zipimport — Import modules from Zip archives
- pkgutil — Package extension utility
- modulefinder — 查找腳本使用的模塊
- runpy — Locating and executing Python modules
- importlib — The implementation of import
- Python 語言服務
- parser — Access Python parse trees
- ast — 抽象語法樹
- symtable — Access to the compiler's symbol tables
- symbol — 與 Python 解析樹一起使用的常量
- token — 與Python解析樹一起使用的常量
- keyword — 檢驗Python關鍵字
- tokenize — Tokenizer for Python source
- tabnanny — 模糊縮進檢測
- pyclbr — Python class browser support
- py_compile — Compile Python source files
- compileall — Byte-compile Python libraries
- dis — Python 字節碼反匯編器
- pickletools — Tools for pickle developers
- 雜項服務
- formatter — Generic output formatting
- Windows系統相關模塊
- msilib — Read and write Microsoft Installer files
- msvcrt — Useful routines from the MS VC++ runtime
- winreg — Windows 注冊表訪問
- winsound — Sound-playing interface for Windows
- Unix 專有服務
- posix — The most common POSIX system calls
- pwd — 用戶密碼數據庫
- spwd — The shadow password database
- grp — The group database
- crypt — Function to check Unix passwords
- termios — POSIX style tty control
- tty — 終端控制功能
- pty — Pseudo-terminal utilities
- fcntl — The fcntl and ioctl system calls
- pipes — Interface to shell pipelines
- resource — Resource usage information
- nis — Interface to Sun's NIS (Yellow Pages)
- Unix syslog 庫例程
- 被取代的模塊
- optparse — Parser for command line options
- imp — Access the import internals
- 未創建文檔的模塊
- 平臺特定模塊
- 擴展和嵌入 Python 解釋器
- 推薦的第三方工具
- 不使用第三方工具創建擴展
- 使用 C 或 C++ 擴展 Python
- 自定義擴展類型:教程
- 定義擴展類型:已分類主題
- 構建C/C++擴展
- 在Windows平臺編譯C和C++擴展
- 在更大的應用程序中嵌入 CPython 運行時
- Embedding Python in Another Application
- Python/C API 參考手冊
- 概述
- 代碼標準
- 包含文件
- 有用的宏
- 對象、類型和引用計數
- 異常
- 嵌入Python
- 調試構建
- 穩定的應用程序二進制接口
- The Very High Level Layer
- Reference Counting
- 異常處理
- Printing and clearing
- 拋出異常
- Issuing warnings
- Querying the error indicator
- Signal Handling
- Exception Classes
- Exception Objects
- Unicode Exception Objects
- Recursion Control
- 標準異常
- 標準警告類別
- 工具
- 操作系統實用程序
- 系統功能
- 過程控制
- 導入模塊
- Data marshalling support
- 語句解釋及變量編譯
- 字符串轉換與格式化
- 反射
- 編解碼器注冊與支持功能
- 抽象對象層
- Object Protocol
- 數字協議
- Sequence Protocol
- Mapping Protocol
- 迭代器協議
- 緩沖協議
- Old Buffer Protocol
- 具體的對象層
- 基本對象
- 數值對象
- 序列對象
- 容器對象
- 函數對象
- 其他對象
- Initialization, Finalization, and Threads
- 在Python初始化之前
- 全局配置變量
- Initializing and finalizing the interpreter
- Process-wide parameters
- Thread State and the Global Interpreter Lock
- Sub-interpreter support
- Asynchronous Notifications
- Profiling and Tracing
- Advanced Debugger Support
- Thread Local Storage Support
- 內存管理
- 概述
- 原始內存接口
- Memory Interface
- 對象分配器
- 默認內存分配器
- Customize Memory Allocators
- The pymalloc allocator
- tracemalloc C API
- 示例
- 對象實現支持
- 在堆中分配對象
- Common Object Structures
- Type 對象
- Number Object Structures
- Mapping Object Structures
- Sequence Object Structures
- Buffer Object Structures
- Async Object Structures
- 使對象類型支持循環垃圾回收
- API 和 ABI 版本管理
- 分發 Python 模塊
- 關鍵術語
- 開源許可與協作
- 安裝工具
- 閱讀指南
- 我該如何...?
- ...為我的項目選擇一個名字?
- ...創建和分發二進制擴展?
- 安裝 Python 模塊
- 關鍵術語
- 基本使用
- 我應如何 ...?
- ... 在 Python 3.4 之前的 Python 版本中安裝 pip ?
- ... 只為當前用戶安裝軟件包?
- ... 安裝科學計算類 Python 軟件包?
- ... 使用并行安裝的多個 Python 版本?
- 常見的安裝問題
- 在 Linux 的系統 Python 版本上安裝
- 未安裝 pip
- 安裝二進制編譯擴展
- Python 常用指引
- 將 Python 2 代碼遷移到 Python 3
- 簡要說明
- 詳情
- 將擴展模塊移植到 Python 3
- 條件編譯
- 對象API的更改
- 模塊初始化和狀態
- CObject 替換為 Capsule
- 其他選項
- Curses Programming with Python
- What is curses?
- Starting and ending a curses application
- Windows and Pads
- Displaying Text
- User Input
- For More Information
- 實現描述器
- 摘要
- 定義和簡介
- 描述器協議
- 發起調用描述符
- 描述符示例
- Properties
- 函數和方法
- Static Methods and Class Methods
- 函數式編程指引
- 概述
- 迭代器
- 生成器表達式和列表推導式
- 生成器
- 內置函數
- itertools 模塊
- The functools module
- Small functions and the lambda expression
- Revision History and Acknowledgements
- 引用文獻
- 日志 HOWTO
- 日志基礎教程
- 進階日志教程
- 日志級別
- 有用的處理程序
- 記錄日志中引發的異常
- 使用任意對象作為消息
- 優化
- 日志操作手冊
- 在多個模塊中使用日志
- 在多線程中使用日志
- 使用多個日志處理器和多種格式化
- 在多個地方記錄日志
- 日志服務器配置示例
- 處理日志處理器的阻塞
- Sending and receiving logging events across a network
- Adding contextual information to your logging output
- Logging to a single file from multiple processes
- Using file rotation
- Use of alternative formatting styles
- Customizing LogRecord
- Subclassing QueueHandler - a ZeroMQ example
- Subclassing QueueListener - a ZeroMQ example
- An example dictionary-based configuration
- Using a rotator and namer to customize log rotation processing
- A more elaborate multiprocessing example
- Inserting a BOM into messages sent to a SysLogHandler
- Implementing structured logging
- Customizing handlers with dictConfig()
- Using particular formatting styles throughout your application
- Configuring filters with dictConfig()
- Customized exception formatting
- Speaking logging messages
- Buffering logging messages and outputting them conditionally
- Formatting times using UTC (GMT) via configuration
- Using a context manager for selective logging
- 正則表達式HOWTO
- 概述
- 簡單模式
- 使用正則表達式
- 更多模式能力
- 修改字符串
- 常見問題
- 反饋
- 套接字編程指南
- 套接字
- 創建套接字
- 使用一個套接字
- 斷開連接
- 非阻塞的套接字
- 排序指南
- 基本排序
- 關鍵函數
- Operator 模塊函數
- 升序和降序
- 排序穩定性和排序復雜度
- 使用裝飾-排序-去裝飾的舊方法
- 使用 cmp 參數的舊方法
- 其它
- Unicode 指南
- Unicode 概述
- Python's Unicode Support
- Reading and Writing Unicode Data
- Acknowledgements
- 如何使用urllib包獲取網絡資源
- 概述
- Fetching URLs
- 處理異常
- info and geturl
- Openers and Handlers
- Basic Authentication
- Proxies
- Sockets and Layers
- 腳注
- Argparse 教程
- 概念
- 基礎
- 位置參數介紹
- Introducing Optional arguments
- Combining Positional and Optional arguments
- Getting a little more advanced
- Conclusion
- ipaddress模塊介紹
- 創建 Address/Network/Interface 對象
- 審查 Address/Network/Interface 對象
- Network 作為 Address 列表
- 比較
- 將IP地址與其他模塊一起使用
- 實例創建失敗時獲取更多詳細信息
- Argument Clinic How-To
- The Goals Of Argument Clinic
- Basic Concepts And Usage
- Converting Your First Function
- Advanced Topics
- 使用 DTrace 和 SystemTap 檢測CPython
- Enabling the static markers
- Static DTrace probes
- Static SystemTap markers
- Available static markers
- SystemTap Tapsets
- 示例
- Python 常見問題
- Python常見問題
- 一般信息
- 現實世界中的 Python
- 編程常見問題
- 一般問題
- 核心語言
- 數字和字符串
- 性能
- 序列(元組/列表)
- 對象
- 模塊
- 設計和歷史常見問題
- 為什么Python使用縮進來分組語句?
- 為什么簡單的算術運算得到奇怪的結果?
- 為什么浮點計算不準確?
- 為什么Python字符串是不可變的?
- 為什么必須在方法定義和調用中顯式使用“self”?
- 為什么不能在表達式中賦值?
- 為什么Python對某些功能(例如list.index())使用方法來實現,而其他功能(例如len(List))使用函數實現?
- 為什么 join()是一個字符串方法而不是列表或元組方法?
- 異常有多快?
- 為什么Python中沒有switch或case語句?
- 難道不能在解釋器中模擬線程,而非得依賴特定于操作系統的線程實現嗎?
- 為什么lambda表達式不能包含語句?
- 可以將Python編譯為機器代碼,C或其他語言嗎?
- Python如何管理內存?
- 為什么CPython不使用更傳統的垃圾回收方案?
- CPython退出時為什么不釋放所有內存?
- 為什么有單獨的元組和列表數據類型?
- 列表是如何在CPython中實現的?
- 字典是如何在CPython中實現的?
- 為什么字典key必須是不可變的?
- 為什么 list.sort() 沒有返回排序列表?
- 如何在Python中指定和實施接口規范?
- 為什么沒有goto?
- 為什么原始字符串(r-strings)不能以反斜杠結尾?
- 為什么Python沒有屬性賦值的“with”語句?
- 為什么 if/while/def/class語句需要冒號?
- 為什么Python在列表和元組的末尾允許使用逗號?
- 代碼庫和插件 FAQ
- 通用的代碼庫問題
- 通用任務
- 線程相關
- 輸入輸出
- 網絡 / Internet 編程
- 數據庫
- 數學和數字
- 擴展/嵌入常見問題
- 可以使用C語言中創建自己的函數嗎?
- 可以使用C++語言中創建自己的函數嗎?
- C很難寫,有沒有其他選擇?
- 如何從C執行任意Python語句?
- 如何從C中評估任意Python表達式?
- 如何從Python對象中提取C的值?
- 如何使用Py_BuildValue()創建任意長度的元組?
- 如何從C調用對象的方法?
- 如何捕獲PyErr_Print()(或打印到stdout / stderr的任何內容)的輸出?
- 如何從C訪問用Python編寫的模塊?
- 如何從Python接口到C ++對象?
- 我使用Setup文件添加了一個模塊,為什么make失敗了?
- 如何調試擴展?
- 我想在Linux系統上編譯一個Python模塊,但是缺少一些文件。為什么?
- 如何區分“輸入不完整”和“輸入無效”?
- 如何找到未定義的g++符號__builtin_new或__pure_virtual?
- 能否創建一個對象類,其中部分方法在C中實現,而其他方法在Python中實現(例如通過繼承)?
- Python在Windows上的常見問題
- 我怎樣在Windows下運行一個Python程序?
- 我怎么讓 Python 腳本可執行?
- 為什么有時候 Python 程序會啟動緩慢?
- 我怎樣使用Python腳本制作可執行文件?
- *.pyd 文件和DLL文件相同嗎?
- 我怎樣將Python嵌入一個Windows程序?
- 如何讓編輯器不要在我的 Python 源代碼中插入 tab ?
- 如何在不阻塞的情況下檢查按鍵?
- 圖形用戶界面(GUI)常見問題
- 圖形界面常見問題
- Python 是否有平臺無關的圖形界面工具包?
- 有哪些Python的GUI工具是某個平臺專用的?
- 有關Tkinter的問題
- “為什么我的電腦上安裝了 Python ?”
- 什么是Python?
- 為什么我的電腦上安裝了 Python ?
- 我能刪除 Python 嗎?
- 術語對照表
- 文檔說明
- Python 文檔貢獻者
- 解決 Bug
- 文檔錯誤
- 使用 Python 的錯誤追蹤系統
- 開始為 Python 貢獻您的知識
- 版權
- 歷史和許可證
- 軟件歷史
- 訪問Python或以其他方式使用Python的條款和條件
- Python 3.7.3 的 PSF 許可協議
- Python 2.0 的 BeOpen.com 許可協議
- Python 1.6.1 的 CNRI 許可協議
- Python 0.9.0 至 1.2 的 CWI 許可協議
- 集成軟件的許可和認可
- Mersenne Twister
- 套接字
- Asynchronous socket services
- Cookie management
- Execution tracing
- UUencode and UUdecode functions
- XML Remote Procedure Calls
- test_epoll
- Select kqueue
- SipHash24
- strtod and dtoa
- OpenSSL
- expat
- libffi
- zlib
- cfuhash
- libmpdec