Python 装饰器

前言

不少文章讲装饰器，一上来就是嵌套函数的实现方式，容易让人产生误解，以为装饰器必须那样实现，其实不然。
相对来说，装饰器属于 Python 较难理解的一部分了，想要完全理解装饰器，需要有一定的 Python 基础，像闭包等概念。
本文希望通过由简到繁的例子，帮助你消化 Python 的装饰器。
消化本文需要了解的概念：一等对象、闭包、工厂模式、callable

概念

先附上装饰器的官方描述

A function returning another function, usually applied as a function transformation using the @wrapper syntax. Common examples for decorators are classmethod() and staticmethod().

• 装饰器是一个返回另一个函数的函数
• 装饰器是一颗语法糖

简单的装饰器

def wrapper(func):
    return func

wrapper 就是一个装饰器，没有比这更简单的了。现在使用 wrapper

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

这样，就用 wrapper 装饰了 target。
当然，这个 wrapper 什么也没做，让人感受不到它的存在。但我们可以在 return 之前做些事

def wrapper(func):
    print('do something before returning')
    return func

这样，没有修改 target，就给它添加了新的功能。
接下来，我们来理解，为什么说装饰器只是一颗语法糖。
首先，我们假设没有这颗糖，该怎么实现：在不修改 target 的前提下，给它添加新的功能

def wrapper(func):
    print('do something before returning')
    return func

target = wrapper(target)

应该像上面那样，此时，再调用 target()，已经给它添加了新的功能，但调用方式没变。
现在，有了装饰器这颗语法糖，可以像下面这样写，这样就简洁了

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

至此，你应该清楚了装饰器的原理。但上述装饰器的用处有限，只能在被装饰的函数之前做些事，如果我想在被装饰的函数之后也做些事，该怎么实现呢？
此时，上面的一层函数已经力不从心，需要用两层函数，如下：

def wrapper(func):
    def inner(*args, **kwargs):
        print('do something before running')
        r = func(*args, **kwargs)
        print('do something after running')
        return r
    return inner

前面说过，@wrapper 相当于 target = wrapper(target)
这里，target 作为参数传给 wrapper，wrapper 返回一个内嵌函数。
此时，target 已被替换成 inner，只是函数名还是 target，但调用 target 实际上已经变成调用 inner。
这样，利用闭包，就可以在被装饰的函数前后，做一些事情了。

无参数的装饰器

这里，特别强调了装饰器是无参数的，而不是指装饰器函数
前面说过，装饰器函数只能有一个参数，像这里，wrapper 函数有一个参数 func

def wrapper(func):
    def inner(*args, **kwargs):
        print('do something before running')
        r = func(*args, **kwargs)
        print('do something after running')
        return r
    return inner

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

target()

有参数的装饰器

对于有参数的装饰器，上面的两层函数也力不从心了，需要用三层函数。这种属于工厂模式，定义一个返回装饰器的函数，如下：

def factory(yes=False):
    def wrapper(func):
        def inner(*args, **kwargs):
            if yes:
                print('do something')
            print('do something before running')
            r = func(*args, **kwargs)
            print('do something after running')
            return r
        return inner
    return wrapper

@factory(True)
def target():
    print('running target()')

target()

@factory(True) 相当于 target = factory(True)(target)
factory 是一个工厂函数，用来接收参数。它不是装饰器，而是返回一个装饰器。
wrapper 装饰器本身其实没法接收参数，但是通过闭包，wrapper 可以访问 factory 的参数，就好像装饰器有参数一样。
注意：当 factory 使用默认参数的时候，需要使用 @factory()，而不是 @factory。因为 factory 不是装饰器，它只是一个函数，它的返回值才是装饰器。

标准库的装饰器

def wrapper(func):
    '''wrapper doc'''
    def inner(*args, **kwargs):
        '''inner doc'''
        print('do something before running')
        r = func(*args, **kwargs)
        print('do something after running')
        return r
    return inner

@wrapper
def target():
    '''target doc'''
    print('running target()')

print(target.__name__)
print(target.__doc__)

程序输出

inner
inner doc

@wrapper 相当于 target = wrapper(target)
target 已被替换成 inner，属性 __name__ 和 __doc__ 也被替换了
functools.wraps 可以避免替换

import functools

def wrapper(func):
    '''wrapper doc'''
    @functools.wraps(func)
    def inner(*args, **kwargs):
        '''inner doc'''
        print('do something before running')
        r = func(*args, **kwargs)
        print('do something after running')
        return r
    return inner

@wrapper
def target():
    '''target doc'''
    print('running target()')

print(target.__name__)
print(target.__doc__)

程序输出

target
target doc

同时使用多个装饰器

def d1(f):
    print('d1')
    return f

def d2(f):
    print('d2')
    return f

@d1
@d2
def f():
    print('f')

f()

程序输出

d2
d1
f

相当于 f = d1(d2(f))，从近到远地装饰函数

类装饰器

无参数的类装饰器

class wrapper:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print('do something before running')
        r = self.func(*args, **kwargs)
        print('do something after running')
        return r

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

target()

相当于 target = wrapper(target)
wrapper(target) 创建一个实例对象，由于 wrapper 是个 callable 类，所以这个实例对象是可调用的
target 被替换为这个实例对象，此后调用 target 实际上是调用 __call__

有参数的类装饰器

class wrapper:
    def __init__(self, yes=False):
        self.yes = yes

    def __call__(self, func):
        def inner(*args, **kwargs):
            if self.yes:
                print('do something')
            print('do something before running')
            r = func(*args, **kwargs)
            print('do something after running')
            return r
        return inner

@wrapper(yes=True)
def target():
    print('running target()')

target()

相当于 target = wrapper(yes=True)(target)
wrapper(yes=True) 创建一个实例对象，然后调用实例对象，返回了内部函数 inner
target 被替换为 inner，此后调用 target 实际上是调用 inner

总结

如前所述，装饰器可以是一个函数，也可以是一个类。同样的，装饰器可以装饰一个函数，也可以装饰一个类。装饰器函数和装饰器类有一个共同点，就是 callable

• 装饰器是一个返回另一个函数的函数。它只有一个位置参数，这个参数是一个可调用的对象
• 装饰器是一颗语法糖
• 无参数的装饰器用两层嵌套函数
• 有参数的装饰器用三层嵌套函数
• 同时使用多个装饰器，从近到远地装饰函数
• functools.wraps 避免 __name__ 和 __doc__ 被替换
• 类装饰器可以减少嵌套层数