函数装饰器和闭包（三）

上个章节：函数装饰器和闭包（二）

这个章节，我们将实现一个简单的装饰器，它在在每次调用函数的时候给被装饰的函数计时，然后把经过的时间、传入的打印，执行的结果打印出来，我们先来看个例子：

# 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>

　　

1. 定义内部函数clocked，它接受任意个定位参数
2. clocked函数中包含func自由变量
3. 返回内部函数，取代被装饰的函数

首先我们先装饰下面的函数：、

@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倍左右的执行时间。

这里有两点需要注意

1. 叠放装饰器时functools.lru_cache必须作为最顶层
2. functools.lru_cache(maxsize=128, typed=False)装饰器接收两个参数，maxsize指定了存储多少个调用结果。存储满了之后，旧的结果会被扔掉，腾出空间来。为了得到最佳的性能，maxsize应该为2的幂。typed参数如果为True，把不同参数类型得到的结果分开保存，即把通常认为相等的浮点数和整数参数（如1和1.0）区分开。另外，因为lru_cache使用字段存储结果，而且键根据调用时传入的定位参数和关键字参数创建，所以被lru_cache装饰的函数，它的所有参数都必须是可散列的