python函数装饰器

什么是装饰器

装饰器是一个可调用的对象，其参数是另一个函数（被装饰的函数）。装饰器可能会：

1，处理被装饰的函数，然后把它返回

2，将其替换成另一个函数或者对象

若有个名为decorate的装饰器，则：

@decorate
def target():
    print('running target()')

等价于：

def target():
    print('running target()')

target = decorate(target)

上述两种写法结果一样，函数执行完之后得到的target不一定是原来那个target()函数，而是decorate(target)返回的函数。

确认被装饰的函数会替换成其他函数的一个示例：

def deco(func):
    def inner():
        print('running inner()')
    return inner        #函数deco返回inner对象


@deco            #使用deco装饰target
def target():
    print('running target()')


target()       #调用target，运行inner
print(target)   #target时是inner的引用

如下结果，target被替换掉了，它是inner的引用。

running inner()
<function deco.<locals>.inner at 0x00000253D76B8A60>

严格来说，装饰器只是语法糖。装饰器可以像常规的可调用对象那样调用，其参数是另一个函数。

装饰器两大特性：

1，能把被装饰的函数替换成其他函数（如前所示）

2，加载模块时立即执行

python执行装饰器时机（加载模块时）

registry = []         #保存被装饰的函数的引用

def register(func):    #参数是一个函数
    print('running register(%s)' % func)   #显示被装饰的函数
    registry.append(func)
    return func       #返回传入的函数

@register
def f1():
    print('running f1()')

@register
def f2():
    print('running f2()')

def f3():
    print('running f3()')

def main():
    print('running main()')
    print('registry ->', registry)
    f1()
    f2()
    f3()

if __name__ == '__main__':
    main()

如上，f1()和f2()被装饰，f3()没有被装饰。结果如下：

running register(<function f1 at 0x0000018E43507A60>)
running register(<function f2 at 0x0000018E43507AE8>)
running main()
registry -> [<function f1 at 0x0000018E43507A60>, <function f2 at 0x0000018E43507AE8>]
running f1()
running f2()
running f3()

如上可知，register在模块中其他函数之前运行（两次），先于main函数执行。调用register时，传给它的参数是被装饰的函数，例如<function f1 at 0x0000018E43507A60>

加载模块后，registry中有两个被装饰函数的引用：f1和f2。这两个函数，以及f3只有在main函数调用时才执行。

若将示例命名为registration.py然后使用import registration.py导入模块，则出现：

running register(<function f1 at 0x0000018E43507A60>)
running register(<function f2 at 0x0000018E43507AE8>)

以上可知，装饰器在导入模块时立即执行，而被装饰的函数只有在明确调用时才执行。

变量作用域规则

一段代码：

def f1(a):
    print(a)
    print(b)

f1(3)     #报错

代码报错，原因很简单，b没有赋值。现在先给b赋值：

b = 6
def f1(a):
    print(a)
    print(b)

f1(3)

#结果
3
6

b为一个全局变量，正常输出。再加一点料：

b = 6
def f1(a):
    print(a)
    print(b)
    b = 9

f1(3)     #报错

b已经赋值过了，为何上述代码会报错呢。print(a)执行了而print(b)没有执行。事实上，python编译函数定义体时，判断b为局部变量，因为函数中给b赋值了，python从尝试本地环境获取b，调用print(b)时发现b没有绑定值，于是报错。

如果在函数中赋值时想让解释器把b当做全局变量，需要使用global声明：

b = 6
def f1(a):
    global b
    print(a)
    print(b)
    b = 9

f1(3)

#结果
3
6

闭包

学习装饰器，必须了解闭包。

闭包：指的是延伸了作用域的函数，其中包含函数定义体中引用，但是不在定义体中定义的非全局变量。关键：它能访问定义体之外的非全局变量。

定义一个计算平均数的函数，每次新加一个数，得到历史上所有加入的数的平均值。

def make_avg():
    series = []


    def average(new_value):
        series.append(new_value)
        total = sum(series)
        return total/len(series)

    return average


avg = make_avg()
print(avg(10))
print(avg(11))
print(avg(12))

结果：

10.0
10.5
11.0

如上，series是make_avg的局部变量，因为那个函数定义体内初始化了series：serise = [ ]。然而，调用avg(10)时，make_avg函数已经返回了，它本身的作用域也不存在了。

在averager函数中，series是自由变量（在本地作用域中绑定的变量）

 

上图中，averager函数的闭包延伸到那个函数作用域之外，包含series的绑定。

审查编译后的averager：

print(avg.__code__.co_varnames)    #打印局部变量
print(avg.__code__.co_freevars)      #打印自由变量
print(avg.__closure__)                    #__colsure__属性，里面各个元素对应一个自由变量的名称
print(avg.__closure__[0].cell_contents)  #取第一个自由变量的值

