flask中有很多装饰器，今天来整理下Python中装饰器的相关概念。

1. 最简单的装饰器

我们常常可以看到类似这样的代码:

@decorator
def fun():
    # ...
    return res

这里定义函数fun的时候用了一个名为decorator的装饰器，使得最终定义出来的fun成为了一个被装饰过的fun。@其实是一种语法糖，等效于以下代码：

def fun():
    # ...
    return res

fun = decorator(fun)

这应该比较好懂。其实@语法会调用decorator对象，并将原来的fun作为第一个参数传入，再用decorator的返回值取代掉原来的fun，就这么简单。
而装饰器本身可能会这么写：

def decorator(fun):
    def decorated_fun():
        # do sth before fun
        res = fun()
        # do sth after fun
        return res
    return decorated_fun

这个装饰器本身是个函数，唯一的参数是个函数，返回值也是个函数。作用就是在原函数之前和之后加一些代码，变成一个装饰过的函数再返回。

2. 被装饰的函数带有参数

需要被装饰的函数往往是有传入参数的。因此装饰器加工之后的函数也应该能正确处理这些参数。要实现其实也很简单，比如原函数有*args, **kwargs这样的参数，装饰器一般就该这么写：

def decorator(fun):
    def decorated_fun(*args, **kwargs):
        # do sth before fun
        res = fun(*args, **kwargs)
        # do sth after fun
        return res
    return decorated_fun

decorator还是接收原函数fun这一个参数，而是其中定义的decorated_fun则和原函数一样，接收*args, **kwargs，同时将其传递给原函数执行。

3. 装饰器本身带有参数

如果不用@语法糖，装饰器可以想传多少个参数就传多少个参数。比如说这样的装饰器：

def decorator(fun, foo, bar):
    def decorated_fun(*args, **kwargs):
        # do sth before fun with foo
        res = fun(*args, **kwargs)
        # do sth after fun with bar
        return res
    return decorated_fun

由于闭包这一概念，在decorator内部，foo和bar都是可以随意调用的，包括在其中定义的decorated_fun内部。
这个带有foo和bar参数的装饰器，可以这样调用：

def fun():
    # ...
    return res

fun = decorator(fun, foo='foo', bar='bar')

用了语法糖的代价，就是需要按照一定的规则来进行编码。比如@语法就只能传递一个参数给装饰器，也就是原函数。想要用@语法，则可以这么做：

def decorator_with_param(foo, bar)
    def decorator(fun):
        def decorated_fun(*args, **kwargs):
            # do sth before fun with foo
            res = fun(*args, **kwargs)
            # do sth after fun with bar
            return res
        return decorated_fun
    return decorator

这样调用：

@decorator_with_param(foo, bar)
def fun()
    # ...
    return res

这其实等价于：

:::python
decorator = decorator_with_param(foo, bar)
@decorator
def fun():
    # ...
    return res

也等价于：

def fun():
    # ...
    return res

fun = decorator_with_param(foo, bar)(fun)

这挺有意思的。首先decorator_with_param函数接收foo和bar2个参数，返回值是个函数。接着这个函数作为一个装饰器，接收一个fun参数，然后会调用foo和bar来装饰这个fun。还是由于闭包这个概念，所以在decorator_with_param内部可以随意使用foo和bar。我觉得这段文字比较难懂，还是看代码吧。

4. 用class写装饰器

装饰器也可以用class来写，比如这样：

class Decorator(object):
    def __init__(self, foo, bar):
        self.foo = foo
        self.bar = bar

    def __call__(self, fun):
        def decorated_fun(*args, **kwargs):
            # do sth before fun with self.foo
            res = fun(*args, **kwargs)
            # do sth after fun with self.bar
            return res
        return decorated_fun

调用还是一样：

@Decorator(foo, bar)
def fun()
    # ...
    return res

这更有意思了。首先Decorator(foo, bar)会生成一个Decorator的实例，有foo和bar这2个实例变量。然后按照@语法，调用这个实例，并将fun这个原函数作为参数传入。也就是会调用__call__方法，__call__的返回值和前面一样，就是被装饰好的函数了。

另外，装饰器还可以用来做register之类的工作，下次有机会再写。