|
|
51CTO旗下网站
|
|
移步端
创造专栏

代码跑得慢甩锅Python?手把手教你如何给代码提速30%

Python已经得到了世界程序员的爱护,但是还是遭到一些人口之指责,原因之一就是认为他运行缓慢。Medium上一位小哥就详细讲了讲如何让python提速30%,这个证明代码跑得慢不是python的题材,而是代码本身的题材。

笔者:大数量文摘| 2020-01-14 15:03

大数量文摘出品

来源:Medium

编译:王转转

Python已经得到了世界程序员的爱护,但是还是遭到一些人口之指责,原因之一就是认为他运行缓慢。

其实某个特定程序(不论是使用何种编程语言)的运作速度是快还是慢,在很大程度上取决于编写该程序的支出人员自身素质,以及他们编写优化而敏捷代码的力量。

Medium上一位小哥就详细讲了讲如何让python提速30%,这个证明代码跑得慢不是python的题材,而是代码本身的题材。

时序分析

在初始进行其它优化之前,咱们第一需要找出代码的哪些部分使所有程序变慢。有时程序的题材很显然,但是如果你一时不知晓问题出在哪儿,这就是说这里有部分可能的挑选:

瞩目:这是我将用于演示的顺序,他将展开指数计算(取自Python文档):

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

最简单的“配置文件”

第一,最简单最偷懒的主意——Unix时光命令。

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

如果你只能直到任何程序的运行时间,这样就够了,但通常这还远远不够。

最详细的剖析

此外一个指令是cProfile,但是它提供的消息过于详细了。

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

在此间,咱们采用cProfile模块和time数运行测试脚本,以便按内部时间(cumtime)对进进行排序。这给了俺们有的是信息,你在地方看到的排大约是现实输出的10%。有鉴于此,exp函数是罪魁祸首,如今我们可以更详细地询问时序和总体性分析。

时序特定功能

如今我们掌握了应有主要关注哪里,咱们可能想对运行速度缓慢的函数计时,而不用测量其余的编码。故此,咱们可以运用一个简单的装潢器:

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

下一场可以将此装饰器应用于待测功能,如下所示:

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

这给出我们如下输出:

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

要求考虑的一件事是咱们实际想要测量的年华。时光包提供time.perf_counter和time.process_time两个函数。她们的分别在于perf_counter回到的未知数,包括你的Python先后进程未运行时的年华,故此他可能会受到计算机负载的影响。一边,process_time仅返回用户时间(不包括系统时间),这仅是你的经过时间。

加快吧!

让Python先后运行得更快,这部分会很有意思!我不会展示可以解决你的性质问题的技艺和代码,更多地是关于构想和政策的,该署构想和政策在采取时可能会对性能产生巨大影响,在少数情况下,可以将速度增长30%。

采用内置数据类型

这一点很显然。内置数据类型非常快,尤其是与我们的自定义类型(例如树或链接列表)相比之下。这第一是因为内置程序是用C贯彻的,故此在采取Python拓展编码时我们的进度实在无法与之匹敌。

采用lru_cache缓存/记得

我已经在上一篇博客中展示了此内容,但我以为值得用简单的示范来重复它:

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

地方的函数使用time.sleep宪章大量计算。着重次采用参数1租用时,他将拭目以待2秒钟,下一场才返回结果。再次调用时,结果已经把缓存,故此他将跳过函数的侧重点并立即返回结果。有关更多实际示例,请参见以前的博客文章。

采用局部变量

这与在每个作用域中寻找变量的进度有关,因为他不只是采取局部变量还是全局变量。实际上,即使在函数的局部变量(最快),类级属性(例如self.name——较慢)和全局(例如,导入的函数)如time.time(最慢)之间,追寻速度实际上也有所不同。

你可以通过使用看似不必要的分配来提高性能,如下所示:

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

采用函数

这似乎违反直觉,因为调用函数会将更多的东西放到堆栈上,并从函数返回中产生开销,但这与上一些有关。如果仅将全部代码放在一个文件中而不将他放入函数中,则由于全局变量,他的运作速度会慢得多。故此,你可以通过将全部代码包装在main函数中并调用一次来加速代码,如下所示:

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

不访问属性

可能会使你的顺序变慢的另一件事是点运算符(.),他在拥有对象属性时被运用。此运算符使用__getattribute__触发字典查找,这会在代码中产生额外的开支。这就是说,咱们如何才能真正避免(限制)采用它呢?

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

不容忽视字符串

采用模数(%s)或.format()拓展巡回运行时,字符串操作可能会变得非常慢。咱们有什么更好的取舍?根据雷蒙德·海廷格(Raymond Hettinger)近些年的推特,咱们唯一应该使用的是f字符串,他是最易读,最简单且最快的主意。根据该推特,这是你可以运用的主意列表——最快到最慢:

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

玉器本质上并没有更快,因为它们把允许进行延迟计算,故而节省了内存而不是时刻。但是,保留的内存可能会导致你的顺序实际运作得更快。这是怎么做到的?如果你有一度很大的多寡集,而没有使用石器(迭代器),这就是说数据可能会溢出CPU L1缓存,这将大大减慢内存中值的追寻速度。

在性能方面,异常关键的少数是CPU可以将正在拍卖的一切数据尽可能地保存在缓存中。你可以看到Raymond Hettingers的视频,她在其中提到了那些题材。

总结

多极化的重大规则是不要僵化。但是,如果确实需要,这就是说我期望上面这些艺术可以协助你。但是,在多极化代码时要注意,因为他可能最终使你的编码难以阅读,故此难以保障,这可能超过优化的功利。

相关报道:

https://towardsdatascience.com/making-python-programs-blazingly-fast-c1cd79bd1b32

【本文是51CTO专栏机构大数量文摘的原创译文,微信公众号“大数量文摘( id: BigDataDigest)”】

     大数量文摘二维码

戳这里,瞧该作者更多好文

【编纂推荐】

  1. 2019数量科学家最需要的技艺盘点,Python大火,Pytorch职位要求翻番
  2. 20元造一个运行Linux和Python的片子
  3. 懒人秘籍:教你如何避免编写pandas代码
  4. 必发娱乐手机版的编码都写完了吗?不如做个Python速度条看看还剩多少
  5. 熟练掌握JS console.log,赈灾你的编码
【义务编辑: 赵宁宁 TEL:(010)68476606】

点赞 0
  • Python  代码  编程语言
  • 分享:
    大家都在看
    猜你喜欢

        
    
       

  • &lt;samp id="b58fb540"&gt;&lt;/samp&gt;