('new_value', 'total')
('series',)
(<cell at 0x000001CEB8890B58: list object at 0x000001CEC2214788>,)
[10, 11, 12]

综上，闭包是一种函数，它会保留定义函数时存在的自由变量的绑定，这样调用函数时，虽然定义作用域不可用了，但是仍然能使用那些绑定。

nonlocal声明

每次都要计算所有历史值的总和然后求平均值，显然效率不高，更好的方法是只保留平均值以及个数，然后求平均值。这样写：

def make_avg():
    count = 0
    total = 0


    def average(new_value):
        count += 1
        total += new_value
        return total/count

    return average


avg = make_avg()
print(avg(10))

根据变量域作用规则，count和total不是average函数的局部变量，而直接计算就认为它是局部变量，计算时却又没有绑定值，显然时有问题的。（参见：变量作用域规则）

而上一个average函数也使用了未赋值的series，却没有问题？

事实上，这里利用了列表是可变的对象的这一事实。但是数字，字符串，元组等不可变类型，只能读取，不能更新。若重新绑定，会隐式创建同名局部变量。

python3引入的nonlocal声明解决了这个问题。上述代码改为：

def make_avg():
    count = 0
    total = 0


    def average(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total/count

    return average


avg = make_avg()
print(avg(10))

一个简单装饰器

输出函数运行时间的装饰器：

import time

def clock(func):
    def clocked(*args):
        t0 = time.perf_counter()
        result = func(*args)   #获取原函数结果
        elapsed = time.perf_counter() - 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   #返回内部函数，取代被装饰的函数

使用该装饰器：

@clock
def snooze(seconds):
    time.sleep(seconds)

@clock
def factorial(n):
    return 1 if n < 2 else n*factorial(n-1)

if __name__ == '__main__':
    print('*' * 40, 'calling snooze(1)')
    snooze(1)
    print('*' * 40, 'calling factorial(6)')
    print('6!=', factorial(6))

结果：

**************************************** calling snooze(1)
[1.00001869s] snooze(1) -> None
**************************************** calling factorial(6)
[0.00000073s] factorial(1) -> 1
[0.00001210s] factorial(2) -> 2
[0.00002016s] factorial(3) -> 6
[0.00002896s] factorial(4) -> 24
[0.00003666s] factorial(5) -> 120
[0.00004582s] factorial(6) -> 720
6!= 720

 在这个示例中，factorial保存的是clocked函数的引用，每次调用factorial(n)，执行的都是clocked(n)：

1）记录初始时间

2）调用原来的factorial函数，保存结果

3）计算时间

4）格式化并打印收集的数据

5）返回第2）步保存的结果

这是装饰器的典型行为：把被装饰的函数替换成新函数，二者接受相同参数，而且返回被装饰的函数本身该返回的值，同时做一些额外操作。

标准库中的几个装饰器

1.functools.wraps         

//保留原函数的属性，保证装饰器不会对被装饰函数造成影响

def deco(func):
    @functools.wraps(func)
    def inner():
        print('running inner()')
    return inner        #函数deco返回inner对象


@deco            #使用deco装饰target
def target():
    print('running target()')


print(target) 

不加这个装饰器时：

<function deco.<locals>.inner at 0x00000253D76B8A60>

使用@functools.wraps装饰器之后 ->显示的是原本的函数，保留了原函数__name__,__doc__等属性

<function target at 0x000001B79BD34A60>

2.functools.lru_cache 

//缓存数据，避免传入相同的参数时的重复计算

使用递归算法生成第n个斐波那契数：

@clock                     #使用clock装饰器
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-2) + fibonacci(n-1)

if __name__ == '__main__':
    print(fibonacci(6))

结果：

[0.00000037s] fibonacci(0) -> 0
[0.00000073s] fibonacci(1) -> 1
[0.00004692s] fibonacci(2) -> 1
[0.00000000s] fibonacci(1) -> 1
[0.00000037s] fibonacci(0) -> 0
[0.00000037s] fibonacci(1) -> 1
[0.00001540s] fibonacci(2) -> 1
[0.00003042s] fibonacci(3) -> 2
[0.00009237s] fibonacci(4) -> 3
[0.00000037s] fibonacci(1) -> 1
[0.00000000s] fibonacci(0) -> 0
[0.00000037s] fibonacci(1) -> 1
[0.00001356s] fibonacci(2) -> 1
[0.00002749s] fibonacci(3) -> 2
[0.00000037s] fibonacci(0) -> 0
[0.00000037s] fibonacci(1) -> 1
[0.00001356s] fibonacci(2) -> 1
[0.00000037s] fibonacci(1) -> 1
[0.00000037s] fibonacci(0) -> 0
[0.00000000s] fibonacci(1) -> 1
[0.00001430s] fibonacci(2) -> 1
[0.00002749s] fibonacci(3) -> 2
[0.00005388s] fibonacci(4) -> 3
[0.00009421s] fibonacci(5) -> 5
[0.00020087s] fibonacci(6) -> 8
8

