函数装饰器和闭包（三）
上个章节：函数装饰器和闭包（二）
这个章节，我们将实现一个简单的装饰器，它在在每次调用函数的时候给被装饰的函数计时，然后把经过的时间、传入的打印，执行的结果打印出来，我们先来看个例子：
# clockdeco.py
import time
def clock(func):
def clocked(*args): # <1>
t0 = time.time()
result = func(*args) # <2>
elapsed = time.time() - t0
name = func.__name__
arg_str = ', '.join(repr(arg) for arg in args)
print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
return result
return clocked # <3>
- 定义内部函数clocked，它接受任意个定位参数
- clocked函数中包含func自由变量
- 返回内部函数，取代被装饰的函数
首先我们先装饰下面的函数：、
@clock
def snooze(seconds):
time.sleep(seconds)
@clock
def factorial(n):
return 1 if n < 2 else n * factorial(n - 1)
运行结果：
>>> snooze(.123)
[0.12308002s] snooze(0.123) -> None
>>> print('6! =', factorial(6))
[0.00000000s] factorial(1) -> 1
[0.00050139s] factorial(2) -> 2
[0.00300074s] factorial(3) -> 6
[0.00551343s] factorial(4) -> 24
[0.00850582s] factorial(5) -> 120
[0.01100802s] factorial(6) -> 720
执行snooze函数在打印的时候还算正常，只打印了一条，但是在执行factorial函数时，打印了6条，这是怎么回事呢？原因是在factorial函数函数中又条用了factorial函数，而这个时候factorial函数已经被替换成clocked函数，我们看一下下面的代码：
>>> factorial.__name__ 'clocked'
clock装饰器有几个缺点，不支持关键字参数，而且遮盖了被装饰函数的__name__和__doc__属性
之前实现的clocked函数还有点粗糙，因为它不支持关键字参数，现在，让我们来实现一个支持关键字参数的clocked函数吧
import functools
import time
def clock(func):
@functools.wraps(func)
def clocked(*args, **kwargs):
t0 = time.time()
result = func(*args, **kwargs)
elapsed = time.time() - t0
name = func.__name__
arg_lst = []
if args:
arg_lst.append(', '.join(repr(arg) for arg in args))
if kwargs:
pairs = ['%s=%r' % (k, w) for k, w in sorted(kwargs.items())]
arg_lst.append(', '.join(pairs))
arg_str = ', '.join(arg_lst)
print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
return result
return clocked
我们给clocked函数添加了一个装饰器，这个装饰器把会把func的一些属性复制到clocked中，例如上面被替换的__name__属性和__doc__属性
运行结果：
>>> snooze(.123)
[0.12308955s] snooze(0.123) -> None
>>> print('6! =', factorial(3))
[0.00000000s] factorial(1) -> 1
[0.00000000s] factorial(2) -> 2
[0.00050092s] factorial(3) -> 6
6! = 6
>>> factorial.__name__
'factorial'
使用functools.lru_cache做备忘
functools.lru_cache是非常实用的装饰器，它实现了备忘的功能。当这个装饰器装饰一个函数时，它会把每一次调用函数时传入的参数和它的执行结果存下来，当以相同的参数再次请求函数，它会直接把之前缓存的结果返回。这里，我们用斐波那契数来测试一下，首先是没有functools.lru_cache装饰器的
@clock # <2>
def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 2) + fibonacci(n - 1)
执行结果：
>>> print(fibonacci(6)) [0.00000000s] fibonacci(0) -> 0 [0.00000000s] fibonacci(1) -> 1 [0.00300026s] fibonacci(2) -> 1 [0.00000000s] fibonacci(1) -> 1 [0.00000000s] fibonacci(0) -> 0 [0.00000000s] fibonacci(1) -> 1 [0.00500345s] fibonacci(2) -> 1 [0.00950742s] fibonacci(3) -> 2 [0.01801252s] fibonacci(4) -> 3 [0.00000000s] fibonacci(1) -> 1 [0.00000000s] fibonacci(0) -> 0 [0.00000000s] fibonacci(1) -> 1 [0.00500369s] fibonacci(2) -> 1 [0.01000690s] fibonacci(3) -> 2 [0.00000000s] fibonacci(0) -> 0 [0.00000000s] fibonacci(1) -> 1 [0.00500178s] fibonacci(2) -> 1 [0.00000000s] fibonacci(1) -> 1 [0.00000000s] fibonacci(0) -> 0 [0.00000000s] fibonacci(1) -> 1 [0.00550294s] fibonacci(2) -> 1 [0.01050520s] fibonacci(3) -> 2 [0.01951361s] fibonacci(4) -> 3 [0.03452396s] fibonacci(5) -> 5 [0.05703855s] fibonacci(6) -> 8 8
现在，我们用functools.lru_cache装饰我们的斐波那契函数
@functools.lru_cache()
@clock
def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 2) + fibonacci(n - 1)
运行结果：
>>> print(fibonacci(6)) [0.00000000s] fibonacci(0) -> 0 [0.00000000s] fibonacci(1) -> 1 [0.00300431s] fibonacci(2) -> 1 [0.00000000s] fibonacci(3) -> 2 [0.00850511s] fibonacci(4) -> 3 [0.00000000s] fibonacci(5) -> 5 [0.01301122s] fibonacci(6) -> 8 8
从两次运行结果来看，使用functools.lru_cache装饰器可以减少大约4倍左右的执行时间。
这里有两点需要注意
- 叠放装饰器时functools.lru_cache必须作为最顶层
- functools.lru_cache(maxsize=128, typed=False)装饰器接收两个参数，maxsize指定了存储多少个调用结果。存储满了之后，旧的结果会被扔掉，腾出空间来。为了得到最佳的性能，maxsize应该为2的幂。typed参数如果为True，把不同参数类型得到的结果分开保存，即把通常认为相等的浮点数和整数参数（如1和1.0）区分开。另外，因为lru_cache使用字段存储结果，而且键根据调用时传入的定位参数和关键字参数创建，所以被lru_cache装饰的函数，它的所有参数都必须是可散列的
