装饰器
我们知道，在python中，我们可以像使用变量一样使用函，这主要依赖于以下几点：
- 函数可以被赋值给其他变量
- 函数可以被删除
- 可以在函数里面再定义函数，函数嵌套。
- 函数可以作为参数传递给另外一个函数
- 函数可以作为另一个函数的返回值
对一个简单的函数进行装饰
为了更好的理解装饰器，我们先从一个简单的例子开始，假设有下面这个函数：
def hello():
return "hello world!"- 1
- 2
现在我们的需求是要增强hello()函数的功能，希望给返回加上HTML标签，比如<i>hello world</i>,但要求我们不得改变hello()函数原来的定义。
def makeitalic(fun):
def wrapped():
return "<i>"+fun()+"</i>"
return wrapped- 1
- 2
- 3
- 4
在上面的代码中，我们定义了一个函数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>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
在上面，我们将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__)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
事实上，makeitalic就是一个装饰器（decorator），它封装了原函数hello，并返回了一个新函数，用于增强原函数的功能，并将其赋值给hello。
一般情况下，我们使用装饰器提供的@语法糖（Syntactic Sugar），来简化上面的操作。
def makeitalic(fun):
def wrapped():
return "<i>" + fun() + "</i>"
return wrapped
@makeitalic
def hello():
return "hello world"- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
这种做法是我们在平时写程序时，常见的操作，但前面例子中的讲解才是内部的实现原理。
像上面的情况，可以动态的修改函数（或类的）功能的函数就是装饰器。本质上，它是一个高阶函数，以被装饰的函数（比如上面的hello）为参数，并返回一个包装后的函数（比如上面的wrapped）给被修饰函数（hello）。
当我们调用hello()函数时，hello函数的执行流程如下分析：
- 把hello函数作为参数传给@符号后面的装饰器函数。
- 然后开始执行装饰器函数，并返回一个包装了的函数，同时，改变原函数的指向，现在原函数指向了这个包装函数。
- 执行原函数，其实此时执行的是包装了的函数，所以说，装饰器增强了一个现有函数的功能，但不会改变现有函数的定义。
装饰器的使用形式
-
装饰器的一般使用形式如下：
@decorator def fun(): pass- 1
- 2
- 3
- 4
等价于下面的形式
def fun(): pass fun = decorator(fun)- 1
- 2
- 3
-
装饰器可以定义多个，离函数定义最近的装饰器最先被调用，比如：
@decotator_one @decorator_two def fun(): pass- 1
- 2
- 3
- 4
等价于：
def fun(): pass fun = decorator_one(decorator_two(fun))- 1
- 2
- 3
-
装饰器还可以带参数，比如：
@decorator(arg1, arg2) def fun(): pass- 1
- 2
- 3
等价于
def fun(): pass fun = decorator(arg1, arg2)(fun)- 1
- 2
- 3
对带参数的函数进行修饰
前面的例子中，被装饰的函数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)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
注意看：内嵌包装函数的参数传给了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"))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
这就是带参数的装饰器，其实就是在装饰器外面多了一层包装，根据不同的参数返回不同的装饰器。
多个装饰器
现在，我们来看看多个装饰器的例子，为了简单，我们使用不带参数的装饰器。
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>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
上面定义了两个装饰器，对hello进行装饰，上面的最后几行代码相当于：
def hello():
return 'hello world'
hello = makebold(makeitalic(hello))- 1
- 2
- 3
- 4
装饰器的副作用
前面提到过，使用装饰器有一个瑕疵，就是被修饰的函数，它的函数名称已经不是原来的名称了，因为最开始的名称指向了包装后的函数。
def makeitalic(func):
def wrapped():
return "<i>" + func() + "</i>"
return wrapped
@makeitalic
def hello():
return 'hello world'- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
函数hello被makeitalic装饰后，它的函数名称已经改变了。
>>> hello.__name__
'wrapped'- 1
- 2
为了消除这样的副作用，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)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
在利用类定义装饰器时，我们用到了两个魔法方法。
__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)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
需要注意的是，如果类装饰器有参数，则__init__接收参数，而__call__接收fun
下面我们来分析上述代码的运行机制：Tag("b")这个表达式返回的是一个可调用对象，虽然是一个实例对象，但可以看做是一个函数，因为实现了__call__()方法。这就回归到了带参数的装饰器情况（用函数定义的）。在这就意味着用一个可调用对象去装饰一个函数。也就是hello = 实例对象(hello)，这是上面这个代码运行的实质。那么问题在于调用对象()是相当于在调用__call__方法吗？如果有hello = 实例对象(hello)，那么此时hello指向了wrapped函数。调用hello()相当于调用wrapped()函数。 所以说在带参数的类装饰其器中，这个实例对象或者说这个__call__方法才是真正的装饰器。
总结
- 本质上，装饰器就是一个返回函数的高阶函数，接收被装饰函数为参数，然后返回一个包装了的函数，并自动用被装饰函数指向返回的这个包装函数。这一切都归功于python提供的语法糖（@符号）。
- 装饰器可以动态的修改一个类或函数的功能，通过在原有的类或者函数上包裹一层修饰类或者修饰函数实现，不会直接去改变原有类或者函数的定义，这符合软件开发中的开闭原则（对拓展是开发的，对修改是封闭的）。
- 事实上，装饰器就是闭包的一种应用，但它比较特别，接收被修饰函数作为参数，并返回一个函数，赋值给被修饰函数，而闭包则没有这种限制。