python中装饰器详解

装饰器

我们知道，在python中，我们可以像使用变量一样使用函，这主要依赖于以下几点：

• 函数可以被赋值给其他变量
• 函数可以被删除
• 可以在函数里面再定义函数，函数嵌套。
• 函数可以作为参数传递给另外一个函数
• 函数可以作为另一个函数的返回值

对一个简单的函数进行装饰
为了更好的理解装饰器，我们先从一个简单的例子开始，假设有下面这个函数：

def hello():
    return "hello world!"

现在我们的需求是要增强hello()函数的功能，希望给返回加上HTML标签，比如<i>hello world</i>,但要求我们不得改变hello()函数原来的定义。

def makeitalic(fun):
    def wrapped():
        return "<i>"+fun()+"</i>"
    return wrapped

在上面的代码中，我们定义了一个函数makeitalic，该函数有一个参数fun，它是一个函数；在makeitalic函数里面我们又定义了一个内部函数wrapped，并将该函数作为返回。

现在我们就达到了我们的需求，不改变hello()函数的定义，但实现了我们想要的功能。

def makeitalic(fun):
          def wrapped():
                    return "<i>" + fun() + "</i>"
          return wrapped


def hello():
          return "hello world"

hello = makeitalic(hello)
print(hello()) #<i>hello world</i>

在上面，我们将hello函数传入makeitalic，再将返回赋值给hello，此时，调用hello()函数就可以得到我们想要的结果。
不过需要注意的是，由于我们将makeitalic的返回赋值给hello，此时，hello()函数仍然存在，但它已不在指向原来定义的hello()函数了，而是指向了wrapped。

现在我们来总结一下，我们上面例子。
为了增强原函数hello的功能，我们定义了一个函数，它接收原函数作为参数，并返回一个新的函数，在这个返回的函数中，执行了原函数，并对原函数的功能进行了增强。完整的代码如下所示：

def makeitalic(fun):
          def wrapped():
                    return "<i>" + fun() + "</i>"
          return wrapped


def hello():
          return "hello world"

hello = makeitalic(hello)
print(hello())
print(hello.__name__)

事实上，makeitalic就是一个装饰器（decorator），它封装了原函数hello，并返回了一个新函数，用于增强原函数的功能，并将其赋值给hello。

一般情况下，我们使用装饰器提供的@语法糖（Syntactic Sugar），来简化上面的操作。

def makeitalic(fun):
    def wrapped():
        return "<i>" + fun() + "</i>"
    return wrapped

@makeitalic
def hello():
    return "hello world"

这种做法是我们在平时写程序时，常见的操作，但前面例子中的讲解才是内部的实现原理。

像上面的情况，可以动态的修改函数（或类的）功能的函数就是装饰器。本质上，它是一个高阶函数，以被装饰的函数（比如上面的hello）为参数，并返回一个包装后的函数（比如上面的wrapped）给被修饰函数（hello）。

当我们调用hello()函数时，hello函数的执行流程如下分析：

• 把hello函数作为参数传给@符号后面的装饰器函数。
• 然后开始执行装饰器函数，并返回一个包装了的函数，同时，改变原函数的指向，现在原函数指向了这个包装函数。
• 执行原函数，其实此时执行的是包装了的函数，所以说，装饰器增强了一个现有函数的功能，但不会改变现有函数的定义。

装饰器的使用形式

• 装饰器的一般使用形式如下：

  @decorator
  def fun():
   pass
  

  等价于下面的形式

  def fun():
   pass
  fun = decorator(fun)

• 装饰器可以定义多个，离函数定义最近的装饰器最先被调用，比如：

  @decotator_one
  @decorator_two
  def fun():
   pass

  等价于：

  def fun():
   pass
  fun = decorator_one(decorator_two(fun)) 

• 装饰器还可以带参数，比如：

  @decorator(arg1, arg2)
  def fun():
   pass

  等价于

  def fun():
   pass
  fun = decorator(arg1, arg2)(fun)

  对带参数的函数进行修饰
  前面的例子中，被装饰的函数hello()是没有带参数的。现在我们来看被装饰函数带参数的情况。

def makeitalic(func):
    def wrapped(*args, **kwargs):
        ret = func(*args, **kwargs)
        return '<i>' + ret + '</i>'
    return wrapped

@makeitalic
def hello(name):
    return 'hello %s' % name

@makeitalic
def hello2(name1, name2):
    return 'hello %s, %s' % (name1, name2)

注意看：内嵌包装函数的参数传给了fun，即被修饰的函数，也就是说内嵌包装函数跟被修饰函数的参数对应，这里使用了（*args，**kwargs），是为了适应可变参数。

带参数的装饰器

上面的例子中，我们增强了函数hello的功能，给它的返回加上了<i>标签，但是现在，如果我们想改用标签<b>或者<p>。是不是还需要重新定义一个装饰器呢？其实我们可以在定义一个函数，将标签作为参数，然后返回一个装饰器。

