老齐教室

让Python程序跑得更快

来源:https://martinheinz.dev/blog/13

作者:Martin

翻译:老齐


讨厌Python的人总是说,他们不想使用Python的原因之一是它的速度太慢。这是一种非常愚蠢的观点。不管使用哪种编程语言,具体的程序是快还是慢,在很大程度上取决于写代码的人的技术能力,而非语言本身。

所以,让我们来证明一些人是错的,看看如何提高Python程序的性能,让它们变得非常快!

计时和剖析

在开始优化任何东西之前,我们首先需要找出代码的哪些部分实际上会减慢整个程序的速度。有时,程序的瓶颈可能很明显,但如果你不知道它在哪里,下面演示一种找到它的方法:

注意:这是我将要用于演示的程序,它计算自然常数e的X次幂(参考了Python文档):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 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命令:

1
2
3
4
5
~ $ time python3 slow_program.py

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

如果你只想给整个程序计时,这样做是可行的。但仅仅计时通常是不够的…

深入分析

使用cProfile,它会给你提供很多信息:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
~ $ python3 -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函数是罪魁祸首(惊奇吧!)。现在我们可以更具体地计时和剖析…

给特定函数计时

既然我们知道该将注意力集中在哪里,就可能希望对执行慢的函数计时,而不对代码的其余部分计时。为此,我们可以使用简单的装饰器:

1
2
3
4
5
6
7
8
9
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

这个装饰器可以应用于将要执行的函数,如下所示:

1
2
3
4
5
6
7
8
@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))

这会带来如下的输出:

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

我们要考虑的一件事是实际(想要)测量的是什么样的时间。标准库中的time模块有time.perf_countertime.process_time,区别是perf_counter返回绝对值,其中包括Python程序进程未运行的时间,因此它可能会受到机器负载的影响。另一方面,process_time只返回用户时间(不包括系统时间),这只是过程的时间。

加速程序的方法

现在到了有趣的部分:让你的Python程序运行得更快。我(基本上)不会向你展示一些能够神奇地解决性能问题的黑客技巧和代码片段。这里更多的是常规的想法和策略,它们在使用中可以对性能产生巨大的影响,在某些情况下可以提高30%的速度。

使用内置数据类型

这一点很明显,内置数据类型非常快,特别是与我们的自定义类型(如树或链表)相比。这主要是因为内置代码是用C实现的,用Python编写代码时,我们在速度上无法真正与之匹配。

使用lru_cache的缓存机制

所谓lru_cache,其含义为: LRU (least recently used) cache,最近最少缓存应用。下面用一个简单的例子来说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
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(最慢)这样的导入函数)之间,查找速度也存在差异。

你可以通过执行看起来不必要的(没有直接用处的)任务来提高性能,比如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#  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函数中并调用一次,就可以加快代码的速度,如下所示:

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

main()

不访问属性

另一个可能会减慢程序运行速度的因素是访问对象属性时使用的点运算符(.)。此运算符实际通过__getattribute__触发字典查找,这会在代码中产生额外的负担。那么,我们如何才能真正避免(限制)使用它呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
#  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,它是最可读、最简洁、最快的方法。因此,根据这条推文,这是你可以使用的方法——下面所列为各种方法从最快到最慢:

1
2
3
4
5
6
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!

生成器可以很快

生成器本身并不能变快,因为它们是为允许惰性计算而设计的,这样可以节省内存而不是时间。但是,节省的内存可能会使程序实际上运行得更快。怎样会这样?好吧,如果你有大型数据集,并且不使用生成器(迭代器),那么数据可能会导致CUP溢出,这将大大减慢在内存中查找值的速度。

在性能方面,CPU可以尽可能地保存它正在处理的所有数据,这一点非常重要,这些数据都在缓存中。

结论

优化的第一条规则是不要这样做。但是,如果你真的需要的话,我希望这几条建议能帮到你。如果你想阅读更多的Python文章,请关注“老齐教室”微信公众号,会不断推出这方面的文章。

关注微信公众号:老齐教室。读深度文章,得精湛技艺,享绚丽人生。

使用支付宝打赏
使用微信打赏

若你觉得我的文章对你有帮助,欢迎点击上方按钮对我打赏

关注微信公众号,免费获得在线机器学习案例