日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
代碼跑得慢甩鍋Python？手把手教你如何給代碼提速30%

大數(shù)據(jù)文摘出品

目前累計服務(wù)客戶近1000家，積累了豐富的產(chǎn)品開發(fā)及服務(wù)經(jīng)驗。以網(wǎng)站設(shè)計水平和技術(shù)實力，樹立企業(yè)形象，為客戶提供網(wǎng)站設(shè)計制作、做網(wǎng)站、網(wǎng)站策劃、網(wǎng)頁設(shè)計、網(wǎng)絡(luò)營銷、VI設(shè)計、網(wǎng)站改版、漏洞修補等服務(wù)。創(chuàng)新互聯(lián)公司始終以務(wù)實、誠信為根本，不斷創(chuàng)新和提高建站品質(zhì)，通過對領(lǐng)先技術(shù)的掌握、對創(chuàng)意設(shè)計的研究、對客戶形象的視覺傳遞、對應(yīng)用系統(tǒng)的結(jié)合，為客戶提供更好的一站式互聯(lián)網(wǎng)解決方案，攜手廣大客戶，共同發(fā)展進(jìn)步。

來源：Medium

編譯：王轉(zhuǎn)轉(zhuǎn)

Python已經(jīng)得到了全球程序員的喜愛，但是還是遭到一些人的詬病，原因之一就是認(rèn)為它運行緩慢。

其實某個特定程序(無論使用何種編程語言)的運行速度是快還是慢，在很大程度上取決于編寫該程序的開發(fā)人員自身素質(zhì)，以及他們編寫優(yōu)化而高效代碼的能力。

Medium上一位小哥就詳細(xì)講了講如何讓python提速30%，以此證明代碼跑得慢不是python的問題，而是代碼本身的問題。

時序分析

在開始進(jìn)行任何優(yōu)化之前，我們首先需要找出代碼的哪些部分使整個程序變慢。有時程序的問題很明顯，但是如果你一時不知道問題出在哪里，那么這里有一些可能的選項：

注意：這是我將用于演示的程序，它將進(jìn)行指數(shù)計算(取自Python文檔)：

 
 
 
 
      
  
  
  
  1. # slow_program.py 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. from decimal import * 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. def exp(x): 
    6.   
  
  
  
  6.     getcontext().prec += 2 
    7.   
  
  
  
  7.     i, lasts, s, fact, num = 0, 0, 1, 1, 1 
    8.   
  
  
  
  8.     while s != lasts: 
    9.   
  
  
  
  9.         lasts = s 
    10.   
  
  
  
  10.         i += 1 
    11.   
  
  
  
  11.         fact *= i 
    12.   
  
  
  
  12.         num *= x 
    13.   
  
  
  
  13.         s += num / fact 
    14.   
  
  
  
  14.     getcontext().prec -= 2 
    15.   
  
  
  
  15.     return +s 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. exp(Decimal(150)) 
    18.   
  
  
  
  18. exp(Decimal(400)) 
    19.   
  
  
  
  19. exp(Decimal(3000)) 
    20.

最簡約的“配置文件”

首先，最簡單最偷懶的方法——Unix時間命令。

 
 
 
 
      
  
  
  
  1. ~ $ time python3.8 slow_program.py 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. real  0m11,058s 
    4.   
  
  
  
  4. user 0m11,050s 
    5.   
  
  
  
  5. sys 0m0,008s 
    6.

如果你只能直到整個程序的運行時間，這樣就夠了，但通常這還遠(yuǎn)遠(yuǎn)不夠。

最詳細(xì)的分析

另外一個指令是cProfile，但是它提供的信息過于詳細(xì)了。

 
 
 
 
      
  
  
  
  1. ~ $ python3.8 -m cProfile -s time slow_program.py 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.          1297 function calls (1272 primitive calls) in 11.081 seconds 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.    Ordered by: internal time 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.    ncalls tottime percall cumtime percall filename:lineno(function) 
    8.   
  
  
  
  8.         3   11.079    3.693   11.079    3.693 slow_program.py:4(exp) 
    9.   
  
  
  
  9.         1    0.000    0.000    0.002    0.002 {built-in method _imp.create_dynamic} 
    10.   
  
  
  
  10.       4/1    0.000    0.000   11.081   11.081 {built-in method builtins.exec} 
    11.   
  
  
  
  11.         6    0.000    0.000    0.000    0.000 {built-in method __new__ of type object at 0x9d12c0} 
    12.   
  
  
  
  12.         6    0.000    0.000    0.000    0.000 abc.py:132(__new__) 
    13.   
  
  
  
  13.        23    0.000    0.000    0.000    0.000 _weakrefset.py:36(__init__) 
    14.   
  
  
  
  14.       245    0.000    0.000    0.000    0.000 {built-in method builtins.getattr} 
    15.   
  
  
  
  15.         2    0.000    0.000    0.000    0.000 {built-in method marshal.loads} 
    16.   
  
  
  
  16.        10    0.000    0.000    0.000    0.000 :1233(find_spec) 
    17.   
  
  
  
  17.       8/4    0.000    0.000    0.000    0.000 abc.py:196(__subclasscheck__) 
    18.   
  
  
  
  18.        15    0.000    0.000    0.000    0.000 {built-in method posix.stat} 
    19.   
  
  
  
  19.         6    0.000    0.000    0.000    0.000 {built-in method builtins.__build_class__} 
    20.   
  
  
  
  20.         1    0.000    0.000    0.000    0.000 __init__.py:357(namedtuple) 
    21.   
  
  
  
  21.        48    0.000    0.000    0.000    0.000 :57(_path_join) 
    22.   
  
  
  
  22.        48    0.000    0.000    0.000    0.000 :59() 
    23.   
  
  
  
  23.         1    0.000    0.000   11.081   11.081 slow_program.py:1() 
    24.

