Python : 会打扮的装饰器

我们知道，在 Python 中，我们可以像使用变量一样使用函数：

• 函数可以被赋值给其他变量

• 函数可以被删除

• 可以在函数里面再定义函数

• 函数可以作为参数传递给另外一个函数

• 函数可以作为另一个函数的返回

简而言之，函数就是一个对象。

对一个简单的函数进行装饰

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

现在我们想增强 hello() 函数的功能，希望给返回加上 HTML 标签，比如 <i>hello world</i>，但是有一个要求，不改变原来hello() 函数的定义。这里当然有很多种方法，下面给出一种跟本文相关的方法：

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

现在，我们就可以不改变 hello() 函数的定义，给返回加上 HTML 标签了：

在上面，我们将 hello 函数传给 makeitalic，再将返回赋给 hello，此时调用 hello() 就得到了我们想要的结果。

不过要注意的是，由于我们将 makeitalic 的返回赋给了 hello，此时 hello() 函数仍然存在，但是它的函数名不再是 hello 了，而是 wrapped，正是 makeitalic 返回函数的名称，可以验证一下：

1 2	>>> hello.__name__ 'wrapped'

对于这个小瑕疵，后文将会给出解决方法。

现在，我们梳理一下上面的例子，为了增强原函数 hello 的功能，我们定义了一个函数，它接收原函数作为参数，并返回一个新的函数，完整的代码如下：

1 2 3 4 5 6 7 8 9

def  makeitalic(func):      def  wrapped():          return  "<i>"  +  func()  +  "</i>"      return  wrapped    def  hello():      return  'hello world'    hello  =  makeitalic(hello)

事实上，makeitalic 就是一个装饰器（decorator），它『装饰』了函数 hello，并返回一个函数，将其赋给 hello。

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

1 2 3 4 5 6 7 8

def  makeitalic(func):      def  wrapped():          return  "<i>"  +  func()  +  "</i>"      return  wrapped    @makeitalic def  hello():      return  'hello world'

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

装饰器的使用形式

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

1 2 3

@decorator def  func():      pass

等价于下面的形式：

1 2 3

def  func():      pass func  =  decorator(func)

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

1 2 3 4

@decorator_one @decorator_two def  func():      pass

等价于：

1 2 3 4

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

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

1 2 3

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

等价于：

下面我们再看一些具体的例子，以加深对它的理解。

对带参数的函数进行装饰

前面的例子中，被装饰的函数 hello() 是没有带参数的，我们看看被装饰函数带参数的情况。对前面例子中的 hello() 函数进行改写，使其带参数，如下：

1 2 3 4 5 6 7 8 9 10 11 12 13

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)

由于函数 hello 带参数，因此内嵌包装函数 wrapped 也做了一点改变：

• 内嵌包装函数的参数传给了 func，即被装饰函数，也就是说内嵌包装函数的参数跟被装饰函数的参数对应，这里使用了 (*args, **kwargs)，是为了适应可变参数。

看看使用：

1 2 3 4

>>> hello( 'python' ) '<i>hello python</i>' >>> hello2( 'python' ,  'java' ) '<i>hello python, java</i>'

带参数的装饰器

上面的例子，我们增强了函数 hello 的功能，给它的返回加上了标签 <i>…</i>，现在，我们想改用标签 <b>…</b> 或 <p>…</p>。是不是要像前面一样，再定义一个类似 makeitalic 的装饰器呢？其实，我们可以定义一个函数，将标签作为参数，返回一个装饰器，比如：

1 2 3 4 5 6 7 8

def  wrap_in_tag(tag):      def  decorator(func):          def  wrapped( * args,  * * kwargs):              ret  =  func( * args,  * * kwargs)              return  '<'  +  tag  +  '>'  +  ret  +  '</'  +  tag  +  '>'          return  wrapped         return  decorator

现在，我们可以根据需要生成想要的装饰器了：

1 2 3 4 5 6 7 8

makebold  =  wrap_in_tag( 'b' )   # 根据 'b' 返回 makebold 生成器    @makebold def  hello(name):      return  'hello %s'  %  name       >>> hello( 'world' ) '<b>hello world</b>'

上面的形式也可以写得更加简洁：

1 2 3

@wrap_in_tag ( 'b' ) def  hello(name):      return  'hello %s'  %  name

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

多个装饰器

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def  makebold(func):      def  wrapped():          return  '<b>'  +  func()  +  '</b>'         return  wrapped    def  makeitalic(func):      def  wrapped():          return  '<i>'  +  func()  +  '</i>'         return  wrapped    @makebold @makeitalic def  hello():      return  'hello world'

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

调用函数 hello：

1 2	>>> hello() '<b><i>hello world</i></b>'

基于类的装饰器

前面的装饰器都是一个函数，其实也可以基于类定义装饰器，看下面的例子：

1 2 3 4 5 6 7 8 9 10 11 12 13

class  Bold( object ):      def  __init__( self , func):          self .func  =  func         def  __call__( self ,  * args,  * * kwargs):          return  '<b>'  +  self .func( * args,  * * kwargs)  +  '</b>'    @Bold def  hello(name):      return  'hello %s'  %  name    >>> hello( 'world' ) '<b>hello world</b>'

可以看到，类 Bold 有两个方法：

• __init__()：它接收一个函数作为参数，也就是被装饰的函数

• __call__()：让类对象可调用，就像函数调用一样，在调用被装饰函数时被调用

还可以让类装饰器带参数：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class  Tag( object ):      def  __init__( self , tag):          self .tag  =  tag         def  __call__( self , func):          def  wrapped( * args,  * * kwargs):              return  "<{tag}>{res}</{tag}>" . format (                  res = func( * args,  * * kwargs), tag = self .tag              )          return  wrapped    @Tag ( 'b' ) def  hello(name):      return  'hello %s'  %  name

需要注意的是，如果类装饰器有参数，则 __init__ 接收参数，而 __call__ 接收 func。

装饰器的副作用

前面提到，使用装饰器有一个瑕疵，就是被装饰的函数，它的函数名称已经不是原来的名称了，回到最开始的例子：

1 2 3 4 5 6 7 8

def  makeitalic(func):      def  wrapped():          return  "<i>"  +  func()  +  "</i>"      return  wrapped    @makeitalic def  hello():      return  'hello world'

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

1 2	>>> hello.__name__ 'wrapped'

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

from  functools  import  wraps    def  makeitalic(func):      @wraps(func)        # 加上 wraps 装饰器      def  wrapped():          return  "<i>"  +  func()  +  "</i>"      return  wrapped    @makeitalic def  hello():      return  'hello world'    >>> hello.__name__ 'hello'

小结

• 本质上，装饰器就是一个返回函数的高阶函数。

• 装饰器可以动态地修改一个类或函数的功能，通过在原有的类或者函数上包裹一层修饰类或修饰函数实现。

• 事实上，装饰器就是闭包的一种应用，但它比较特别，接收被装饰函数为参数，并返回一个函数，赋给被装饰函数，闭包则没这种限制。

  
  

来源：https://segmentfault.com/a/1190000007558691