十步，教你把Python运行速度提升 30%

作者 | Martin Heinz

译者 | 陆离

编辑 | Jane

出品 | AI科技大本营（ID：rgznai100）

  

【导读】一直以来，诟病 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 :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 :57(_path_join)
       48    0.000    0.000    0.000    0.000 :59()
        1    0.000    0.000   11.081   11.081 slow_program.py:1()
...

在这里，我们使用 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可以将所有正在处理的数据尽可能地保存在缓存之中。

 

结论

 

优化的第一条规则是不要优化。但是，如果你确实需要的话，那么我希望以上的这几条建议可以帮到你。但是，在优化代码的时候一定要小心，因为它可能会让你的代码失去了可读性，导致程序难以维护，这可能就超过了优化的好处。

原文链接：

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

（*本文为AI科技大本营翻译文章，转载请微信联系 1092722531）

◆

精彩推荐

◆

1、评选进行中，参与投票即有机会参与抽奖，60+公开课免费学习

2、【Python Day——北京站】现已正式启动，「新春早鸟票」火热开抢！2020年，我们还将在全国多个城市举办巡回活动，敬请期待！活动咨询，可扫描下方二维码加入官方交流群~

CSDN「Python Day」咨询群 ????

来~一起聊聊Python

如果群满100人，无法自动进入，可添加会议小助手微信：婷婷，151 0101 4297（电话同微信）

---

推荐阅读

• 疫情严重，潜伏期也有传染性？科技公司在行动

• 召唤超参调优开源新神器：集XGBoost、TensorFlow、PyTorch、MXNet等十大模块于一身

• 5个可以帮助你提高工作效率的新AI工具

• 亚马逊机器学习服务：深入研究AWS SageMaker

• 从4个月到7天，Netflix开源Python框架Metaflow有何提升性能的魔法？

• 管理7k+工作流，月运行超10000万次，Lyft开源的Flyte平台意味着什么？

• 伯克利新无监督强化学习方法：减少混沌所产生的突现行为

• 机器推理文本+视觉，跨模态预训练新进展
  

• 

  你点的每个“在看”，我都认真当成了AI