雖然並非你編寫的每個 Python 程式都要求一個嚴格的效能分析，但是讓人放心的是，當問題發生的時候，Python 生態圈有各種各樣的工具可以處理這類問題。
分析程式的效能可以歸結為回答四個基本問題：
- 正執行的多快
- 速度瓶頸在哪裡
- 記憶體使用率是多少
- 記憶體洩露在哪裡
下面，我們將用一些神奇的工具深入到這些問題的答案中去。
用 time 粗粒度的計算時間
讓我們開始通過使用一個快速和粗暴的方法計算我們的程式碼:傳統的 unix time 工具。
|
1 2 3 4 |
$ time python yourprogram.py real 0m1.028s user 0m0.001s sys 0m0.003s |
三個輸出測量值之間的詳細意義在這裡 stackoverflow article，但簡介在這：
- real — 指的是實際耗時
- user — 指的是核心之外的 CPU 耗時
- sys — 指的是花費在核心特定函式的 CPU 耗時
你會有你的應用程式用完了多少 CPU 週期的即視感，不管系統上其他執行的程式新增的系統和使用者時間。
如果 sys 和 user 時間之和小於 real 時間，然後你可以猜測到大多數程式的效能問題最有可能與 IO wait 相關。
用 timing context 管理器細粒度的計算時間
我們下一步的技術包括直接嵌入程式碼來獲取細粒度的計時資訊。下面是我進行時間測量的程式碼的一個小片段
timer.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import time class Timer(object): def __init__(self, verbose=False): self.verbose = verbose def __enter__(self): self.start = time.time() return self def __exit__(self, *args): self.end = time.time() self.secs = self.end - self.start self.msecs = self.secs * 1000 # millisecs if self.verbose: print 'elapsed time: %f ms' % self.msecs |
為了使用它，使用 Python 的 with 關鍵字和 Timer 上下文管理器來包裝你想計算的程式碼。當您的程式碼塊開始執行，它將照顧啟動計時器,當你的程式碼塊結束的時候，它將停止計時器。
這個程式碼片段示例：
|
1 2 3 4 5 6 7 8 9 10 11 |
from timer import Timer from redis import Redis rdb = Redis() with Timer() as t: rdb.lpush("foo", "bar") print "=> elasped lpush: %s s" % t.secs with Timer() as t: rdb.lpop("foo") print "=> elasped lpop: %s s" % t.secs |
為了看看我的程式的效能隨著時間的演化的趨勢，我常常記錄這些定時器的輸出到一個檔案中。
使用 profiler 逐行計時和分析執行的頻率
羅伯特·克恩有一個不錯的專案稱為 line_profiler , 我經常使用它來分析我的指令碼有多快，以及每行程式碼執行的頻率：
為了使用它，你可以通過使用 pip 來安裝它：
|
1 |
pip install line_profiler |
安裝完成後，你將獲得一個新模組稱為 line_profiler 和 kernprof.py 可執行指令碼。
為了使用這個工具，首先在你想測量的函式上設定 @profile 修飾符。不用擔心，為了這個修飾符，你不需要引入任何東西。kernprof.py 指令碼會在執行時自動注入你的指令碼。
primes.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
@profile def primes(n): if n==2: return [2] elif n<2: return [] s=range(3,n+1,2) mroot = n ** 0.5 half=(n+1)/2-1 i=0 m=3 while m <= mroot: if s[i]: j=(m*m-3)/2 s[j]=0 while j<half: s[j]=0 j+=m i=i+1 m=2*i+3 return [2]+[x for x in s if x] primes(100) |
一旦你得到了你的設定了修飾符 @profile 的程式碼，使用 kernprof.py 執行這個指令碼。
|
1 |
kernprof.py -l -v fib.py |
-l 選項告訴 kernprof 把修飾符 @profile 注入你的指令碼，-v 選項告訴 kernprof 一旦你的指令碼完成後，展示計時資訊。這是一個以上指令碼的類似輸出：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
Wrote profile results to primes.py.lprof Timer unit: 1e-06 s File: primes.py Function: primes at line 2 Total time: 0.00019 s Line # Hits Time Per Hit % Time Line Contents ============================================================== 2 @profile 3 def primes(n): 4 1 2 2.0 1.1 if n==2: 5 return [2] 6 1 1 1.0 0.5 elif n<2: 7 return [] 8 1 4 4.0 2.1 s=range(3,n+1,2) 9 1 10 10.0 5.3 mroot = n ** 0.5 10 1 2 2.0 1.1 half=(n+1)/2-1 11 1 1 1.0 0.5 i=0 12 1 1 1.0 0.5 m=3 13 5 7 1.4 3.7 while m <= mroot: 14 4 4 1.0 2.1 if s[i]: 15 3 4 1.3 2.1 j=(m*m-3)/2 16 3 4 1.3 2.1 s[j]=0 17 31 31 1.0 16.3 while j<half: 18 28 28 1.0 14.7 s[j]=0 19 28 29 1.0 15.3 j+=m 20 4 4 1.0 2.1 i=i+1 21 4 4 1.0 2.1 m=2*i+3 22 50 54 1.1 28.4 return [2]+[x for x |
尋找 hits 值比較高的行或是一個高時間間隔。這些地方有最大的優化改進空間。
它使用了多少記憶體？
現在我們掌握了很好我們程式碼的計時資訊，讓我們繼續找出我們的程式使用了多少記憶體。我們真是非常幸運， Fabian Pedregosa 仿照 Robert Kern 的 line_profiler 實現了一個很好的記憶體分析器 [memory profiler][5]。
首先通過 pip 安裝它：
|
1 2 |
$ pip install -U memory_profiler $ pip install psutil |
在這裡建議安裝 psutil 是因為該包能提升 memory_profiler 的效能。
想 line_profiler 一樣， memory_profiler 要求在你設定 @profile 來修飾你的函式：
|
1 2 3 4 |
@profile def primes(n): ... ... |
執行如下命令來顯示你的函式使用了多少記憶體：
|
1 |
$ python -m memory_profiler primes.py |
一旦你的程式退出，你應該可以看到這樣的輸出：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
Filename: primes.py Line # Mem usage Increment Line Contents ============================================== 2 @profile 3 7.9219 MB 0.0000 MB def primes(n): 4 7.9219 MB 0.0000 MB if n==2: 5 return [2] 6 7.9219 MB 0.0000 MB elif n<2: 7 return [] 8 7.9219 MB 0.0000 MB s=range(3,n+1,2) 9 7.9258 MB 0.0039 MB mroot = n ** 0.5 10 7.9258 MB 0.0000 MB half=(n+1)/2-1 11 7.9258 MB 0.0000 MB i=0 12 7.9258 MB 0.0000 MB m=3 13 7.9297 MB 0.0039 MB while m <= mroot: 14 7.9297 MB 0.0000 MB if s[i]: 15 7.9297 MB 0.0000 MB j=(m*m-3)/2 16 7.9258 MB -0.0039 MB s[j]=0 17 7.9297 MB 0.0039 MB while j<half: 18 7.9297 MB 0.0000 MB s[j]=0 19 7.9297 MB 0.0000 MB j+=m 20 7.9297 MB 0.0000 MB i=i+1 21 7.9297 MB 0.0000 MB m=2*i+3 22 7.9297 MB 0.0000 MB return [2]+[x for x in s if x] |
line_profiler 和 memory_profiler 的 IPython 快捷命令
line_profiler 和 memory_profiler 一個鮮為人知的特性就是在 IPython 上都有快捷命令。你所能做的就是在 IPython 上鍵入以下命令：
|
1 2 3 |
%load_ext memory_profiler %load_ext line_profiler |
這樣做了以後，你就可以使用魔法命令 %lprun 和 %mprun 了，它們表現的像它們命令列的副本，最主要的不同就是你不需要給你需要分析的函式設定 @profile 修飾符。直接在你的 IPython 會話上繼續分析吧。
|
1 2 3 |
In [1]: from primes import primes In [2]: %mprun -f primes primes(1000) In [3]: %lprun -f primes primes(1000) |
這可以節省你大量的時間和精力,因為使用這些分析命令，你不需要修改你的原始碼。
哪裡記憶體溢位了？
cPython的直譯器使用引用計數來作為它跟蹤記憶體的主要方法。這意味著每個物件持有一個計數器，當增加某個物件的引用儲存的時候，計數器就會增加，當一個引用被刪除的時候，計數器就是減少。當計數器達到0， cPython 直譯器就知道該物件不再使用，因此直譯器將刪除這個物件，並且釋放該物件持有的記憶體。
記憶體洩漏往往發生在即使該物件不再使用的時候，你的程式還持有對該物件的引用。
最快速發現記憶體洩漏的方式就是使用一個由 Marius Gedminas 編寫的非常好的稱為 [objgraph][6] 的工具。
這個工具可以讓你看到在記憶體中物件的數量,也定位在程式碼中所有不同的地方,對這些物件的引用。
開始，我們首先安裝 objgraph
|
1 |
pip install objgraph |
一旦你安裝了這個工具，在你的程式碼中插入一個呼叫偵錯程式的宣告。
|
1 |
import pdb; pdb.set_trace() |
哪個物件最常見
在執行時,你可以檢查在執行在你的程式中的前20名最普遍的物件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
pdb) import objgraph (pdb) objgraph.show_most_common_types() MyBigFatObject 20000 tuple 16938 function 4310 dict 2790 wrapper_descriptor 1181 builtin_function_or_method 934 weakref 764 list 634 method_descriptor 507 getset_descriptor 451 type 439 |
哪個物件被增加或是刪除了？
我們能在兩個時間點之間看到哪些物件被增加或是刪除了。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
(pdb) import objgraph (pdb) objgraph.show_growth() . . . (pdb) objgraph.show_growth() # this only shows objects that has been added or deleted since last show_growth() call traceback 4 +2 KeyboardInterrupt 1 +1 frame 24 +1 list 667 +1 tuple 16969 +1 |
這個洩漏物件的引用是什麼？
繼續下去，我們還可以看到任何給定物件的引用在什麼地方。讓我們以下面這個簡單的程式舉個例子。
|
1 2 3 |
x = [1] y = [x, [x], {"a":x}] import pdb; pdb.set_trace() |
為了看到持有變數 X 的引用是什麼，執行 objgraph.show_backref() 函式：
|
1 2 |
(pdb) import objgraph (pdb) objgraph.show_backref([x], filename="/tmp/backrefs.png") |
該命令的輸出是一個 PNG 圖片，被儲存在 /tmp/backrefs.png，它應該看起來像這樣：
盒子底部有紅色字型就是我們感興趣的物件，我們可以看到它被符號 x 引用了一次，被列表 y 引用了三次。如果 x 這個物件引起了記憶體洩漏，我們可以使用這種方法來追蹤它的所有引用，以便看到為什麼它沒有被自動被收回。
回顧一遍，objgraph 允許我們：
- 顯示佔用 Python 程式記憶體的前 N 個物件
- 顯示在一段時期內哪些物件被增加了，哪些物件被刪除了
- 顯示我們指令碼中獲得的所有引用
Effort vs precision
在這篇文章中,我展示瞭如何使用一些工具來分析一個python程式的效能。通過這些工具和技術的武裝，你應該可以獲取所有要求追蹤大多數記憶體洩漏以及在Python程式快速識別瓶頸的資訊。
和許多其他主題一樣,執行效能分析意味著要在付出和精度之間的平衡做取捨。當有疑問是，用最簡單的方案，滿足你當前的需求。