python装饰器

开闭原则:
在不修改原函数及其调用方式的情况下对原函数功能进行扩展
对代码的修改是封闭
不能修改被装饰的函数的源代码
不能修改被装饰的函数的调用方式

用函数的方式设想一下游戏里用枪的场景

 1 def game():
 2     print('压子弹')
 3     print('枪上膛')
 4     print('发射子弹')
 5 game()
 6 game()
 7 game()
 8 
 9 此时需要给枪增加一个瞄准镜,比如狙击远程目标时候需要加,狙击近程目标不用加
10 此时上边的代码就变成了现在的代码
11 
12 def sight():
13     print('专业狙击瞄准镜')
14     game()
15 sight()
16 sight()
17 sight()
18 此时的设计就不符合开闭原则(因为修改了原代码及调用名称)

装饰器(python里面的动态代理)
本质: 是一个闭包
组成: 函数+实参高阶函数+返回值高阶函数+嵌套函数+语法糖 = 装饰器
存在的意义: 在不破坏原有函数和原有函数调用的基础上,给函数添加新的功能

通用装饰器写法:

 1 def warpper(fn):        # fn是目标函数相当于func
 2     def inner(*args,**kwargs):      # 为目标函数的传参
 3         '''在执行目标函数之前操作'''
 4         ret = fn(*args,**kwargs)    # 调用目标函数,ret是目标函数的返回值
 5         '''在执行目标函数之后操作'''
 6         return ret      # 把目标函数返回值返回,保证函数正常的结束
 7     return inner
 8 
 9 #语法糖
10 @warpper    #相当于func = warpper(func)
11 def func():
12     pass
13 func()      #此时就是执行的inner函数

上边的场景用装饰器修改后

 1 方式一
 2 def game():
 3     print('压子弹')
 4     print('枪上膛')
 5     print('发射子弹')
 6 
 7 def sight(fn):      # fn接收的是一个函数
 8     def inner():
 9         print('安装专业狙击瞄准镜')
10         fn()        #调用传递进来的函数
11         print('跑路')
12     return inner    #返回函数地址
13 
14 game = sight(game)  #传递game函数到sight函数中
15 game()
16 
17 执行步骤
18 第一步定义两个函数game()为普通函数,sight()为装饰器函数
19 第二步定义game = sight(game)等于把game函数当做参数传递给sight(fn)装饰器函数fn形参
20 第三步执行sight(fn),fn在形参位置,相当于下边函数game()传参过来等于fn
21 第四步执行inner函数,然后return把inner函数内存地址当做返回值返回给sight(game)
22 第五步然后执行game(),相当于执行inner函数
23 第六步,执行inner函数,打印'狙击镜',执行fn()形参,由于fn形参等于game函数,所以执行game()函数,打印'压子弹','上膛','发射子弹'
24 第七步打印'跑路'
25 第八步把打印的结果返回给game()
26 
27 方式二
28 def sight(fn):      # fn接收的是一个函数
29     def inner():
30         print('安装专业狙击瞄准镜')
31         fn()        #调用传递进来的函数
32         print('跑路')
33     return inner    #返回函数地址
34 
35 @sight      #相当于game = sight(game)
36 def game():
37     print('压子弹')
38     print('枪上膛')
39     print('发射子弹')
40 game()
41 
42 执行步骤
43 第一步执行sight(fn)函数
44 第二步执行@sight,相当于把把game函数与sight装饰器做关联
45 第三步把game函数当做参数传递给sight(fn)装饰器函数fn形参
46 第四步执行inner函数,然后return把inner函数内存地址当做返回值返回给@sight
47 第五步执行game()相当相当于执行inner()函数,因为@sight相当于game = sight(game)
48 第六步打印'瞄准镜
49 第七步执行fn函数,因为fn等于game函数,所以会执行game()函数,打印'压子弹','上膛','发射子弹'.fn()函数执行完毕
50 第八步打印'跑路'
51 第九步然后把所有打印的结果返回给game()
52 
53 结果
54 安装专业狙击瞄准镜
55 压子弹
56 枪上膛
57 发射子弹
58 跑路

一个简单的装饰器实现

 1 def warpper(fn):
 2     def inner():
 3         print('每次执行被装饰函数之前都要先经过这里')
 4         fn()
 5     return inner
 6 @warpper
 7 def func():
 8     print('执行了func函数')
 9 func()
10 
11 结果
12 每次执行被装饰函数之前都要先经过这里
13 执行了func函数

 带有一个或多个参数的装饰器

 1 def sight(fn):                      #fn等于调用game函数
 2     def inner(*args,**kwargs):      #接受到的是元组("bob",123)
 3         print('开始游戏')
 4         fn(*args,**kwargs)    #接受到的所有参数,打散传递给user,pwd
 5         print('跑路')
 6     return inner
 7 @sight
 8 def game(user,pwd):
 9     print('登陆游戏用户名密码:',user,pwd)
