共计 4898 个字符，预计需要花费 13 分钟才能阅读完成。
Python 曾经失去了寰球程序员的青睐，然而还是受到一些人的诟病，起因之一就是认为它运行迟缓。
其实某个特定程序（无论应用何种编程语言）的运行速度是快还是慢，在很大水平上取决于编写该程序的开发人员本身素质，以及他们编写优化而高效代码的能力。
Medium 上一位小哥就具体讲了讲如何让 Python 提速 30%，以此证实代码跑得慢不是 Python 的问题，而是代码自身的问题。
01 时序剖析
在开始进行任何优化之前，咱们首先须要找出代码的哪些局部使整个程序变慢。有时程序的问题很显著，然而如果你一时不晓得问题出在哪里，那么这里有一些可能的选项：
留神：这是我将用于演示的程序，它将进行指数计算
# 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 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.process_time 两个函数。他们的区别在于 perf_counter 返回的绝对值，包含你的 Python 程序过程未运行时的工夫，因而它可能会受到计算机负载的影响。另一方面，process_time 仅返回用户工夫（不包含零碎工夫），这仅是你的过程工夫。
02 减速吧！
让 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!当心字符串
应用模数（%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 L1 缓存，这将大大减慢内存中值的查找速度。
在性能方面，十分重要的一点是 CPU 能够将正在解决的所有数据尽可能地保留在缓存中。你能够观看 Raymond Hettingers 的视频，他在其中提到了这些问题。
03 论断
优化的首要规定是不要优化。然而，如果的确须要，那么我心愿下面这些技巧能够帮忙你。然而，在优化代码时要小心，因为它可能最终使你的代码难以浏览，因而难以保护，这可能超过优化的益处。
最近整顿了几百 G 的 Python 学习材料，蕴含新手入门电子书、教程、源码等等，收费分享给大家！想要的返回“Python 编程学习圈 ”，发送“J”即可收费取得