def wrap_in_tag(tag):
    def decorator(fun):
        def wrapped(*args, **kwargs):
            # ret此时是原函数返回的字符串
            ret = fun(*args, **kwargs)
            return '<' + tag + '>' + ret + '</' + tag + '>'
        return wrapped
    return decorator

makebold = wrap_in_tag("b")

@makebold
def hello(name):
    return "hello %s" % name

print(hello("world"))

这就是带参数的装饰器，其实就是在装饰器外面多了一层包装，根据不同的参数返回不同的装饰器。

多个装饰器

现在，我们来看看多个装饰器的例子，为了简单，我们使用不带参数的装饰器。

def makebold(fun):
          def wrapped():
                    return "<b>" + fun() + "</b>"

          return wrapped

def makeitalic(fun):
          def wrapped():
                    return "<i>" + fun() + "</i>"

          return wrapped

@makebold
@makeitalic
def hello():
          return "hello world"

print(hello()) # 输出<b><i>hello world</i></b>

上面定义了两个装饰器，对hello进行装饰，上面的最后几行代码相当于：

def hello():
    return 'hello world'

hello = makebold(makeitalic(hello))

装饰器的副作用

前面提到过，使用装饰器有一个瑕疵，就是被修饰的函数，它的函数名称已经不是原来的名称了，因为最开始的名称指向了包装后的函数。

def makeitalic(func):
    def wrapped():
        return "<i>" + func() + "</i>"
    return wrapped

@makeitalic
def hello():
    return 'hello world'

函数hello被makeitalic装饰后，它的函数名称已经改变了。

>>> hello.__name__
'wrapped'

为了消除这样的副作用，Python中的functions包提供了一个wraps的装饰器。

很好奇wraps内部是怎么实现的？明天搞吧，今天心情不好。想静静。
看了下functools这个模块的源码，但是看的不怎么懂。我猜测这个wraps函数里面包装了一个装饰器，并且最终把这个装饰器返回了。所以说这个wraps只是外层的包装函数，并不是真正的装饰器。

基于类的装饰器

前面我们一直讨论的装饰器都是一个函数，其实也可以定义基于类的装饰器。

class Bold(object):
          def __init__(self, fun):
                    self.fun = fun

          def __call__(self, *args, **kwargs):
                    return "<b>" + self.fun(*args, **kwargs) + "</b>"


@Bold
def hello(name):
          return "hello %s" % name

result = hello("world")
print(result)

在利用类定义装饰器时，我们用到了两个魔法方法。
__init__()：用于初始化一个实例对象，它接收一个函数作为参数，也就是被装饰的函数。
__call()__：让一个实例对象可调用，就像函数调用一样，在调用被装饰函数时被调用。

我们尝试分析上述代码的运行机制：在上面我们用一个类去修饰一个函数，当我们调用hello函数时。它作为参数被传给类Bold，进行了一次实例化的过程，并且新产生的实例也叫hello。这样我们就可以像掉用函数一样来调用这个实例对象。那么，对于这种无参数的类装饰器，其实整个类被称为一个装饰器。

下面我们分析带参数的类装饰器：

class Tag(object):
          def __init__(self, tag):
                    self.tag = tag

          def __call__(self, fun):
                    def wrapped(*args, **kwargs):
                              return "<{tag}>{res}</{tag}>".format(
                                                  res = fun(*args, **kwargs), tag = self.tag
                                        )
                    return wrapped

@Tag("b")
def hello(name):
          return "hello %s" % name

result = hello("world")
print(result)

需要注意的是，如果类装饰器有参数，则__init__接收参数，而__call__接收fun
下面我们来分析上述代码的运行机制：Tag("b")这个表达式返回的是一个可调用对象，虽然是一个实例对象，但可以看做是一个函数，因为实现了__call__()方法。这就回归到了带参数的装饰器情况（用函数定义的）。在这就意味着用一个可调用对象去装饰一个函数。也就是hello = 实例对象(hello)，这是上面这个代码运行的实质。那么问题在于调用对象()是相当于在调用__call__方法吗？如果有hello = 实例对象(hello)，那么此时hello指向了wrapped函数。调用hello()相当于调用wrapped()函数。 所以说在带参数的类装饰其器中，这个实例对象或者说这个__call__方法才是真正的装饰器。

总结

• 本质上，装饰器就是一个返回函数的高阶函数，接收被装饰函数为参数，然后返回一个包装了的函数，并自动用被装饰函数指向返回的这个包装函数。这一切都归功于python提供的语法糖（@符号）。
• 装饰器可以动态的修改一个类或函数的功能，通过在原有的类或者函数上包裹一层修饰类或者修饰函数实现，不会直接去改变原有类或者函数的定义，这符合软件开发中的开闭原则（对拓展是开发的，对修改是封闭的）。
• 事实上，装饰器就是闭包的一种应用，但它比较特别，接收被修饰函数作为参数，并返回一个函数，赋值给被修饰函数，而闭包则没有这种限制。