Python装饰器解析

发表于 | 分类于

本文力图解析以下几个问题

  1. 什么是装饰器
  2. 装饰器的原理
  3. 装饰器与闭包的关系
  4. 装饰器的执行顺序
什么是装饰器

装饰器模式是一种允许动态或者静态向一个对象添加新的行为而不会影响到其他对象的一种设计模式。Python提供了一种更为自然的方式来装饰一个函数，这种方法通过在被装饰的函数前加一个注释来时实现。
装饰器本质上是一个 Python 函数或类，它可以让其他函数或类在不需要做任何代码修改的前提下增加额外功能，装饰器的返回值也是一个函数/类对象。

装饰器的原理

在Python中一切皆对象，函数作为一个特殊的对象，可以作为参数传递给另外一个函数，装饰器的工作原理就是基于这一特性。装饰器的默认语法是使用@来调用，这实际上仅仅是一种语法糖。

1
2
3
4
5
6
7
def foo():
    print("foo")

def bar(func):
    func()

bar(foo)
简单装饰器
1
2
3
4
5
6
7
8
9
10
11
12
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()
@ 语法糖
1
2
3
@use_logging
def foo():
    print("i am foo")

有了 @ ，我们就可以省去foo = use_logging(foo)这一句了，直接调用 foo() 即可得到想要的结果。

带参数的装饰器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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")
def foo(name='foo'):
    print("i am %s" % name)

foo()
类装饰器

装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的call方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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()
functools.wraps

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 装饰器
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 一样的元信息了。

1
2
3
4
5
6
7
8
9
10
11
12
13
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
装饰器与闭包的关系

在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。

一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。

1
2
3
4
5
6
7
def func(name):
    def inner_func(age):
        print 'name:', name, 'age:', age
    return inner_func

bb = func('the5fire')
bb(26)  # >>> name: the5fire age: 26

这里面调用func的时候就产生了一个闭包——inner_func,并且该闭包持有自由变量——name，因此这也意味着，当函数func的生命周期结束之后，name这个变量依然存在，因为它被闭包引用了，所以不会被回收。

事实上，装饰器就是一种的闭包的应用，只不过其传递的是函数.

装饰器的执行顺序

一个函数还可以同时定义多个装饰器,它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器。

1
2
3
4
5
@a
@b
@c
def f ():
    pass
1
f = a(b(c(f)))

参考

理解 Python 装饰器看这一篇就够了

Python 的闭包和装饰器