python装饰器

前置知识
python中的函数可以像普通变量一样当作参数传递给另外一个函数，例如：

def foo():
    print("foo")
    
def bar(func):
    func()
bar(foo)

# 输出
# foo

装饰器本质上是一个Python函数或类，它可以让其它函数或者类在不需要做任何代码修改的前提下增加额外功能，装饰器返回值也是一个函数/类对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。概括地讲，装饰器的作用就是为已经存在的对象添加额外的功能。

一个简单的例子：

def foo():
    print('i am foo')
    time.sleep(3)

现在有一个新的需求，希望可以计算出函数的执行时间，于是在代码中增加几行代码

import time

def foo():
    t1 = time.time()
    print('i am foo')
    time.sleep(3)
    print("耗时%0.3f"%(time.time() - t1))

foo()


'''
输出
i am foo
耗时3.000
'''

如果函数 foo()、foo2() 也有类似的需求，怎么做？再写一个 time.time() 在 foo 函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个新的函数：专门计算函数执行时间的函数

import time

def timer(func):
    t1 = time.time()
    func()
    print("耗时%0.3f"%(time.time() - t1))

def foo():
    print('i am foo')
    time.sleep(3)

timer(foo)


'''
输出
i am foo
耗时3.002
'''

这样做逻辑上是没问题的，功能是实现了，但是调用的时候不再是调用真正的逻辑foo函数，而是换成了timer()函数，这就破环了原有的代码结构，现在不得不都要把原来的那个foo函数作为参数传递给timer()函数，有没有更好的方法呢？使用装饰器。

简单的装饰器

import time

def timer(func):
    def wrapper():
        t1 = time.time()
        func() # 把foo当作参数传递进来时，执行foo()就相当于执行foo()
        print("耗时%0.3f"%(time.time() - t1))
    return wrapper

def foo():
    print('i am foo')
    time.sleep(3)

foo = timer(foo) # 因为装饰器timer(foo)返回的是函数对象wrapper，这条语句相当于 foo = wrapper
foo() #执行foo()就相当于执行wrapper()

timer就是一个装饰器，它是一个普通函数，它把执行真正业务逻辑的函数func包裹在其中，看起来像foo被timer装饰了一样，timer返回的也是一个函数，这个函数的名字叫wrapper。在这个例子中，函数进入和退出时，就被称为一个横切面，这种编程方式被称为面向切面的编程。

@语法糖

@符号是装饰器的语法糖，它放在函数开始定义的地方，这样就可以省略最后一步再次赋值的操作。

import time

def timer(func):
    def wrapper():
        t1 = time.time()
        func() 
        print("耗时%0.3f"%(time.time() - t1))
    return wrapper

@timer
def foo():
    print('i am foo')
    time.sleep(3)

foo = timer(foo)

如上所示，有了 @ ，就可以省去foo = timer(foo)这一句了，直接调用 foo() 即可得到想要的结果。foo() 函数不需要做任何修改，只需在定义的地方加上装饰器，调用的时候还是和以前一样，如果有其他的类似函数，可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，就提高了程序的可重复利用性，并增加了程序的可读性。

装饰器在 Python 使用如此方便都要归因于 Python 的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

*args,**kwargs

如果业务逻辑函数需要传参，可以*args,**kwargs定义在wrapper中

import time

def timer(func):
    def wrapper(*args, **kwds):
        t0 = time.time()
        func(*args, **kwds)
        t1 = time.time()
        print('耗时%0.3f'%(t1 - t0))
    return wrapper

@timer
def do_something(delay):
    print('函数do_something开始')
    time.sleep(delay)
    print('函数do_something结束')

do_something(3)


'''
输出
函数do_something开始
函数do_something结束
耗时3.009
'''

带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器，在上面的装饰器调用中，该装饰器接受唯一的参数就是执行业务的函数foo。装饰器的语法允许在调用时，提供其它参数，可以为装饰器的编写和使用提供更大的灵活性。比如，我们可以在装饰器中指定函数的运行时间段。

import time

def _peroid(peroid):
    def timer(func):
        def wrapper(*args,**kwargs):
            if peroid == 'morning':
                print('早上')
            elif peroid == 'afternoon':
                print('下午')
            elif peroid == 'night' :
                print('晚上')
            return func(*args,**kwargs)
        return wrapper
    return timer

@_peroid('afternoon')
def do_something(delay):
    t0 = time.time()
    print('函数do_something开始')
    time.sleep(delay)
    print('函数do_something结束')
    print('耗时%0.3f'%(time.time() - t0))

do_something(3)


'''
输出
下午
函数do_something开始
函数do_something结束
耗时3.000
'''

上面的_peroid是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当使用@_peroid(‘afternoon’)调用的时候，python能够发现这一次的封装，并把参数传递到装饰器的环境中。

附：什么是闭包

类装饰器
装饰器不仅可以是函数，还可以是类。类装饰器本质上和装饰器原理、作用相同，都是为其它函数增加额外的功能。但是相比起函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器可以直接依靠类内部的__call__方法来实现，当使用@形式将类装饰器附加到函数上时，就会调用类装饰器的__call__方法。而不需要像函数装饰器那样，在装饰器函数中定义嵌套函数，来实现装饰功能。
使用类装饰器为一个函数的执行增加计时功能。

import time

class timer():
    def __init__(self,func):
        self.func = func
        
    def __call__(self,*args):
        t0 = time.time()
        self.func(*args)
        print('耗时%0.3f'%(time.time() - t0))

@timer
def do_something(delay):
    t0 = time.time()
    print('函数do_something开始')
    time.sleep(delay)
    print('函数do_something结束')

do_something(3)


'''
函数do_something开始
函数do_something结束
耗时3.001
'''

另外，使用装饰器极大地服用了代码，但是有一个缺点就是原函数地元信息不见了，比如函数地docstring、__name__、参数列表，先看例子：

import time
from functools import wraps
def deco(func):
    def with_timer(*args,**kwargs):
        return func(*args,**kwargs)
    return with_timer

@deco
def do_something(delay):
    """do something"""
    print('函数do_something开始')
    time.sleep(delay)
    print('函数do_something结束')

do_something(3)
print(do_something.__name__)
print(do_something.__doc__)


'''
函数do_something开始
函数do_something结束
with_timer
None
'''

不难发现，函数do_something被with_timer取代了，当然它的docstring,__name__就是变成了with_timer的信息了。好在我们有functools.wraps，wraps本身也是一个装饰器，它可以保证装饰器不会对被装饰函数造成影响。

import time
from functools import wraps
def deco(func):
    @wraps(func)
    def with_timer(*args,**kwargs):
        return func(*args,**kwargs)
    return with_timer

@deco
def do_something(delay):
    """do something"""
    print('函数do_something开始')
    time.sleep(delay)
    print('函数do_something结束')

do_something(3)
print(do_something.__name__)
print(do_something.__doc__)


'''
函数do_something开始
函数do_something结束
do_something
do something
'''

装饰器调用顺序
一个函数可以同时定义多个装饰器，比如

@a
@b
@c
def f ():
    pass

它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器。

参考文章：

[1] https://www.runoob.com/w3cnote/python-func-decorators.html