討厭 Python 的人總是說(shuō)，他們不想使用 Python 的原因之一是它的速度太慢。好吧，不管使用哪種編程語(yǔ)言，具體的程序是快還是慢，在很大程度上取決于編寫(xiě)程序的開(kāi)發(fā)人員以及他們編寫(xiě)優(yōu)化、快速程序的能力。              

所以，讓我們來(lái)證明那些人是錯(cuò)的——讓我們看看如何提高 Python 程序的性能并使它們變得非常快！

時(shí)間和性能              

在開(kāi)始優(yōu)化任何代碼之前，我們首先需要找出代碼的哪些部會(huì)減慢整個(gè)程序的速度。有時(shí)，程序的瓶頸可能很明顯，但如果你不知道它在哪里，那么你可以從下面幾個(gè)地方找到它：              

注意：這是我用于演示的程序，它將 e 計(jì)算為 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))

最懶的「剖析」

首先，最簡(jiǎn)單、最懶的解決方案——Unix time 命令：

~ $ time python3.8 slow_program.py

real 0m11,058s
user 0m11,050s
sys  0m0,008s

如果你只想給你的整個(gè)程序計(jì)時(shí)，這是可行的，但這通常是不夠的。       

最詳細(xì)的分析              

另一個(gè)是 cProfile，它會(huì)給你提供特別多的信息：

~ $ 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ù)運(yùn)行測(cè)試腳本，以便按內(nèi)部時(shí)間（cumtime）對(duì)行進(jìn)行排序。這給了我們很多信息，你可以看到上面的行大約是實(shí)際輸出的 10%。由此我們可以看出 exp 函數(shù)是罪魁禍?zhǔn)祝ㄊ遣皇歉械胶荏@奇？），現(xiàn)在我們可以更具體地了解時(shí)間和分析了！

特定函數(shù)計(jì)時(shí) 

既然我們知道該將注意力集中在哪里，我們可能希望對(duì)慢函數(shù)進(jìn)行計(jì)時(shí)，而不測(cè)量代碼的其余部分。為此，我們可以使用簡(jiǎn)單的 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

這個(gè) decorator 隨后可以應(yīng)用于測(cè)試中的函數(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

這里要考慮的一件事是，我們實(shí)際想要測(cè)量的是什么樣的時(shí)間。時(shí)間包提供 time.perf_counter 和 time.process_time。這里的區(qū)別在于 perf_counter 返回絕對(duì)值，其中包括 Python 程序進(jìn)程未運(yùn)行的時(shí)間，因此它可能會(huì)受到機(jī)器負(fù)載的影響。另一方面，process_time 只返回用戶時(shí)間（不包括系統(tǒng)時(shí)間），這只是進(jìn)程的時(shí)間。

使程序更快 

現(xiàn)在，有趣的是。讓我們讓你的 Python 程序運(yùn)行得更快。我基本上不會(huì)向你展示一些能夠神奇地解決性能問(wèn)題的技巧和代碼片段。這更多的是關(guān)于一般的想法和策略，當(dāng)你使用這些策略時(shí)，它們可以對(duì)性能產(chǎn)生巨大的影響，在某些情況下甚至可以提高 30% 的速度。

使用內(nèi)置數(shù)據(jù)類型 

這一點(diǎn)很明顯。內(nèi)置數(shù)據(jù)類型非?？?，特別是與我們的自定義類型（如樹(shù)或鏈列表）相比。這主要是因?yàn)閮?nèi)置代碼是用 C 語(yǔ)言實(shí)現(xiàn)的，在用 Python 編寫(xiě)代碼時(shí)，我們?cè)谒俣壬蠠o(wú)法與之相比。

使用 lru 緩存的緩存/備忘錄 

我已經(jīng)在之前的博文（https://martinheinz.dev/blog/4）中寫(xiě)過(guò)這個(gè)，但是我認(rèn)為有必要用一個(gè)簡(jiǎn)單的例子來(lái)重復(fù)一下：

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 模擬繁重的計(jì)算。當(dāng)?shù)谝淮问褂脜?shù) 1 調(diào)用時(shí)，它等待 2 秒，然后才返回結(jié)果。再次調(diào)用時(shí)，結(jié)果已被緩存，因此它跳過(guò)函數(shù)體并立即返回結(jié)果。更多例子，請(qǐng)看之前的博文：https://martinheinz.dev/blog/4 。              

使用局部變量              

這與在每個(gè)范圍內(nèi)查找變量的速度有關(guān)。我編寫(xiě)每個(gè)作用域，因?yàn)樗粌H僅和局部變量和全局變量的使用有關(guān)。實(shí)際上，在函數(shù)中的局部變量、類級(jí)屬性和全局之間的查找速度也存在差異。              

你可以通過(guò)使用看起來(lái)不必要的任務(wù)來(lái)提高性能，比如：

#  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ù)              

這似乎有悖常理，因?yàn)檎{(diào)用函數(shù)會(huì)把更多的東西放到堆棧中，并從函數(shù)返回中產(chǎn)生開(kāi)銷(xiāo)，但這與前面的觀點(diǎn)有關(guān)。如果只將所有的代碼放在一個(gè)文件中而不將其放在函數(shù)中，由于全局變量，程序會(huì)變慢很多。因此，只需將整個(gè)代碼包裝在 main 函數(shù)中并調(diào)用一次，就可以加快代碼的速度，如下所示：

def main():
    ...  # All your previously global code

main()

不訪問(wèn)屬性              

另一個(gè)可能會(huì)減慢程序速度的是點(diǎn)運(yùn)算符（.），它在訪問(wèn)對(duì)象屬性時(shí)使用。此運(yùn)算符使用 getattribute 觸發(fā)字典查找，這會(huì)在代碼中產(chǎn)生額外的開(kāi)銷(xiāo)。那么，我們?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（）運(yùn)行時(shí)，對(duì)字符串的操作可能會(huì)非常慢。我們還有什么更好的選擇？根據(jù) Raymond Hettinger 最近的推文（https://twitter.com/raymondh/status/1205969258800275456），我們唯一應(yīng)該使用的是 f-string，它是最可讀、最簡(jiǎn)潔、最快的方法。因此，根據(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!

迭代器可以很快              

迭代器本身并不會(huì)更快，因?yàn)樗鼈兪菫樵试S惰性計(jì)算而設(shè)計(jì)的，這樣可以節(jié)省內(nèi)存而不是時(shí)間。但是，保存的內(nèi)存可能會(huì)導(dǎo)致程序?qū)嶋H運(yùn)行得更快。這是為什么？好吧，如果你有大型數(shù)據(jù)集，并且不使用迭代器，那么數(shù)據(jù)可能會(huì)溢出 cpu L1 緩存，這將顯著減慢在內(nèi)存中查找值的速度。              

在性能方面，CPU 可以盡可能地保存它正在處理的所有數(shù)據(jù)，這一點(diǎn)非常重要，這些數(shù)據(jù)都在緩存中。你可以看 Raymond Hettingers 的訪談（https://www.youtube.com/watch?v=OSGv2VnC0go&t=8m17s ），他提到了這些問(wèn)題。              

結(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)載。詳情見(jiàn)轉(zhuǎn)載須知。