python 装饰器

2020-12-16 10:24:49 编辑 0 阅读量:383

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

## 一、装饰器的写法和用法
### 1.1 简单装饰器
```
def use_logging(func):

def wrapper():
        logging.warn("%s is running" % func.__name__)
        return func()   # 把 foo 当做参数传递进来时，执行func()就相当于执行foo()
    return wrapper

def foo():
    print('i am foo')

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

### 1.2 @ 语法糖

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

def wrapper():
        logging.warn("%s is running" % func.__name__)
        return func()
    return wrapper

@use_logging  # 当python解释器遇到@时，相当于执行了一次 func = use_logging(func), 即对func重新赋值, 实际就是func = wraper, 后续调用就相当于调用wrapper了。这里可以很容易将函数添加到某些调用链中。ps：flask的app.route就是在这一步时注册了路由
def foo():
    print("i am foo")
	
# 所以，此时foo.__name__的值为wrapper

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

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

### 1.3 带参数的装饰器
`*args、**kwargs`

可能有人问，如果我的业务逻辑函数 foo 需要参数怎么办？比如：
```
def foo(name):
    print("i am %s" % name)
```
我们可以在定义 wrapper 函数的时候指定参数：
```
def wrapper(name):
        logging.warn("%s is running" % func.__name__)
        return func(name)
    return wrapper
```
这样 foo 函数定义的参数就可以定义在 wrapper 函数中。这时，又有人要问了，如果 foo 函数接收两个参数呢？三个参数呢？更有甚者，我可能传很多个。当装饰器不知道 foo 到底有多少个参数时，我们可以用`*args` 来代替：
```
def wrapper(*args):
        logging.warn("%s is running" % func.__name__)
        return func(*args)
    return wrapper
```
如此一来，甭管 foo 定义了多少个参数，我都可以完整地传递到 func 中去。这样就不影响 foo 的业务逻辑了。这时还有读者会问，如果 foo 函数还定义了一些关键字参数呢？比如：
```
def foo(name, age=None, height=None):
    print("I am %s, age %s, height %s" % (name, age, height))
```
这时，你就可以把 wrapper 函数指定关键字函数：
```
def wrapper(*args, **kwargs):
        # args是一个数组，kwargs一个字典
        logging.warn("%s is running" % func.__name__)
        return func(*args, **kwargs)
    return wrapper
```

装饰器还有更大的灵活性，例如带参数的装饰器，在上面的装饰器调用中，该装饰器接收唯一的参数就是执行业务的函数 foo 。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。比如，我们可以在装饰器中指定日志的等级，因为不同业务函数可能需要的日志级别是不一样的。
```
def use_logging(level):
    def decorator(func):  # 因为在装饰函数时，函数是唯一的参数
        def wrapper(*args, **kwargs):
            if level == "warn":
                logging.warn("%s is running" % func.__name__)
            elif level == "info":
                logging.info("%s is running" % func.__name__)
            return func(*args)
        return wrapper

return decorator

@use_logging(level="warn")  # 相当于执行了一次 func = use_logging(level="warn")(func), use_logging返回的是decorator,所以实际是 func = decorator(func)而decorator(func)返回的是wrapper, 所以最终是 func = wrapper, 后续调用实际调用wrapper,同时里面的level已经被赋值为"warn"，类似于闭包的概念.注意这里的装饰器调用是    @aka('key')  而不是装饰器函数本身
def foo(name='foo'):
    print("i am %s" % name)

foo()  # 前面已经被解释器替换，所以就是执行wrapper()
```
上面的 use_logging 是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器(有点类似与闭包，level就是闭包里面的参数)。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python 能够发现这一层的封装，并把参数传递到装饰器的环境中。

`@use_logging(level="warn")等价于@decorator`

### 1.4 类装饰器

没错，装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的`__call__`方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
```
class Foo(object):
    def __init__(self, func):
        self._func = func

def __call__(self):
        print ('class decorator runing')
        self._func()
        print ('class decorator ending')

@Foo
def bar():
    print ('bar')

bar()
```
### 1.5 functools.wraps

使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的`docstring、__name__、参数列表`，先看例子：
```
# 装饰器
def logged(func):
    def with_logging(*args, **kwargs):
        print func.__name__      # 输出 'with_logging'
        print func.__doc__       # 输出 None
        return func(*args, **kwargs)
    return with_logging

