0
討厭 Python 的人總是說，他們不想使用 Python 的原因之一是它的速度太慢。好吧，不管使用哪種編程語言，具體的程序是快還是慢，在很大程度上取決于編寫程序的開發(fā)人員以及他們編寫優(yōu)化、快速程序的能力。
所以，讓我們來證明那些人是錯的——讓我們看看如何提高 Python 程序的性能并使它們變得非?？?！
時間和性能
在開始優(yōu)化任何代碼之前，我們首先需要找出代碼的哪些部會減慢整個程序的速度。有時，程序的瓶頸可能很明顯，但如果你不知道它在哪里，那么你可以從下面幾個地方找到它：
注意：這是我用于演示的程序，它將 e 計算為 X 的冪（取自 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 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 參數(shù)運行測試腳本，以便按內(nèi)部時間（cumtime）對行進行排序。這給了我們很多信息，你可以看到上面的行大約是實際輸出的 10%。由此我們可以看出 exp 函數(shù)是罪魁禍首（是不是感到很驚奇？），現(xiàn)在我們可以更具體地了解時間和分析了！
特定函數(shù)計時
既然我們知道該將注意力集中在哪里，我們可能希望對慢函數(shù)進行計時，而不測量代碼的其余部分。為此，我們可以使用簡單的 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 隨后可以應(yīng)用于測試中的函數(shù)，如下所示：
@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。這里的區(qū)別在于 perf_counter 返回絕對值，其中包括 Python 程序進程未運行的時間，因此它可能會受到機器負載的影響。另一方面，process_time 只返回用戶時間（不包括系統(tǒng)時間），這只是進程的時間。
使程序更快
現(xiàn)在，有趣的是。讓我們讓你的 Python 程序運行得更快。我基本上不會向你展示一些能夠神奇地解決性能問題的技巧和代碼片段。這更多的是關(guān)于一般的想法和策略，當你使用這些策略時，它們可以對性能產(chǎn)生巨大的影響，在某些情況下甚至可以提高 30% 的速度。
使用內(nèi)置數(shù)據(jù)類型
這一點很明顯。內(nèi)置數(shù)據(jù)類型非?？?，特別是與我們的自定義類型（如樹或鏈列表）相比。這主要是因為內(nèi)置代碼是用 C 語言實現(xiàn)的，在用 Python 編寫代碼時，我們在速度上無法與之相比。
使用 lru 緩存的緩存/備忘錄
我已經(jīng)在之前的博文（https://martinheinz.dev/blog/4）中寫過這個，但是我認為有必要用一個簡單的例子來重復一下：
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
上面的函數(shù)使用 time.sleep 模擬繁重的計算。當?shù)谝淮问褂脜?shù) 1 調(diào)用時，它等待 2 秒，然后才返回結(jié)果。再次調(diào)用時，結(jié)果已被緩存，因此它跳過函數(shù)體并立即返回結(jié)果。更多例子，請看之前的博文：https://martinheinz.dev/blog/4 。
使用局部變量
這與在每個范圍內(nèi)查找變量的速度有關(guān)。我編寫每個作用域，因為它不僅僅和局部變量和全局變量的使用有關(guān)。實際上，在函數(shù)中的局部變量、類級屬性和全局之間的查找速度也存在差異。
你可以通過使用看起來不必要的任務(wù)來提高性能，比如：
# 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()
使用函數(shù)
這似乎有悖常理，因為調(diào)用函數(shù)會把更多的東西放到堆棧中，并從函數(shù)返回中產(chǎn)生開銷，但這與前面的觀點有關(guān)。如果只將所有的代碼放在一個文件中而不將其放在函數(shù)中，由于全局變量，程序會變慢很多。因此，只需將整個代碼包裝在 main 函數(shù)中并調(diào)用一次，就可以加快代碼的速度，如下所示：
def main():
... # All your previously global code
main()
不訪問屬性
另一個可能會減慢程序速度的是點運算符（.），它在訪問對象屬性時使用。此運算符使用 getattribute 觸發(fā)字典查找，這會在代碼中產(chǎn)生額外的開銷。那么，我們?nèi)绾尾拍苷嬲苊馐褂盟兀?/p>
# 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!
小心字符串
在循環(huán)中使用例如 module（%s）或 .format（）運行時，對字符串的操作可能會非常慢。我們還有什么更好的選擇？根據(jù) Raymond Hettinger 最近的推文（https://twitter.com/raymondh/status/1205969258800275456），我們唯一應(yīng)該使用的是 f-string，它是最可讀、最簡潔、最快的方法。因此，根據(jù)這條推文，這是你可以使用的方法——從最快到最慢：
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!
迭代器可以很快
迭代器本身并不會更快，因為它們是為允許惰性計算而設(shè)計的，這樣可以節(jié)省內(nèi)存而不是時間。但是，保存的內(nèi)存可能會導致程序?qū)嶋H運行得更快。這是為什么？好吧，如果你有大型數(shù)據(jù)集，并且不使用迭代器，那么數(shù)據(jù)可能會溢出 cpu L1 緩存，這將顯著減慢在內(nèi)存中查找值的速度。
在性能方面，CPU 可以盡可能地保存它正在處理的所有數(shù)據(jù)，這一點非常重要，這些數(shù)據(jù)都在緩存中。你可以看 Raymond Hettingers 的訪談（https://www.youtube.com/watch?v=OSGv2VnC0go&t=8m17s ），他提到了這些問題。
結(jié)論
優(yōu)化的第一條規(guī)則是不要優(yōu)化。但是，如果你真的需要的話，我希望這幾條建議能幫到你。
via：https://martinheinz.dev/blog/13
雷鋒網(wǎng)雷鋒網(wǎng)雷鋒網(wǎng)
雷峰網(wǎng)版權(quán)文章，未經(jīng)授權(quán)禁止轉(zhuǎn)載。詳情見轉(zhuǎn)載須知。
