装饰器是程序开发中经常会用到的一个功能,用好了装饰器,开发效率如虎添翼,同时,这也是Python面试中必问的问题。
例子
先看下下面的例子:
需求
假设某公司已经实现了一系列基础功能,如:数据库操作、redis调用、监控API等功能。业务部门使用基础功能时,只需调用基础平台提供的功能即可。如下:
1 2 3 4 5
| def f1(): print('f1')
def f2(): print('f2')
|
业务部门需要使用基础平台提供的功能,直接调用就好了:
现在问题来了:以前基础平台的开发人员在写代码时候没有关注验证相关的问题,现在需要对基础平台的所有功能进行重构,为平台提供的所有功能添加验证机制,即:执行功能前,先进行验证。
重构方案一
将需要进行的验证操作,写入到每个函数中。
1 2 3 4 5 6 7 8 9 10 11
| def f1(): # 验证1 # 验证2 # 验证3 print('f1')
def f2(): # 验证1 # 验证2 # 验证3 print('f2')
|
如果我们需要的验证操作很多,这种方式显然不合理。
重构方案二
我们把验证操作封装到一个函数中。
1 2 3 4 5
| def check_login(): # 验证1 # 验证2 # 验证3 pass
|
在函数中,对check_login()进行调用即可:
1 2 3 4 5 6 7 8 9 10 11
| def f1():
check_login()
print('f1')
def f2():
check_login()
print('f2')
|
上面的做法可行,但不遵循开放封闭原则,虽然在这个原则是用的面向对象开发,但是也适用于函数式编程,简单来说,它规定已经实现的功能代码不允许被修改,但可以被扩展,即:
1.封闭:已实现的功能代码块
2.开放:对扩展开发
如果将开放封闭原则应用在上述需求中,那么就不允许在函数 f1 、f2的内部进行修改代码。
重构方案三
使用装饰器:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| def w1(func): def inner(): # 验证1 # 验证2 # 验证3 func() return inner
@w1 def f1(): print('f1') @w1 def f2(): print('f2')
|
对于上述代码,仅仅对基础平台的代码进行修改,就可以实现在其他人调用函数f1 f2之前都进行验证操作,并且业务部门无需做任何操作。
原理
单独以f1为例:
1 2 3 4 5 6 7 8 9 10 11
| def w1(func): def inner(): # 验证1 # 验证2 # 验证3 func() return inner
@w1 def f1(): print('f1')
|
python解释器就会从上到下解释代码,步骤如下:
1 2
| 1.def w1(func): ==>将w1函数加载到内存 2.@w1
|
从表面上看解释器仅仅会解释这两句代码,因为函数在没有被调用之前其内部代码不会被执行。
但是@w1这一句代码里却有大文章,@函数名
是python的一种语法糖。
@w1内部会执行以下操作:
执行w1函数
执行w1函数,并将@w1下面的函数作为w1函数的参数,即:@w1等价于 w1(f1)所以,内部就会去执行:
1 2 3 4 5 6 7
| def w1(func): def inner(): #验证 1 #验证 2 #验证 3 f1() # func是参数,此时 func 等于 f1 return inner
|
返回的inner,inner代表的是函数,非执行函数,其实就是将原来的f1函数塞进另外一个函数中。
w1的返回值
将执行完的w1函数返回值赋值给@w1下面的函数的函数名f1即将w1的返回值再重新赋值给f1,即:
1 2 3 4 5 6
| 新f1 = def inner(): #验证 1 #验证 2 #验证 3 原来f1() return inner
|
所以,以后业务部门想要执行f1 函数时,就会执行新f1函数,在新f1函数内部先执行验证,再执行原来的f1函数,然后将原来f1函数的返回值返回给了业务调用者。
再议装饰器
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
| #定义函数:完成包裹数据 def makeBold(fn): def wrapped(): return "<b>" + fn() + "</b>" return wrapped
#定义函数:完成包裹数据 def makeItalic(fn): def wrapped(): return "<i>" + fn() + "</i>" return wrapped
@makeBold def test1(): return "hello world-1"
@makeItalic def test2(): return "hello world-2"
@makeBold @makeItalic def test3(): return "hello world-3"
print(test1())) print(test2())) print(test3()))
|
运行结果:
1 2 3
| <b>hello world-1</b> <i>hello world-2</i> <b><i>hello world-3</i></b>
|
备注:多个装饰器的调用顺序是自下往上,但是运行时的执行顺序是自上往下。
装饰器的应用
1.引入日志
2.函数执行时间统计
3.执行函数前预备处理
4.执行函数后清理功能
5.权限校验等场景
6.缓存
被装饰的函数无参数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| from time import ctime, sleep
def timefun(func): def wrappedfunc(): print("%s called at %s"%(func.__name__, ctime())) func() return wrappedfunc
@timefun def foo(): print("I am foo")
foo() sleep(2) foo()
|
上面代码理解装饰器执行行为可理解成
1 2 3 4 5 6
| foo = timefun(foo) #foo先作为参数赋值给func后,foo接收指向timefun返回的wrappedfunc foo() #调用foo(),即等价调用wrappedfunc() #内部函数wrappedfunc被引用,所以外部函数的func变量(自由变量)并没有释放 #func里保存的是原foo函数对象
|
被装饰的函数有参数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
| from time import ctime, sleep
def timefun(func): def wrappedfunc(a, b): print("%s called at %s"%(func.__name__, ctime())) print(a, b) func(a, b) return wrappedfunc
@timefun def foo(a, b): print(a+b)
foo(3,5) sleep(2) foo(2,4)
|
被装饰的函数有不定长参数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| from time import ctime, sleep
def timefun(func): def wrappedfunc(*args, **kwargs): print("%s called at %s"%(func.__name__, ctime())) func(*args, **kwargs) return wrappedfunc
@timefun def foo(a, b, c): print(a+b+c)
foo(3,5,7) sleep(2) foo(2,4,9)
|
装饰器中的return
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
| from time import ctime, sleep
def timefun(func): def wrappedfunc(): print("%s called at %s"%(func.__name__, ctime())) func() return wrappedfunc
@timefun def foo(): print("I am foo")
@timefun def getInfo(): return '----hahah---'
foo() sleep(2) foo()
print(getInfo())
|
一般情况下为了让装饰器更通用,可以有return
装饰器带参数,在原有装饰器的基础上,设置外部变量
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
| #decorator2.py
from time import ctime, sleep
def timefun_arg(pre="hello"): def timefun(func): def wrappedfunc(): print("%s called at %s %s"%(func.__name__, ctime(), pre)) return func() return wrappedfunc return timefun
@timefun_arg("test") def foo(): print("I am foo")
@timefun_arg("python") def too(): print("I am too")
foo() sleep(2) foo()
too() sleep(2) too()
|
可以理解为
1
| foo()==timefun_arg("test")(foo)()
|
类装饰器
装饰器函数其实是这样一个接口约束,它必须接受一个callable对象作为参数,然后返回一个callable对象。在Python中一般callable对象都是函数,但也有例外。只要某个对象重写了 __call__() 方法,那么这个对象就是callable的。
1 2 3 4 5 6
| class Test(): def __call__(self): print('call me!')
t = Test() t() # call me
|
类装饰器demo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
| class Test(object): def __init__(self, func): print("---初始化---") print("func name is %s"%func.__name__) self.__func = func def __call__(self): print("---装饰器中的功能---") self.__func() #说明: #1. 当用Test来装作装饰器对test函数进行装饰的时候,首先会创建Test的实例对象 # 并且会把test这个函数名当做参数传递到__init__方法中 # 即在__init__方法中的func变量指向了test函数体 # #2. test函数相当于指向了用Test创建出来的实例对象 # #3. 当在使用test()进行调用时,就相当于让这个对象(),因此会调用这个对象的__call__方法 # #4. 为了能够在__call__方法中调用原来test指向的函数体,所以在__init__方法中就需要一个实例属性来保存这个函数体的引用 # 所以才有了self.__func = func这句代码,从而在调用__call__方法中能够调用到test之前的函数体 @Test def test(): print("----test---") test() showpy()#如果把这句话注释,重新运行程序,依然会看到"--初始化--"
|
运行结果如下:
1 2 3 4
| ---初始化--- func name is test ---装饰器中的功能--- ----test---
|
v1.5.2