# 函数
@logged
def f(x):
   """does some math"""
   return x + x * x

logged(f)
```
不难发现，函数 f 被`with_logging`取代了，当然它的`docstring，__name__`就是变成了`with_logging`函数的信息了。好在我们有`functools.wraps`，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器里面的 func 函数中，这使得装饰器里面的 func 函数也有和原函数 foo 一样的元信息了。

```
from functools import wraps
def logged(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print func.__name__      # 输出 'f'
        print func.__doc__       # 输出 'does some math'
        return func(*args, **kwargs)
    return with_logging

@logged
def f(x):
   """does some math"""
   return x + x * x
```

## 二、 装饰器进阶
### 2.1 装饰器顺序

一个函数还可以同时定义多个装饰器，比如：
```
@a
@b
@c
def f ():
    pass
# 它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器，它等效于
f = a(b(c(f)))  # 记住，这里是f = ，相当于改变了函数的定义
```
但是，记住先调用装饰器和调用装饰器内的函数是不一样的！！！！

试判断下面的执行结果:
```
def decorator_a(func):
    print 'Get in decorator_a'
    def inner_a(*args, **kwargs):
        print 'Get in inner_a'
        return func(*args, **kwargs)
    return inner_a

def decorator_b(func):
    print 'Get in decorator_b'
    def inner_b(*args, **kwargs):
        print 'Get in inner_b'
        return func(*args, **kwargs)
    return inner_b

@decorator_b
@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

f(1)
```

如果不假思索根据自下而上的原则来判断地话，先执行 decorator_a 再执行 decorator_b , 那么会先输出 Get in decotator_a, Get in inner_a 再输出 Get in decotator_b , Get in inner_b 。然而事实并非如此。

实际上运行的结果如下:
```
Get in decorator_a
Get in decorator_b
Get in inner_b
Get in inner_a
Get in f
```

其实可以这么理解，
```
@decorator_b
@decorator_a
def f(x):
等价于
f = decorator_b(decorator_a(f))
调用f(1)的执行步骤如下：
decorator_b(decorator_a(f))(1)， 按照括号的深浅和从左到右的顺序，先执行decorator(f)
所以输出：
'Get in decorator_a',然后返回inner_a，记住，此时inner_a里面的func为f
decorator_b(inner_a)
print 'Get in decorator_b'， 然后返回inner_b
inner_b(1)  # 此时，inner_b的func是inner_a，然后inner_a的func是f，所以
'Get in inner_b'
然后执行return func(*args, **kwargs)，也就是inner_a(*args, **kwargs)
print 'Get in inner_a'
然后执行return func(*args, **kwargs), 也就是f(1)
print 'Get in f'
```

更进一步的分析：

#### 2.1.1 函数和函数调用的区别
为什么是先执行 inner_b 再执行 inner_a 呢？为了彻底看清上面的问题，得先分清两个概念:函数和函数调用。上面的例子中 f 称之为函数， f(1) 称之为函数调用，后者是对前者传入参数进行求值的结果。在Python中函数也是一个对象，所以 f 是指代一个函数对象，它的值是函数本身， f(1) 是对函数的调用，它的值是调用的结果，这里的定义下 f(1) 的值2。同样地，拿上面的 decorator_a 函数来说，它返回的是个函数对象 inner_a ，这个函数对象是它内部定义的。在 inner_a 里调用了函数 func ，将 func 的调用结果作为值返回。

#### 2.1.2 装饰器函数在被装饰函数定义好后立即执行
其次得理清的一个问题是，当装饰器装饰一个函数时，究竟发生了什么。现在简化我们的例子，假设是下面这样的:
```
def decorator_a(func):
    print 'Get in decorator_a'
    def inner_a(*args, **kwargs):
        print 'Get in inner_a'
        return func(*args, **kwargs)
    return inner_a

@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

# 此时f相当于
f = decorator_a(f)
```
所以，当解释器执行这段代码时， decorator_a 已经调用了，它以函数 f 作为参数， 返回它内部生成的一个函数，所以此后 f 指代的是 decorater_a 里面返回的 inner_a 。所以当以后调用 f 时，实际上相当于调用 inner_a ,传给 f 的参数会传给 inner_a , 在调用 inner_a 时会把接收到的参数传给 inner_a 里的 func 即 f ,最后返回的是 f 调用的值，所以在最外面看起来就像直接再调用 f 一样。

#### 2.1.2 疑问的解释
当理清上面两方面概念时，就可以清楚地看清最原始的例子中发生了什么。
当解释器执行下面这段代码时，实际上按照从下到上的顺序已经依次调用了 decorator_a 和 decorator_b ，这是会输出对应的 Get in decorator_a 和 Get in decorator_b 。 这时候 f 已经相当于 decorator_b 里的 inner_b 。但因为 f 并没有被调用，所以 inner_b 并没有调用，依次类推 inner_b 内部的 inner_a 也没有调用，所以 Get in inner_a 和 Get in inner_b 也不会被输出。
```
@decorator_b
@decorator_a
def f(x):
    print 'Get in f'
    return x * 2
```
然后最后一行当我们对 f 传入参数1进行调用时， inner_b 被调用了，它会先打印 Get in inner_b ，然后在 inner_b 内部调用了 inner_a 所以会再打印 Get in inner_a, 然后再 inner_a 内部调用的原来的 f, 并且将结果作为最终的返回。这时候你该知道为什么输出结果会是那样，以及对装饰器执行顺序实际发生了什么有一定了解了吧。

在实际应用的场景中，当我们采用上面的方式写了两个装饰方法比如先验证有没有登录 @login_required ， 再验证权限够不够时 @permision_allowed 时，我们采用下面的顺序来装饰函数:
```
@login_required
@permision_allowed
def f()
  # Do something
  return
```

这里会先调用permission_allowd的装饰器，但是并不是先调用permission_allow的装饰器内的函数。

## 三、 一些说明
### 3.1 python解释器的行为
python解释器在遇到`@`时，会执行func = decorator(func)，也就是说func的定义就被改变了，如下示例
```
# coding: utf-8
class NotFlask():
    def __init__(self):
        self.routes = {}

def route(self, route_str):
        def decorator(f):
            self.routes[route_str] = f
            return f

return decorator

def serve(self, path):
        view_function = self.routes.get(path)
        if view_function:
            return view_function()
        else:
            raise ValueError(
                'Route "{}"" has not been registered'.format(path))

app = NotFlask()

# import pdb; pdb.set_trace()
@app.route("/")  # 解释器会执行hello = app.route("/")(hello),所以app.routes的值发生变化
def hello():
    return "Hello World!"

# 如果你在@app.route前单步执行一次，可以看到python进入route函数，然后到return decorator，然后进入def decorator然后执行self.routes[route_str] = f，于是路由就被绑定了
print app.routes
```
ps:这个示例就和flask的app.route有点类似
但是需要注意的是，并不是说就一定会进入装饰器的最里面的函数，比如说：
```
def use_logging(level):

def decorator(func):  # 因为在装饰函数时，函数是唯一的参数

def wrapper(*args, **kwargs):
            import pdb; pdb.set_trace()

if level == "warn":
                print("%s is running" % func.__name__)
            elif level == "info":
                print("%s is running" % func.__name__)
            return func(*args)
        return wrapper
    return decorator

@use_logging(level="warn")  # 等价于use_logging(level="warn")(foo) => decorator(foo)  => wrapper, 但是wrapper就不需要再进入里面的代码了，因为还没执行wrapper()，后续使用foo()就相当于wrapper()，这时候才print
def foo(name='foo'):
    print("i am %s" % name)
import pdb; pdb.set_trace()

foo()  
```

### 3.2 使用装饰器管理函数行为
这里举个记录函数执行次数的类装饰器
```
class Decorator(object):
    def __init__(self, max):
        self.max = max
        self.count = 0

# 这里让对象能够像函数一样被调用
    def __call__(self, func):
        self.func = func
        return self.call_func

def call_func(self, *args, **kwargs):
        if self.count < self.max:
            self.func(*args, **kwargs)
            self.count += 1
        else:
            print('{} run more than {} times'.format(self.func.__name__, self.max))

@Decorator(5)
def do_some():
    print('do some')

for i in range(10):
    do_some()

```

---
参考：
- [1][理解 Python 装饰器看这一篇就够了](https://foofish.net/python-decorator.html)
- [2][探究多个装饰器执行顺序](https://segmentfault.com/a/1190000007837364)
- [3][python装饰器理解与实践---挺好的文章](https://www.jianshu.com/p/e93fea508268)

python 装饰器

附件: