装饰器python详解_python装饰器详解

Python的装饰器是面试的常客&＃xff0c;因为其写法复杂多变&＃xff0c;经常忘记什么地方应该写哪种参数&＃xff0c;新手学习起来也经常一头雾水&＃xff0c;不怕不怕&＃xff0c;看了这一篇你对装饰器的各种用法就全明白了。废话不多说&＃xff0c;直接进入主题&＃xff01;

不带参数的函数&＃xff0c;不带参数的装饰器

我们先来写一个简单的装饰器&＃xff0c;实现将函数运行前后的情况记录下来。

defdec1(func):print(func)def_wrap():print(&＃39;before run&＃39;)

r&＃61;func()print(&＃39;after run&＃39;)returnrreturn_wrap

&＃64;dec1deff1():print(&＃39;call f1&＃39;)

上面只是定义了两个函数&＃xff0c;运行后发现竟然有输出&＃xff1a;

仔细看看&＃xff0c;原来是第一个print语句的输出。这说明装饰的函数还没有实际运行的时候&＃xff0c;装饰器就运行过了&＃xff0c;因为&＃64;dec1相当于单独的一个语句&＃xff1a;

dec1(f1)

那我们来正式运行一下f1吧&＃xff1a;

f1(1)

输出如下确实达到了预期的效果&＃xff1a;

before run

call f1

after run

不带参数的函数&＃xff0c;带空参数的装饰器

后面我们还想要给装饰器加上参数呢&＃xff0c;先试试用这个方式调用会发生什么情况&＃xff1a;

&＃64;dec1()

输出了错误&＃xff1a;

Traceback (most recent call last) in

8 return_wrap9

---> 10&＃64;dec1()11 deff1():12 print(&＃39;call f1&＃39;)

TypeError: dec1() missing1 required positional argument: &＃39;func&＃39;

它说dec1需要接受func这个参数才行&＃xff0c;那我们改改&＃xff0c;作为f2函数吧&＃xff1a;

defdec2():def_wrap(func):print(func)print(&＃39;before run&＃39;)returnfuncreturn_wrap

&＃64;dec2()deff2():print(&＃39;call f2&＃39;)

f2()

这下可以了&＃xff1a;

before run

call f2

可是这个结构和原来有点不同了&＃xff0c;而且&＃xff0c;after run要写在哪里呢&＃xff1f;很愁人地又改了一版&＃xff0c;把它叫做f2x吧&＃xff0c;对比dec1&＃xff0c;又多了一层函数dec2x_w&＃xff0c;开始有点晕&＃xff1a;

defdec2x_w():defdec2x(func):print(func)def_wrap():print(&＃39;before run&＃39;)

r&＃61;func()print(&＃39;after run&＃39;)returnrreturn_wrapreturndec2x

&＃64;dec2x_w()deff2x():print(&＃39;call f2x&＃39;)

f2x()

运行一下看看&＃xff0c;确实是想要的&＃xff1a;

before run

call f2x

after run

后面我们就不加before/after run了。

带参数的函数&＃xff0c;不带参数的装饰器

函数f2x想要接受参数呢&＃xff1f;我们把它叫做a吧&＃xff0c;比较简单&＃xff0c;不就是_wrap的参数吗&＃xff0c;加上就是了&＃xff0c;而且又回到了只有两层函数就可以实现了&＃xff1a;

defdec3(func):print(func)def_wrap(param):print(param)

r&＃61;func(param)returnrreturn_wrap

&＃64;dec3deff3(a):print(&＃39;call f3&＃39;, a)

f3(1)#很争气地输出了结果&＃xff1a;

1call f31

带参数的函数&＃xff0c;带参数的装饰器

下面我们实现一个装饰器&＃xff0c;传入一个整数&＃xff0c;和函数传入的参数做个加法&＃xff1a;

defdec4_w(d_param):print(d_param)defdec4(func):print(func)def_wrap(param):print(param)

r&＃61; func(param &＃43;d_param)returnrreturn_wrapreturndec4

&＃64;dec4_w(2)deff4(a):print(&＃39;call f4&＃39;, a)

f4(1)

输出1&＃43;2&＃61;3&＃xff1a;2

1call f43从调用的装饰器往里看&＃xff0c;注意这三层函数的形参&＃xff0c;第一层是装饰器的参数&＃xff0c;第二层是函数&＃xff0c;第三层是函数的参数&＃xff0c;很有规律的排列&＃xff0c;先记一下这个规律(要考的)。带两个参数的也是一样的&＃xff0c;接着写就可以了&＃xff1a;defdec5_w(d_param_1, d_param_2):print(d_param_1, d_param_2)defdec5(func):print(func)def_wrap(param):print(param)

r&＃61; func(param &＃43; d_param_1 &＃43;d_param_2)returnrreturn_wrapreturndec5

&＃64;dec5_w(2, 3)deff5(a):print(&＃39;call f5&＃39;, a)

f5(1)

输出1&＃43;2&＃43;3&＃61;6&＃xff1a;2 3

1call f56如果用不定数量的位置参数&＃xff0c;就用*args作为形参吧&＃xff1a;def dec6_w(*args):

d_param_1, d_param_2,&＃61;argsprint(d_param_1, d_param_2)defdec6(func):print(func)def _wrap(*args):

