Python学习笔记——用装饰器decorator和Memoization记忆化提高效率，原理讲清楚了

Python真是一个强大而又简洁的语言，接触python时间越长，越能发现它能提供的某些功能真是让人叹为观止，然而这些强大的语言又能用非常简洁的方式引入到代码中去，真是太厉害了。
今天学到的是memoization，并且兼顾学习了装饰器decorator的知识

装饰器

首先讲一点预备知识，python里常用的装饰器，其实就是一个函数，以另一个函数为参数做一些事情，因此也可以看成是一个包裹函数，把另一个函数包裹起来，提供一些原函数不具备的功能。
比方说，有一个函数计算n的平方。函数的功能只是计算，而不作进一步的操作。我们这时就可以写一个包裹函数把它包裹起来，提供打印的功能。注意，这个包裹函数的返回值是一个新的函数。

看代码，先定义一个包裹函数，添加打印功能。注意这个函数在函数体内定义了一个新的函数，并将新函数作为返回值：

In  [1]: def print_func(func): 
    ...:     def printing_func(*args): 
    ...:         res = func(*args) 
    ...:         print('result of', func.__name__, 'is', res)
    ...:     return printing_func 
    ...:

我们要包裹这个简单的平方函数：

In  [2]: def pow(n): 
    ...:     return n * n 
    ...: 

包裹函数写好后，可以手工包裹，可以看到函数的输出已经变成了打印结果。如下：

In [3]: pr_pow = print_func(pow)

In [4]: pr_pow(3)
result of pow is 9

但这体现不出python的简洁性，最能体现的简洁性的是用装饰器：

In  [5]: @print_func 
    ...: def pow2(n): 
    ...:     return n * n 
    ...:                       

In  [6]: pow2(3)       
result of pow2 is 9

直接完成！就这样@装饰器通过一行代码就改变了一个函数的行为，实际上是通过一个“二次函数”返回一个新的函数实现的，但表达方式非常清楚、优美。

上面装饰器的知识是用来帮我我们理解下面的干货的，毕竟用装饰器打印结果并不是一个最佳实践，而下面的例子就充分体现装饰器的作用和python的强大了。

Memoization记忆化

Memoization (注意不是“Memorization”，少一个字母“r”，这个词的词源是memorandum/memo，意思是“备忘录”) 是一种优化程序性能的方法，它用于需要反复执行一个昂贵的函数的场合。所谓昂贵的函数，指的是运行时间很长、或内存占用量很大的函数，这样的函数会导致等待、或占用其他程序的运算时间。
Memoization 的基本原理，是在内存中把这个函数的输出值保存下来供下次使用，这样就不需要重复计算了。

我们可以以一个计算斐波那契数列的递归函数为例看看memoization是如何做的，首先定义memoize()函数：

In [7]: def memoize(func): 
   ...:     cache = {} 
   ...:     def memoized_func(*args): 
   ...:         if args in cache: 
   ...:             return cache[args] 
   ...:         res = func(*args) 
   ...:         cache[args] = res 
   ...:         return res 
   ...:     return memoized_func 
   ...: 

我们在上例中用了一个字典来存放临时信息缓存，只要字典内有结果，就直接返回结果，只有当字典内找不到结果时才计算，并放入字典供下次使用。使用字典来存放临时结果缓存的原因是字典的读取速度非常快。

接下来定义斐波那契函数。就个函数是一个递归函数，运算效率极低，计算的时间复杂度是$O(2^N)$，因此是个昂贵函数。

In [8]: def fib(n): 
   ...:     if n == 0: 
   ...:         return 0 
   ...:     elif n == 1: 
   ...:         return 1 
   ...:     return fib(n-1) + fib(n-2) 
   ...:   

我们可以看下纯函数的运行耗时：

In [9]: %time fib(35)                            
CPU times: user 3.87 s, sys: 5.93 ms, total: 3.87 s
Wall time: 3.88 s   
Out[9]: 9227465

再用memoize()函数手工打包，再运行：

In [10]: memoized_fib = memoize(fib)       
     
In [11]: %time memoized_fib(35)                        
CPU times: user 3.75 s, sys: 11.1 ms, total: 3.76 s
Wall time: 3.77 s
Out[11]: 9227465

时间差不多！这是为什么！因为第一次计算，结果还未保存，现在我们再运行一次：

In [12]: %time memoized_fib(35)                    
CPU times: user 4 µs, sys: 0 ns, total: 4 µs
Wall time: 6.91 µs
Out[12]: 9227465

