python装饰器 通俗易懂

装饰器

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

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

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

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

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

 

1

2

 

def hello():

return 'hello world'

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

 

1

2

3

4

 

def makeitalic(func):

def wrapped():

return "<i>" + func() + "</i>"

return wrapped

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

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

 

1

2

3

 

>>> hello = makeitalic(hello) # 将 hello 函数传给 makeitalic

>>> hello()

'<i>hello world</i>'

在上面,我们将 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

等价于:

 

1

2

3

4

 

def func():

pass

func = decorator(arg1, arg2)(func)

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

对带参数的函数进行装饰

前面的例子中,被装饰的函数 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 进行装饰,上面的最后几行代码相当于:

 

1

2

3

4

 

def hello():

return 'hello world'

hello = makebold(makeitalic(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'

小结

  • 本质上,装饰器就是一个返回函数的高阶函数。
  • 装饰器可以动态地修改一个类或函数的功能,通过在原有的类或者函数上包裹一层修饰类或修饰函数实现。
  • 事实上,装饰器就是闭包的一种应用,但它比较特别,接收被装饰函数为参数,并返回一个函数,赋给被装饰函数,闭包则没这种限制。

参考资料

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值