许多重复的计算导致浪费时间，使用lru_cache改善：

@functools.lru_cache()              #lru_cache是参数化装饰器，必须加上()    可看下节  参数化装饰器
@clock
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-2) + fibonacci(n-1)

时间从0.0002s减少到0.00008s

[0.00000037s] fibonacci(0) -> 0
[0.00000037s] fibonacci(1) -> 1
[0.00005242s] fibonacci(2) -> 1
[0.00000073s] fibonacci(3) -> 2
[0.00006635s] fibonacci(4) -> 3
[0.00000073s] fibonacci(5) -> 5
[0.00008138s] fibonacci(6) -> 8
8

lru_cache使用两个可选参数来配置：lru_cache(maxsize=128,typed=False)

maxsize：缓存个数，满了之后会被扔掉(least recently used  扔掉最近最少使用的数据)，理论上应设置为2的幂次

typed：设置为True时，不同类型的参数的运算结果会分开保存，例如1和1.0

3.functools.singledispatch     

//类似于c++重载，使用singledispatch装饰的普通函数会变为泛函数：根据第一个参数类型以不同方式执行相同操作的一组函数（称之为单分派；而根据多个参数选择专门的函数，称为多分派） 

python不支持重载方法或函数，使用if/elif/elif来处理不同类型的数据显得稍显笨拙，不便于扩展。而functools.singledispatch提供了类似于重载的方式，根据传入的不同类型返回结果

from functools import singledispatch

@singledispatch
def show(obj):
    print (obj, type(obj), "obj")

@show.register(str)
def _(text):
    print (text, type(text), "str")

@show.register(int)
def _(n):
    print (n, type(n), "int")
show(1)
show("helloworld")
show([1])

结果：

1 <class 'int'> int
helloworld <class 'str'> str
[1] <class 'list'> obj

叠放装饰器

@d1
@d2
def f():
    xxx

等同于：

def f():
    xxx

f = d1(d2(f))

参数化装饰器

python把被装饰的函数作为第一个参数传给装饰器函数。如果要让装饰器接受其他函数，就需要创建一个装饰器工厂函数，把参数传给它，返回一个装饰器，然后再把它应用到要装饰的函数上。

对于clock装饰器，加一点料，让用户传入一个格式字符串，控制被装饰函数的输出：

import time
from functools import wraps

DEFAULT_FMT = '[{elapsed:0.8f}s] {name}({arg_str}) -> {_result}'

def clock(fmt=DEFAULT_FMT):
    def decorate(func):
        @wraps(func)
        def clocked(*args, **kwargs):
            t0 = time.perf_counter()
            result = func(*args)   #获取原函数结果
            elapsed = time.perf_counter() - t0  #运行时间
            name = func.__name__       #函数名
            arg_list = []
            if args:
                arg_list.append(', '.join(repr(arg) for arg in args))
            if kwargs:
                pairs = ['%s=%r' % (k, w) for k, w in sorted(kwargs.items())]
                arg_list.append(', '.join(pairs))
            arg_str = ', '.join(arg_list)
            _result = repr(result)
            print(fmt.format(**locals()))
            return result
        return clocked
    return decorate

if __name__ == '__main__':

    @clock()
    def snooze(seconds):
        time.sleep(seconds)

    for i in range(3):
        snooze(.123)

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

这个clock装饰器，clock是参数化装饰器工厂函数，decorate是真正的装饰器，clocked包装被装饰的函数；clocked会取代被装饰的函数，返回被装饰的函数原本返回值，decorate返回clocked，clock返回decorete

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

默认输出格式:'[{elapsed:0.8f}s] {name}({arg_str}) -> {_result}' 　　 上述代码输出：

[0.12360011s] snooze(0.123) -> None
[0.12296046s] snooze(0.123) -> None
[0.12395127s] snooze(0.123) -> None

调整格式：

if __name__ == '__main__':

    @clock('{name}({arg_str}) dt = {elapsed:0.8f}s')
    def snooze(seconds):
        time.sleep(seconds)

    for i in range(3):
        snooze(.123)

输出结果

snooze(0.123) dt = 0.12316317s
snooze(0.123) dt = 0.12387173s
snooze(0.123) dt = 0.12382994s

由于类也是可调用对象，而调用类即调用类的__call__方法，因此类装饰器需要实现__call__方法。事实上，装饰器最好通过实现了__call__方法的类来实现而不是通过普通函数来实现。

以上来自《流畅的python》