Python: 会打扮的装饰器

装饰器

咱们知道，在 Python 中，咱们能够像使用变量同样使用函数：

• 函数能够被赋值给其余变量

• 函数能够被删除

• 能够在函数里面再定义函数

• 函数能够做为参数传递给另一个函数

• 函数能够做为另外一个函数的返回

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

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

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

def hello():
    return 'hello world'

如今咱们想加强 hello() 函数的功能，但愿给返回加上 HTML 标签，好比 <i>hello world</i>，可是有一个要求，不改变原来 hello() 函数的定义。这里固然有不少种方法，下面给出一种跟本文相关的方法：

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

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

如今，咱们就能够不改变 hello() 函数的定义，给返回加上 HTML 标签了：

>>> hello = makeitalic(hello)  # 将 hello 函数传给 makeitalic
>>> hello()
'<i>hello world</i>'

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

不过要注意的是，因为咱们将 makeitalic 的返回赋给了 hello，此时 hello() 函数仍然存在，可是它的函数名再也不是 hello 了，而是 wrapped，正是 makeitalic 返回函数的名称，能够验证一下：

>>> hello.__name__
'wrapped'

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

如今，咱们梳理一下上面的例子，为了加强原函数 hello 的功能，咱们定义了一个函数，它接收原函数做为参数，并返回一个新的函数，完整的代码以下：

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），来简化上面的写法：

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

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

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

装饰器的使用形式

• 装饰器的通常使用形式以下：

@decorator
def func():
    pass

等价于下面的形式：

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

• 装饰器能够定义多个，离函数定义最近的装饰器先被调用，好比：

@decorator_one
@decorator_two
def func():
    pass

等价于：

def func():
    pass

func = decorator_one(decorator_two(func))

• 装饰器还能够带参数，好比：

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

等价于：

def func():
    pass

func = decorator(arg1, arg2)(func)

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

对带参数的函数进行装饰

前面的例子中，被装饰的函数 hello() 是没有带参数的，咱们看看被装饰函数带参数的状况。对前面例子中的 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)

因为函数 hello 带参数，所以内嵌包装函数 wrapped 也作了一点改变：

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

看看使用：

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

带参数的装饰器

上面的例子，咱们加强了函数 hello 的功能，给它的返回加上了标签 <i>...</i>，如今，咱们想改用标签 <b>...</b> 或 <p>...</p>。是否是要像前面同样，再定义一个相似 makeitalic 的装饰器呢？其实，咱们能够定义一个函数，将标签做为参数，返回一个装饰器，好比：

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

    return decorator

如今，咱们能够根据须要生成想要的装饰器了：

makebold = wrap_in_tag('b')  # 根据 'b' 返回 makebold 生成器

@makebold
def hello(name):
    return 'hello %s' % name
    
>>> hello('world')
'<b>hello world</b>'

上面的形式也能够写得更加简洁：

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

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

多个装饰器

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

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 进行装饰，上面的最后几行代码至关于：

def hello():
    return 'hello world'

hello = makebold(makeitalic(hello))

调用函数 hello：

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

基于类的装饰器

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

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__()：让类对象可调用，就像函数调用同样，在调用被装饰函数时被调用

还可让类装饰器带参数：

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。

装饰器的反作用

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

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

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

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

>>> hello.__name__
'wrapped'

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

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'

小结

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

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

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

本文由 funhacks 发表于我的博客，采用 Creative Commons BY-NC-ND 4.0（自由转载-保持署名-非商用-禁止演绎）协议发布。
非商业转载请注明做者及出处。商业转载请联系做者本人。
本文标题为: Python: 会打扮的装饰器
本文连接为: https://funhacks.net/2016/11/...

参考资料

• Python修饰器的函数式编程 - coolshell

• How can I make a chain of function decorators in Python? - Stack Overflow

• Python中的装饰器介绍 – 思诚之道

• python装饰器入门与提升 | 赖明星