一直以來，詬病 Python語言的人經常說，他們不想使用的一個原因是 Python 的速度太慢了。不管使用哪一種編程語言，程序運行速度的快慢在很大程度上還是取決於編寫程序的開發人員，以及他們編寫高效程序的技巧和能力。
那這可以說是 Python 開發者們的問題嗎？爲了證實一些不正確的看法，我們接下來就帶領大家一起看看想要提升 Python 程序的性能，加快運行速度 30%，有什麼方法？
時序和性能優化
在開始優化任何一段 Python 程序之前，我們首先需要找出哪部分代碼是拖慢整個程序運行速度的原因。有時候程序的瓶頸可能會很明顯，但更多時候不那麼容易被發現，爲了快速地定位瓶頸來進行優化，下面提供了一些查找瓶頸的方法：
以下我們以一段實際的代碼作爲示例，它用於進行指數運算（來源於Python文檔）：
# slow_program.py
from decimal import *
def exp(x):
getcontext().prec += 2
i, lasts, s, fact, num = 0, 0, 1, 1, 1
while s != lasts:
lasts = s
i += 1
fact *= i
num *= x
s += num / fact
getcontext().prec -= 2
return +s
exp(Decimal(150))
exp(Decimal(400))
exp(Decimal(3000))
最簡單的優化
首先，最簡單的、最實用的性能優化的解決辦法是利用 Unix 的 time 命令，time可以監控程序執行的時間：
~ $ time python3.8 slow_program.py
real 0m11,058s
user 0m11,050s
sys 0m0,008s
如果你只想給整個程序的運行計時，這是可行的，但通常來說還是遠遠不夠的…
最詳細的性能分析
另外一個可以利用的指令是 cProfile，但是它提供的信息又過於詳細了：
~ $ python3.8 -m cProfile -s time slow_program.py
1297 function calls (1272 primitive calls) in 11.081 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
3 11.079 3.693 11.079 3.693 slow_program.py:4(exp)
1 0.000 0.000 0.002 0.002 {built-in method _imp.create_dynamic}
4/1 0.000 0.000 11.081 11.081 {built-in method builtins.exec}
6 0.000 0.000 0.000 0.000 {built-in method __new__ of type object at 0x9d12c0}
6 0.000 0.000 0.000 0.000 abc.py:132(__new__)
23 0.000 0.000 0.000 0.000 _weakrefset.py:36(__init__)
245 0.000 0.000 0.000 0.000 {built-in method builtins.getattr}
2 0.000 0.000 0.000 0.000 {built-in method marshal.loads}
10 0.000 0.000 0.000 0.000 <frozen importlib._bootstrap_external>:1233(find_spec)
8/4 0.000 0.000 0.000 0.000 abc.py:196(__subclasscheck__)
15 0.000 0.000 0.000 0.000 {built-in method posix.stat}
6 0.000 0.000 0.000 0.000 {built-in method builtins.__build_class__}
1 0.000 0.000 0.000 0.000 __init__.py:357(namedtuple)
48 0.000 0.000 0.000 0.000 <frozen importlib._bootstrap_external>:57(_path_join)
48 0.000 0.000 0.000 0.000 <frozen importlib._bootstrap_external>:59(<listcomp>)
1 0.000 0.000 11.081 11.081 slow_program.py:1(<module>)
...
在這裏，我們使用 cProfile 模塊和 time 參數來運行測試腳本，以便按內部運行時間（cumtime）對行數據進行排序。這會提供給我們很多的信息，在上圖中你可以看到顯示的行數大約只是實際輸出的十分之一。因此，我們可以看出exp函數是耗時的罪魁禍首，現在我們可以更進一步地瞭解時序和性能優化了。
時序特定功能
既然我們知道性能瓶頸所在，那麼我們可能希望給運行起來比較耗時的函數進行計時，而不用關注其餘部分的代碼了。爲此，我們可以使用一個簡單的 decorator（裝飾器）：
def timeit_wrapper(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter() # Alternatively, you can use time.process_time()
func_return_val = func(*args, **kwargs)
end = time.perf_counter()
print('{0:<10}.{1:<8} : {2:<8}'.format(func.__module__, func.__name__, end - start))
return func_return_val
return wrapper
這個decorator可以應用於後面的待測函數，如下圖中的代碼所示：
@timeit_wrapper
def exp(x):
...
print('{0:<10} {1:<8} {2:^8}'.format('module', 'function', 'time'))
exp(Decimal(150))
exp(Decimal(400))
exp(Decimal(3000))
我們會得到如下的輸出結果：
~ $ python3.8 slow_program.py
module function time
__main__ .exp : 0.003267502994276583
__main__ .exp : 0.038535295985639095
__main__ .exp : 11.728486061969306
需要考慮的一件事，是我們實際想要測量的運行時間。時間包裏提供了time.perf_counter和time.process_time。在這裏的區別在於perf_counter返回的是絕對值，其中包括Python程序執行進程未運行的時間，因此它可能會受到計算機負載量的影響。另一方面，process_time只返回用戶時間（不包括系統時間），這只是你的進程執行時間。
加速
現在，我們進入有趣的部分，讓你的 Python 程序運行的更快。我基本上不會展示一些能夠解決程序性能問題的技巧和代碼，更多的是關於通常的思路和策略，在使用的時候，它們可能會對性能產生巨大的影響，在某些情況下，可以將程序運行速度提高30%。
使用內置數據類型
這一點很明顯。內置的數據類型執行起來非常的快，特別是與我們自定義的數據類型相比，比如樹或者鏈表。這主要是因爲內置代碼是由C語言實現的，因此，我們在使用 Python 編寫代碼時，在速度上實在是無法與其相比。
使用 lru_cache 緩存
我已經在上一篇文章中提及了這一技術，但我認爲有必要用一個簡單的例子再來說一下：
import functools
import time
# caching up to 12 different results
@functools.lru_cache(maxsize=12)
def slow_func(x):
time.sleep(2) # Simulate long computation
return x
slow_func(1) # ... waiting for 2 sec before getting result
slow_func(1) # already cached - result returned instantaneously!
slow_func(3) # ... waiting for 2 sec before getting result
上面代碼中的函數使用了 time.sleep 模擬了密集型計算任務。當第一次使用參數 1 進行調用時，它等待了 2 秒，之後才返回結果。而當再次調用的時候，結果已被緩存了，因此它跳過函數體的執行並立即返回了結果。有關更多實際應用的例子，請參見以前的博客文章。
使用局部變量
這與在每個作用域裏查找一些變量的速度有關係，每個作用域不僅僅是局部變量跟全局變量。實際上，即使是在函數的局部變量（最快）、類級屬性（例如self.name，較慢）和全局變量（例如time.time，最慢）之間，查找速度也存在着明顯的差異。
你可以通過使用一些看起來不必要的任務來提高性能，如下面的代碼所示：
# Example #1
class FastClass:
def do_stuff(self):
temp = self.value # this speeds up lookup in loop
for i in range(10000):
... # Do something with `temp` here
# Example #2
import random
def fast_function():
r = random.random
for i in range(10000):
print(r()) # calling `r()` here, is faster than global random.random()
使用函數
這看起來似乎有悖於常理，因爲調用函數會將更多的東西放入堆棧裏，並從函數的返回過程中產生額外的性能開銷，但這與前面說的一點有關係。如果只將整個代碼打包在一個文件裏，而不是將其放在函數中，那樣就會由於全局變量而導致運行速度要慢得多。因此，只需將整個代碼打包到main函數之中並只調用一次，就可以提高代碼運行的速度，如下圖所示：
def main():
... # All your previously global code
main()
不要訪問屬性
另一個可能會影響程序運行速度的是，點運算符訪問對象屬性的過程。點運算符使用__getattribute__觸發數據字典查找的操作，這會在代碼中產生額外的開銷。那麼，我們如何才能真正地避免或者是限制使用它呢？見下圖中的代碼：
# Slow:
import re
def slow_func():
for i in range(10000):
re.findall(regex, line) # Slow!
# Fast:
from re import findall
def fast_func():
for i in range(10000):
findall(regex, line) # Faster!
注意字符串
在循環中使用如module（%s）或者.format（）的時候，對字符串的操作可能會非常的慢。那我們還有什麼更好的選擇呢？根據Raymond Hettinger最近的推特文章，我們應該使用的是f-string，它是最易讀、最簡潔並且最快速的方法。因此，根據今天的介紹方法，以下是大家可以使用的方法列表 — 由最快到最慢排列：
f'{s} {t}' # Fast!
s + ' ' + t
' '.join((s, t))
'%s %s' % (s, t)
'{} {}'.format(s, t)
Template('$s $t').substitute(s=s, t=t) # Slow!
生成器本身並不會更快，因爲它們是爲了進行延遲計算而設計的，這樣可以節省內存而不是節省時間。但是，節省下的內存實際上可能會讓程序運行的更快。這是怎麼做到的呢？如果你有一個很大的數據集，並且沒有使用生成器（迭代器），那麼數據有可能會溢出CPUs L1緩存，這將大大地減慢了在內存中查找值的速度。
在性能方面，非常重要的一點是CPU可以將所有正在處理的數據儘可能地保存在緩存之中。
結論
優化的第一條規則是不要優化。但是，如果你確實需要的話，那麼我希望以上的這幾條建議可以幫到你。但是，在優化代碼的時候一定要小心，因爲它可能會讓你的代碼失去了可讀性，導致程序難以維護，這可能就超過了優化的好處。
