python中装饰器详解

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weixin_37972723/article/details/80666877

装饰器

我们知道,在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提供的语法糖(@符号)。
  • 装饰器可以动态的修改一个类或函数的功能,通过在原有的类或者函数上包裹一层修饰类或者修饰函数实现,不会直接去改变原有类或者函数的定义,这符合软件开发中的开闭原则(对拓展是开发的,对修改是封闭的)。
  • 事实上,装饰器就是闭包的一种应用,但它比较特别,接收被修饰函数作为参数,并返回一个函数,赋值给被修饰函数,而闭包则没有这种限制。
展开阅读全文

没有更多推荐了,返回首页