计时专用函数
现在我们知道了需要关注哪里，那么我们可能只想要给运行缓慢的函数计时而不去管代码的其他部分。我们可以使用一个简单的装饰器来做到这点：
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 库提供了 time.perf_counter 和 time.process_time 两种时间。其区别在于，perf_counter 返回绝对值，其中包括了 Python 程序并不在运行的时间，因此它可能受到机器负载的影响。而 process_time 只返回用户时间（除去了系统时间），也就是只有进程运行时间。
让程序更快
现在到了真正有趣的部分了，让 Python 程序跑得更快！是关于通用的想法和策略。使用这些策略，可以对程序性能产生巨大的影响，有时甚至可以带来高达 30% 的提速。
使用内置的数据类型
这一点非常明显。内置的数据类型非常快，尤其相比于树或链表等自定义类型而言。这主要是因为内置数据类型使用 C 语言实现，使用 Python 实现的代码在运行速度上和它们没法比。
1、使用 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 秒钟后返回了结果。当再次调用时，结果已经被缓存起来，所以它跳过了函数体，直接返回结果。
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()
3、使用函数
这也许有些反直觉，因为调用函数会让更多的东西入栈，进而在函数返回时为程序带来负担，但这其实和之前的策略相关。如果你只是把所有代码扔进一个文件而没有把它们放进函数，那么它会因为众多的全局变量而变慢。因此，你可以通过将所有代码封装在 main 函数中并调用它来实现加速，如下所示：
def main():
... # All your previously global code
main()
4、不要访问属性
另一个可能让程序变慢的东西是用来访问对象属性的点运算符（.）。这个运算符会引起程序使用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!
5、当心字符串
当在循环中使用取模运算符（%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!
6、生成器
生成器本质上并不会更快，因为它们的目的是惰性计算，以节省内存而非节省时间。然而，节省的内存会让程序运行更快。为什么呢？如果你有一个大型数据集，并且你没有使用生成器（迭代器），那么数据可能造成 CPU 的缓存溢出，进而导致访存速度显著变慢。