在這里，我們使用cProfile模塊和time參數(shù)運行測試腳本，以便按內(nèi)部時間(cumtime)對行進(jìn)行排序。這給了我們很多信息，你在上面看到的行大約是實際輸出的10%。由此可見，exp函數(shù)是罪魁禍?zhǔn)?，現(xiàn)在我們可以更詳細(xì)地了解時序和性能分析。

時序特定功能

現(xiàn)在我們知道了應(yīng)當(dāng)主要關(guān)注哪里，我們可能想對運行速度緩慢的函數(shù)計時，而不用測量其余的代碼。為此，我們可以使用一個簡單的裝飾器：

 
 
 
 
      
  
  
  
  1. def timeit_wrapper(func): 
    2.   
  
  
  
  2.     @wraps(func) 
    3.   
  
  
  
  3.     def wrapper(*args, **kwargs): 
    4.   
  
  
  
  4.         start = time.perf_counter() # Alternatively, you can use time.process_time() 
    5.   
  
  
  
  5.         funcfunc_return_val = func(*args, **kwargs) 
    6.   
  
  
  
  6.         end = time.perf_counter() 
    7.   
  
  
  
  7.         print('{0:<10}.{1:<8} : {2:<8}'.format(func.__module__, func.__name__, end - start)) 
    8.   
  
  
  
  8.         return func_return_val 
    9.   
  
  
  
  9.     return wrapper 
    10.

然后可以將此裝飾器應(yīng)用于待測功能，如下所示：

 
 
 
 
      
  
  
  
  1. @timeit_wrapper 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. def exp(x): 
    4.   
  
  
  
  4.     ... 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. print('{0:<10} {1:<8} {2:^8}'.format('module', 'function', 'time')) 
    7.   
  
  
  
  7. exp(Decimal(150)) 
    8.   
  
  
  
  8. exp(Decimal(400)) 
    9.   
  
  
  
  9. exp(Decimal(3000)) 
    10.

這給出我們?nèi)缦螺敵觯?/p>

 
 
 
 
      
  
  
  
  1. ~ $ python3.8 slow_program.py 
    2.   
  
  
  
  2. module function   time   
    3.   
  
  
  
  3. __main__ .exp      : 0.003267502994276583 
    4.   
  
  
  
  4. __main__ .exp      : 0.038535295985639095 
    5.   
  
  
  
  5. __main__ .exp      : 11.728486061969306 
    6.

需要考慮的一件事是我們實際想要測量的時間。時間包提供time.perf_counter和time.process_time兩個函數(shù)。他們的區(qū)別在于perf_counter返回的絕對值，包括你的Python程序進(jìn)程未運行時的時間，因此它可能會受到計算機負(fù)載的影響。另一方面，process_time僅返回用戶時間(不包括系統(tǒng)時間)，這僅是你的過程時間。

加速吧!

讓Python程序運行得更快，這部分會很有趣!我不會展示可以解決你的性能問題的技巧和代碼，更多地是關(guān)于構(gòu)想和策略的，這些構(gòu)想和策略在使用時可能會對性能產(chǎn)生巨大影響，在某些情況下，可以將速度提高30%。

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

這一點很明顯。內(nèi)置數(shù)據(jù)類型非常快，尤其是與我們的自定義類型(例如樹或鏈接列表)相比。這主要是因為內(nèi)置程序是用C實現(xiàn)的，因此在使用Python進(jìn)行編碼時我們的速度實在無法與之匹敵。

使用lru_cache緩存/記憶

我已經(jīng)在上一篇博客中展示了此內(nèi)容，但我認(rèn)為值得用簡單的示例來重復(fù)它：

 
 
 
 
      
  
  
  
  1. import functools 
    2.   
  
  
  
  2. import time 
    3.   
  
  
  
  3. # caching up to 12 different results 
    4.   
  
  
  
  4. @functools.lru_cache(maxsize=12) 
    5.   
  
  
  
  5. def slow_func(x): 
    6.   
  
  
  
  6.     time.sleep(2) # Simulate long computation 
    7.   
  
  
  
  7.     return x 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. slow_func(1) # ... waiting for 2 sec before getting result 
    10.   
  
  
  
  10. slow_func(1) # already cached - result returned instantaneously! 
    11.   
  
  
  
  11. slow_func(3) # ... waiting for 2 sec before getting result 
    12.

