让 Python 程序运行速度飞快

注：本文最初发布于martinheinz.dev

Python 的反对者总是说，他们不想用它的原因之一是它太慢。其实，一个程序——无论用什么编程语言——是快是慢，很大程度上取决于编写它的开发人员的技能，以及他们编写优化且快速程序的能力。

所以，让我们证明某些人是错误的，让我们看看如何提高Python程序的性能并使其真正快速运行！

时间和分析

在开始优化任何代码之前，我们首先需要找出代码中哪些部分实际上拖慢了整个程序的速度。有时程序的瓶颈可能很明显，但如果你不知道它在哪里，那么你可以使用以下方法查找：

注意：这是我将用于演示目的的程序，它计算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))

最懒惰的“剖析”

首先，最简单且非常懒惰的解决方案 - Unixtime命令：

~ $ 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，因此每行代码都按内部时间排序（cumtime）。这给了我们很多信息，上面看到的行大约占实际输出的 10%。由此我们可以看出，exp函数是罪魁祸首（真是意外！），现在我们可以更详细地了解时间和性能分析……

计时特定功能

现在我们知道了应该把注意力集中在哪里，我们可能想对运行缓慢的函数进行计时，而不测量其余代码。为此，我们可以使用简单的装饰器：

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

然后可以将此装饰器应用于测试函数，如下所示：

@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 包提供了和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!

小心琴弦

在循环中使用例如modulus ( %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!

生成器可以很快

生成器本身并不更快，因为它们的设计初衷是允许惰性计算，从而节省内存而不是时间。然而，节省的内存实际上可以使你的程序运行得更快。为什么呢？如果你有一个很大的数据集，并且不使用生成器（迭代器），那么数据可能会溢出 CPU 的一级缓存，这会显著减慢在内存中查找值的速度。

说到性能，CPU 能否尽可能地将所有正在处理的数据保存在缓存中至关重要。您可以观看Raymond Hettingers 的演讲，他在演讲中提到了这个问题。

结论

优化的第一条规则就是不要去做。但是，如果你真的必须去做，我希望这些技巧能帮到你。如果你想阅读更多 Python 文章，可以看看我之前关于测试的博客文章（这里），以及一些常用的技巧和窍门（这里（第一部分）或这里（第二部分）。

鏂囩珷鏉ユ簮锛�https://dev.to/martinheinz/making-python-programs-blazing-fast-4knl

让 Python 程序运行速度飞快

让 Python 程序运行速度飞快

时间和分析

最懒惰的“剖析”

最详细的分析

计时特定功能

使其更快

使用内置数据类型

缓存/记忆lru_cache

使用局部变量

使用函数

不要访问属性

小心琴弦

生成器可以很快

结论

缓存/记忆`lru_cache`