param&＃61;args[0]print(param)

r&＃61; func(param &＃43; d_param_1 &＃43;d_param_2)returnrreturn_wrapreturndec6

&＃64;dec6_w(2, 3)deff6(a):print(&＃39;call f6&＃39;, a)

f6(1)print(f6.__name__)

顺便输出了一下f6的函数名&＃xff1a;2 3

1call f66_wrap

咦&＃xff01;怎么肥四&＃xff01;&＃xff01;&＃xff01;f6怎么是里面那个_wrap的名字呢&＃xff1f;不怕不怕&＃xff0c;functools提供了一个wraps装饰器专治各种不服(在装饰器里面放上另一个装饰器)&＃xff1a;from functools importwrapsdef dec7_w(*args):

d_param_1, d_param_2,&＃61;argsprint(d_param_1, d_param_2)defdec7(func):print(func)

&＃64;wraps(func)def _wrap(*args):

param&＃61;args[0]print(param)

r&＃61; func(param &＃43; d_param_1 &＃43;d_param_2)returnrreturn_wrapreturndec7

&＃64;dec7_w(2, 3)deff7(a):print(&＃39;call f7&＃39;, a)

f7(1)print(f7.__name__)

这下正常输出f7了&＃xff1a;2 3

1call f76f7

装饰器类(带参数的函数&＃xff0c;带参数的装饰器)

用函数做装饰器局限性太多了&＃xff0c;用相同的调用方法&＃xff0c;把函数f7改成类怎么样&＃xff1f;emmm…改造工程有点大&＃xff0c;直接看看成品吧&＃xff1a;

from functools importwrapsclassdec8_c:def __init__(self, *args):

self.d_param_1, self.d_param_2,&＃61;argsprint(self.d_param_1, self.d_param_2)def __call__(self, func):print(func)

&＃64;wraps(func)def_wrap(param):print(param)

r&＃61; func(param &＃43; self.d_param_1 &＃43;self.d_param_2)returnrreturn_wrap

&＃64;dec8_c(2, 3)deff8(a):print(&＃39;call f8&＃39;, a)

f8(1)print(f8.__name__)

看看是不是实现了一样的效果&＃xff1a;

2 3

1call f86f8

虽然使用了__call__&＃xff0c;但这里的__init__不能省略(因为它需要知道参数个数)&＃xff0c;否则会出现这个错误&＃xff1a;

Traceback (most recent call last) in

14 returndec815

---> 16 &＃64;dec8_c(2, 3)17 deff8(a):18 print(&＃39;call f8&＃39;, a)

TypeError: dec8_c() takes no arguments

同时还可以发现&＃xff0c;__call__只需要两层函数了&＃xff0c;去掉了第二层&＃xff0c;直接把_wrap的函数体往上提了一层&＃xff01;

装饰器类(带参数的函数&＃xff0c;不带参数的装饰器)

大概是吃饱了撑着&＃xff0c;又想要实现一开始那个不带参数的装饰器了&＃xff0c;那就继续敲敲打打一番看看&＃xff1a;

classdec9_c:def __init__(self, func):print(func)

self.func&＃61;func

self.__name__ &＃61; func.__name__

def __call__(self, param):print(param)

func&＃61;self.func

r&＃61;func(param)returnr

&＃64;dec9_cdeff9(a):print(&＃39;call f9&＃39;, a)

f9(1)print(f9.__name__)

赶快运行看看&＃xff1a;

1call f91f9

咦&＃xff0c;f9的函数名可以直接打印&＃xff0c;这下都不用&＃64;wraps了呢&＃xff01;呃&＃xff0c;再仔细看看&＃xff0c;这写法好像有些不一样啊&＃xff1a;

dec8_c的init带的是装饰器的参数&＃xff0c;可是dec9_c带的是装饰器函数自己&＃xff01;

所以实际调用的函数名也可以在init中传给它了哦&＃xff01;

而且call函数也简洁了很多&＃xff0c;看来有没有参数真的有很大区别呢&＃xff01;

这里先做个总结&＃xff0c;装饰器使用函数名形式(不带括号)和使用函数调用形式(带括号和参数)在实现上是不同的&＃xff0c;因为前者是函数本身&＃xff0c;而后者是从装饰器函数中返回的函数。这也是f2相比f1缺少了记录after run的原因&＃xff0c;因为dec1直接调用了f2&＃xff0c;而dec2先运行得到函数&＃xff0c;再把函数返回去调用f2。用装饰器类就可以解决这个问题&＃xff0c;因为它是对__call__的调用&＃xff0c;只需要自己定义一下就可以了。

上面的f9要写两个函数&＃xff0c;能不能写得和f1一样简洁&＃xff1f;当然是可以的&＃xff0c;使用__new__大法&＃xff1a;

from functools importwrapsclassdec9x_c:def __new__(self, func):print(func)

&＃64;wraps(func)defdec9x(param):print(param)

r&＃61;func(param)returnrreturndec9x

&＃64;dec9x_cdeff9x(a):print(&＃39;call f9x&＃39;, a)

f9x(1)print(f9x.__name__)

这样就避开了函数调用&＃xff0c;不用打call了(定义__call__函数)&＃xff0c;快看它来了&＃xff1a;

1call f9x1f9x