上面的函數(shù)使用time.sleep模擬大量計算。第一次使用參數(shù)1調(diào)用時，它將等待2秒鐘，然后才返回結(jié)果。再次調(diào)用時，結(jié)果已經(jīng)被緩存，因此它將跳過函數(shù)的主體并立即返回結(jié)果。有關(guān)更多實際示例，請參見以前的博客文章。

使用局部變量

這與在每個作用域中查找變量的速度有關(guān)，因為它不只是使用局部變量還是全局變量。實際上，即使在函數(shù)的局部變量(最快)，類級屬性(例如self.name——較慢)和全局(例如，導(dǎo)入的函數(shù))如time.time(最慢)之間，查找速度實際上也有所不同。

你可以通過使用看似不必要的分配來提高性能，如下所示：

 
 
 
 
      
  
  
  
  1. # Example #1 
    2.   
  
  
  
  2. class FastClass: 
    3.   
  
  
  
  3.     def do_stuff(self): 
    4.   
  
  
  
  4.         temp = self.value # this speeds up lookup in loop 
    5.   
  
  
  
  5.         for i in range(10000): 
    6.   
  
  
  
  6.             ... # Do something with `temp` here 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8. # Example #2 
    9.   
  
  
  
  9. import random 
    10.   
  
  
  
  10. def fast_function(): 
    11.   
  
  
  
  11.     r = random.random 
    12.   
  
  
  
  12.     for i in range(10000): 
    13.   
  
  
  
  13.         print(r()) # calling `r()` here, is faster than global random.random() 
    14.

使用函數(shù)

這似乎違反直覺，因為調(diào)用函數(shù)會將更多的東西放到堆棧上，并從函數(shù)返回中產(chǎn)生開銷，但這與上一點有關(guān)。如果僅將整個代碼放在一個文件中而不將其放入函數(shù)中，則由于全局變量，它的運行速度會慢得多。因此，你可以通過將整個代碼包裝在main函數(shù)中并調(diào)用一次來加速代碼，如下所示：

 
 
 
 
      
  
  
  
  1. def main(): 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     ... # All your previously global code 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. main() 
    6.

不訪問屬性

可能會使你的程序變慢的另一件事是點運算符(.)，它在獲得對象屬性時被使用。此運算符使用__getattribute__觸發(fā)字典查找，這會在代碼中產(chǎn)生額外的開銷。那么，我們?nèi)绾尾拍苷嬲苊?限制)使用它呢?

 
 
 
 
      
  
  
  
  1. # Slow: 
    2.   
  
  
  
  2. import re 
    3.   
  
  
  
  3. def slow_func(): 
    4.   
  
  
  
  4.     for i in range(10000): 
    5.   
  
  
  
  5.         re.findall(regex, line) # Slow! 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. # Fast: 
    8.   
  
  
  
  8. from re import findall 
    9.   
  
  
  
  9. def fast_func(): 
    10.   
  
  
  
  10.     for i in range(10000): 
    11.   
  
  
  
  11.         findall(regex, line) # Faster! 
    12.

當(dāng)心字符串

使用模數(shù)(%s)或.format()進(jìn)行循環(huán)運行時，字符串操作可能會變得非常慢。我們有什么更好的選擇?根據(jù)雷蒙德·海廷格(Raymond Hettinger)最近的推特，我們唯一應(yīng)該使用的是f字符串，它是最易讀，最簡潔且最快的方法。根據(jù)該推特，這是你可以使用的方法列表——最快到最慢：

 
 
 
 
      
  
  
  
  1. f'{s} {t}'  # Fast! 
    2.   
  
  
  
  2. s + ' ' + t 
    3.   
  
  
  
  3. ' '.join((s, t)) 
    4.   
  
  
  
  4. '%s %s' % (s, t) 
    5.   
  
  
  
  5. '{} {}'.format(s, t) 
    6.   
  
  
  
  6. Template('$s $t').substitute(ss=s, tt=t) # Slow! 
    7.

生成器本質(zhì)上并沒有更快，因為它們被允許進(jìn)行延遲計算，從而節(jié)省了內(nèi)存而不是時間。但是，保存的內(nèi)存可能會導(dǎo)致你的程序?qū)嶋H運行得更快。這是怎么做到的?如果你有一個很大的數(shù)據(jù)集，而沒有使用生成器(迭代器)，那么數(shù)據(jù)可能會溢出CPU L1緩存，這將大大減慢內(nèi)存中值的查找速度。

在性能方面，非常重要的一點是CPU可以將正在處理的所有數(shù)據(jù)盡可能地保存在緩存中。你可以觀看Raymond Hettingers的視頻，他在其中提到了這些問題。

結(jié)論

優(yōu)化的首要規(guī)則是不要優(yōu)化。但是，如果確實需要，那么我希望上面這些技巧可以幫助你。但是，在優(yōu)化代碼時要小心，因為它可能最終使你的代碼難以閱讀，因此難以維護，這可能超過優(yōu)化的好處。


網(wǎng)站欄目：代碼跑得慢甩鍋Python？手把手教你如何給代碼提速30%
URL地址：http://www.5511xx.com/article/cdigchd.html