當執行一個複雜的 Python 程式，它需要很長時間來執行。你或許想提升它的執行時間。但如何做？
首先，你需要工具來查明你程式碼的瓶頸，比如，那部分執行花費的時間長。用這個方法，你可以首先專注於提升這部分的速度。
而且，你也應該控制記憶體和 CPU 使用率，因為它可以為你指出的程式碼可以改進的新的部分。
所以，在本文中，我將對 7 個不同的 Python 工具發表意見，給你一些關於你函式執行時間和記憶體以及 CPU 使用率的見解。
1. 使用一個裝飾器來測量你的函式
測量一個函式最簡單的方式就是定義一個裝飾器來測量執行該函式的執行時間，並列印該結果：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import time from functools import wraps def fn_timer(function): @wraps(function) def function_timer(*args, **kwargs): t0 = time.time() result = function(*args, **kwargs) t1 = time.time() print ("Total time running %s: %s seconds" % (function.func_name, str(t1-t0)) ) return result return function_timer |
這時，你已經在你想測量的函式之前新增了裝飾器，像：
|
1 2 3 4 |
@fn_timer def myfunction(...): ... |
例如，讓我們測量下排序一個 2000000 個隨機數的陣列會花費多長時間：
|
1 2 3 4 5 6 7 8 |
@fn_timer def random_sort(n): return sorted([random.random() for i in range(n)]) if __name__ == "__main__": random_sort(2000000) |
如果你執行你的指令碼，你將看到：
|
1 2 |
Total time running random_sort: 1.41124916077 seconds |
2. 使用 timeit 模組
另外一個選項是使用 timeit 模組，它給你測量一個平均時間。
為了執行它，在你的終端執行以下命令：
|
1 2 |
$ python -m timeit -n 4 -r 5 -s "import timing_functions" "timing_functions.random_sort(2000000)" |
timing_functions 是你指令碼的名字。
在輸出的最後，你會看到一些像這樣的東西：
|
1 2 |
4 loops, best of 5: 2.08 sec per loop |
表明了執行這個測試 4 次（-n 4），並在每個測試中重複平均 5 次（-r 5），最佳的結果是 2.08 秒。
如果你沒有指定測試或者重複，它預設是 10 次迴圈和 5 次重複。
3. 使用 Uinx 的 time 命令
儘管如此，裝飾器和 timeit 模組都是基於 Python 的。這就是為什麼 unix time 工具或許有用，因為它是一個外部的 Python 測量。
為了執行 time 工具型別：
|
1 2 |
$ time -p python timing_functions.py |
將給出如下輸出：
|
1 2 3 4 5 |
Total time running random_sort: 1.3931210041 seconds real 1.49 user 1.40 sys 0.08 |
第一行來自於我們定義的裝飾器，其他三行是：
- real 表明了執行指令碼花費的總時間
- User 表明了執行指令碼花費在的 CPU 時間
- Sys 表明了執行指令碼花費在核心函式的時間
因此， real time 和 user+sys 相加的不同或許表明了時間花費在等待 I/O 或者是系統在忙於執行其他任務。
4. 使用 cProfile 模組
如果你想知道花費在每個函式和方法上的時間，以及它們被呼叫了多少次，你可以使用 cProfile 模組。
|
1 2 |
$ python -m cProfile -s cumulative timing_functions.py |
現在你將看到你的程式碼中每個函式被呼叫多少次的詳細描述，並且它將通過累積花費在每個函式上面的時間來排序（感謝 -s cumulative 選項）
你將看到花費在執行你的指令碼的總時間是比以前高的。這是我們測量每個函式執行時間的損失。
5. 使用 line_profiler 模組
line_profiler 給出了在你程式碼每一行花費的 CPU 時間。
這個模組首先應該被安裝，使用命令：
|
1 2 |
$ pip install line_profiler |
下一步，你需要指定你想使用裝飾器 @profile 評估哪個函式（你不需要把它 import 到你的檔案中）。
|
1 2 3 4 5 6 7 8 9 |
@profile def random_sort2(n): l = [random.random() for i in range(n)] l.sort() return l if __name__ == "__main__": random_sort2(2000000) |
最後，你可以通過鍵入以下命令取得 random_sort2 函式逐行的描述：
|
1 2 |
$ kernprof -l -v timing_functions.py |
-l 標識表明了逐行和 -v 標識表明詳細輸出。使用這個方法，我們看到了陣列結構花費了 44% 的計算時間，sort() 方法花費了剩餘的 56%。
你也將看到，由於時間測量，這個指令碼執行花費的或許更長。
6. 使用 memory_profiler 模組
memory_profiler 模組被用於在逐行的基礎上，測量你程式碼的記憶體使用率。儘管如此，它可能使得你的程式碼執行的更慢。
安裝：
|
1 2 |
$ pip install memory_profiler |
也建議安裝 psutil 包，使得 memory_profile 模組執行的更快：
|
1 2 |
$ pip install psutil |
類似 line_profiler 的方式，使用裝飾器 @profile 來標記哪個函式被跟蹤。下一步，鍵入：
|
1 2 |
$ python -m memory_profiler timing_functions.py |
是的，前面的指令碼比之前的 1 或 2 秒需要更長的時間。並且，如果你不安裝 psutil 模組，你將一直等待結果。
看上面的輸出，注意記憶體使用率的單位是 MiB，這代表的是兆位元組（1MiB = 1.05MB）。
7. 使用 guppy 包
最後，使用這個包，你可以跟蹤每個型別在你程式碼中每個階段（字元， 元組， 字典 等等）有多少物件被建立了。
安裝：
|
1 2 |
$ pip install guppy |
下一步，像這樣新增到你的程式碼中：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from guppy import hpy def random_sort3(n): hp = hpy() print "Heap at the beginning of the functionn", hp.heap() l = [random.random() for i in range(n)] l.sort() print "Heap at the end of the functionn", hp.heap() return l if __name__ == "__main__": random_sort3(2000000) |
並且這樣執行你的程式碼：
|
1 2 |
$ python timing_functions.py |
你將看到一些像下面的輸出：
通過配置 heap 在你的程式碼的不同地方，你可以在指令碼中學到物件的建立和銷燬。
如果你想學習更多提升你 Python 程式碼的知識，我建議你看看 2014 年 11 月出版的 High Performance Python: Practical Performant Programming for Humans 這本書。