day012 装饰器进阶

一、多个装饰器装饰一个函数

 1 def wrapper1(func):
 2     def inner1():
 3         print('wrapper1 ,before func')
 4         ret = func()
 5         print('wrapper1 ,after func')
 6         return ret
 7     return inner1
 8 
 9 
10 def wrapper2(func):
11     def inner2():
12         print('wrapper2 ,before func')
13         ret = func()
14         print('wrapper2 ,after func')
15         return ret
16     return inner2
17 
18 
19 def wrapper3(func):
20     def inner3():
21         print('wrapper3 ,before func')
22         ret = func()
23         print('wrapper3 ,after func')
24         return ret
25     return inner3
26 
27 
28 @wrapper3
29 @wrapper2
30 @wrapper1
31 def f():
32     print('in f')
33     return '哈哈哈'
34 
35 
36 print(f())

　　输出结果为：

1 wrapper3 ,before func
2 wrapper2 ,before func
3 wrapper1 ,before func
4 in f
5 wrapper1 ,after func
6 wrapper2 ,after func
7 wrapper3 ,after func
8 哈哈哈

二、函数及装饰器总结

 1 # 函数 —— 2天
 2     # 函数的定义和调用
 3     # def 函数名(形参):
 4         #函数体
 5         #return 返回值
 6     #调用 函数名(实参)
 7     # 站在形参的角度上 ： 位置参数，*args，默认参数（陷阱），**kwargs
 8     # 站在实参的角度上 ： 按照位置传，按照关键字传
 9     # 返回值：没有返回值 返回一个值 返回多个值
10     # 接收返回值：没有返回值不接收，返回一个值用一个变量接收，返回多个值用一个变量或者对应数目的变量接收
11 # 闭包函数 —— 在内部函数引用外部函数的变量
12 # 装饰器函数—— 装饰器一定是闭包函数
13     # 装饰器的作用 ： 在不改变原来函数的调用方式的情况下 在这个函数的前后添加新的功能
14     # 完美的符合了一个开发原则 ：开放封闭原则
15         # 对扩展是开发的
16         # 对修改是封闭的
17     # 基础的装饰器
18         # from functools import wraps
19         # def wrapper(func):
20         #     @wraps(func)
21         #     def inner(*args,**kwargs):
22         #          '''在函数被调用之前添加的代码'''
23         #         ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
24         #         '''在函数被调用之后添加的代码'''
25         #         return ret
26         #     return inner
27         # 使用 —— @wrapper
28         # @wrapper
29         # def func():   #inner
30         #     pass
31         #
32         # func.__name__
33         
34     # 带参数的装饰器
35         # @wrapper -- > @warapper(argument)
36         # 三层嵌套函数
37         # def outer(形参):
38         #     def wrapper(func):
39         #         def inner(*args,**kwargs):
40         #             '''在函数被调用之前添加的代码'''
41         #             ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
42         #             '''在函数被调用之后添加的代码'''
43         #             return ret
44         #         return inner
45         #     return wrapper
46         # @outer(True)
47         # def func():
48         #     pass
49         
50         
51         
52     # 多个装饰器装饰一个函数
53         # 俄罗斯套娃
54 
55     #def wrapper1(func):
56         #     @wraps(func)
57         #     def inner(*args,**kwargs):
58         #         print('before 1')
59         #         print('******')
60         #         ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
61         #         '''在函数被调用之后添加的代码'''
62         #         return ret
63     # def wrapper2(func):
64     #     @wraps(func)
65     #     def inner(*args,**kwargs):
66     #         print('before 2')
67     #         ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
68     #         '''在函数被调用之后添加的代码'''
69     #         return ret
70     #   @wrapper1
71     #   @wrapper2
72     #   def func():
73     #       print('111')

 

posted @ 2018-10-11 10:20  wangspy  阅读(59)  评论(0)    收藏  举报