10     print('压子弹')
11     print('枪上膛')
12     print('发射子弹')
13 game('bob','123')
14 结果
15 开始游戏
16 登陆游戏用户名密码: bob 123
17 压子弹
18 枪上膛
19 发射子弹
20 跑路

动态传递一个或多个参数给装饰器

 1 def sight(fn):                      #调用game函数
 2     def inner(*args,**kwargs):      #接受到的是元组("bob",123)
 3         print('开始游戏')
 4         fn(*args,**kwargs)    #接受到的所有参数,打散传递给正常的参数
 5         print('跑路')
 6     return inner
 7 @sight
 8 def game(user,pwd):
 9     print('登陆游戏用户名密码:',user,pwd)
10     print('压子弹')
11     print('枪上膛')
12     print('发射子弹')
13     return '游戏展示完毕'
14 ret = game('bob','123')     #传递了两个参数给装饰器sight
15 print(ret)
16 
17 @sight
18 def car(qq):
19     print('登陆QQ号%s'%qq)
20     print('开始战车游戏')
21 ret2 = car(110110)          #传递了一个参数给装饰器sight
22 print(ret2)
23 结果
24 开始游戏
25 登陆游戏用户名密码: bob 123
26 压子弹
27 枪上膛
28 发射子弹
29 跑路
30 None
31 开始游戏
32 登陆QQ号110110
33 开始战车游戏
34 跑路
35 None
36 你会发现这两个函数执行的返回值都为None,但是我game定义返回值了return '游戏展示完毕',却没给返回

装饰器的返回值

 1 为什么我定义了返回值,但是返回值还是None呢,是因为我即使在game函数中定义了return '游戏展示完毕'
 2 但是装饰器里只有一个return inner定义返回值,但是这个返回值是返回的inner函数的内存地址的,并不是inner
 3 函数内部的return所以默认为None,所以应该定义一个inner函数内部的return返回值,而且也没有接收返回值的变量,
 4 所以要要设置ret = fn(*args,**kwargs)和return ret
 5 
 6 def sight(fn):                      #调用game函数
 7     def inner(*args,**kwargs):      #接受到的是元组("bob",123)
 8         print('开始游戏')
 9         ret = fn(*args,**kwargs)    #接受到的所有参数,打散传递给正常的参数
10         print('跑路')
11         return ret
12     return inner
13 @sight
14 def game(user,pwd):
15     print('登陆游戏用户名密码:',user,pwd)
16     print('压子弹')
17     print('枪上膛')
18     print('发射子弹')
19     return '游戏展示完毕'
20 ret = game('bob','123')     #传递了两个参数给装饰器sight
21 print(ret)
22 结果
23 开始游戏
24 登陆游戏用户名密码: bob 123
25 压子弹
26 枪上膛
27 发射子弹
28 跑路
29 游戏展示完毕
30 
31 
32 事例2
33 def wrapper_out(flag):      #装饰器本身的参数
34     def wrapper(fn):        #目标函数
35         def inner(*args,**kwargs):  #目标函数需要接受的参数
36             if flag == True:
37                 print('找第三方问问价格行情')
38                 ret = fn(*args,**kwargs)
39                 print('买到装备')
40                 return ret
41             else:
42                 ret = fn(*args,**kwargs)
43                 return ret
44         return inner
45     return wrapper
46 #语法糖,@装饰器
47 @wrapper_out(True)
48 def func(a,b):  #被wrapper装饰
49     print(a,b)
50     print('开黑')
51     return 'func返回值'
52 abc = func('我是参数1','我是参数2')
53 print(abc)
54 结果
55 找第三方问问价格行情
56 我是参数1 我是参数2
57 开黑
58 买到装备
59 func返回值

多个装饰器同用一个函数

 1 def wrapper1(fn):
 2     def inner(*args,**kwargs):
 3         print('wrapper1-1')
 4         ret = fn(*args,**kwargs)
 5         print('wrapper1-2')
 6         return ret
 7     return inner
 8 
 9 def wrapper2(fn):
10     def inner(*args,**kwargs):
11         print('wrapper2-1')
12         ret = fn(*args,**kwargs)
13         print('wrapper2-2')
14         return ret
15     return inner
16 
17 def wrapper3(fn):
18     def inner(*args,**kwargs):
19         print('wrapper3-1')
20         ret = fn(*args,**kwargs)
21         print('wrapper3-2')
22         return ret
23     return inner
24 @wrapper1
25 @wrapper2
26 @wrapper3
27 def func():
28     print('我是测试小白')
29 func()
30 结果
31 wrapper1-1
32 wrapper2-1
33 wrapper3-1
34 我是测试小白
35 wrapper3-2
36 wrapper2-2
37 wrapper1-2