看！“耗时”大大降低，很明显，从字典里读取数据当然比递归调用要快得多
我们可以用以下方法方便地检查函数的缓存值

In [13]: memoized_fib.__closure__[0].cell_contents      
Out[13]: {(35,): 9227465}

果然！fib(35)的函数值已经在cache中了，我们可以多试几次，新的计算结果同样会被保存：

In [14]: memoized_fib(36)               
Out[14]: 14930352

In [15]: memoized_fib(0)                 
Out[15]: 0

In [16]: memoized_fib(1)                 
Out[16]: 1

In [17]: memoized_fib(2)                           
Out[17]: 1

In [18]: memoized_fib(3)                               
Out[18]: 2

In [19]: memoized_fib.__closure__[0].cell_contents    
Out[19]: {(35,): 9227465, (36,): 14930352, (0,): 0, (1,): 1, (2,): 1, (3,): 2}

有人会想，既然memoize()函数可以保存最终结果，同时斐波那契函数是递归定义的，那如果把递归调用的中间结果也缓存，是不是可以加速函数运行呢？答案是肯定的，但我们怎么做呢？用包裹好的函数调用自身？那样函数写出来就太复杂了！
所幸，pythom提供了装饰器，通过一个小小的装饰器，让函数改头换面

In [20]: @memoize 
    ...: def fib_memo(n): 
    ...:     if n == 0: 
    ...:         return 0 
    ...:     if n == 1: 
    ...:         return 1 
    ...:     return fib_memo(n-1) + fib_memo(n-2) 
    ...:                                   

简单吗？
看看运行结果

In [21]: %time fib_memo(35)             
CPU times: user 48 µs, sys: 1 µs, total: 49 µs
Wall time: 52 µs
Out[21]: 9227465

In [22]: %time fib_memo(36)    
CPU times: user 8 µs, sys: 1 µs, total: 9 µs
Wall time: 12.2 µs
Out[22]: 14930352

是不是很惊喜！由于整个函数被装饰器打包好了，因此它自身递归调用的也是作过缓存改造的函数，因此直接的效果就是极大的效率提升！
当然，惊艳的不仅仅是速度的提升，还有装饰器的极简使用，非常pythonic，非常优美。

运用functools中的lru_cache()函数实现记忆化

当然，Python有那么多的扩展包，我们不需要自己来实现memoization，python的functools包中有lru_cache()函数可以调用：

In [55]: from functools import lru_cache            

In [56]: @lru_cache(maxsize=128) 
    ...: def fib_lru(n): 
    ...:     if n == 0: 
    ...:         return 0 
    ...:     if n == 1: 
    ...:         return 1 
    ...:     return fib_lru(n-1) + fib_lru(n-2) 
    ...:                                   

看看效果：

In [57]: %time fib_lru(35)                       
CPU times: user 31 µs, sys: 11 µs, total: 42 µs
Wall time: 63.2 µs
Out[57]: 9227465

而且，lru_cache还自带CacheInfo函数用来查看缓存信息

In [58]: fib_lru.cache_info()                      
Out[58]: CacheInfo(hits=33, misses=36, maxsize=128, currsize=36)

局限性

一、函数必须严格定义

Memoization最大的局限性是只能应用于严格定义的函数，所谓严格定义的函数的特点是，当给定一个输入时，输出的结果永远是一样的。在计算机领域，我们有大量的函数并不符合这样的额严格定义：比如一个函数返回值跟当天的日期和时间有关联时，在星期五早上调用函数，跟在星期一下午调用同一个函数，尽管输入的参数是一样的，但结果很可能不同。

这种情况记忆化肯定行不通，因为星期五的结果不能用在星期一。

二、函数的参数必须是“不变的” (immutable)

在python中的对象按照可变性分为两类：“可变的 (mutable，例如list、dict等) ”和“不可变的 (immutable, 例如str，int，float，tuple等) ”。只有不可变对象作为参数的函数才能使用Memoization。这是因为将函数的结果存储在字典中时，需要将函数的参数作为字典的key存储，要作为字典的key必须可以计算哈希值，然而可变对象是不可以计算哈希值的，不能作为字典的key存在，因此自然无法进行memoization了。
因此，如果您的函数用到list或dict作为参数的话，就无法使用memoizations了，如果一定要用list，建议用tuples代替。

别的应用场景？

另外，Memoization函数用于函数递归调用提升性能是显而易见的效果，因为递归涉及到大量的同一函数调用，那么，我想跟大家讨论一下，还有什么别的情况是使用memoization的好场景呢？？