22_装饰器、带参数的装饰器、多个装饰器装饰一个函数

一、装饰器的执行流程

 1 def wrapper(func):
 2     def inner(*args,**kwargs):
 3         ret = func(*args,**kwargs)
 4         return ret
 5     return inner
 6 
 7 @wrapper   #fun = wrapper(fun)
 8 def fun(s):
 9     print('666')
10     return s
11 
12 fun('777')
13 print(fun('777'))
14 
15 '''
16 1.程序至上而下，遇到wrapper() 保存到内存中
17 2.@wrapper   ==   fun = wrapper(fun)  
18 3.执行wrapper(fun)   --> return inner
19 4.return  inner  --->  fun = inner
20 5.fun = inner
21 6.把fun()放到内存中
22 7.执行fun()  ->  inner()
23 8.print('666')
24 9.renturn ret --> return s
25 '''

二、开放封闭原则

关于开放封闭原则，其核心的思想是：

软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的。

因此，开放封闭原则主要体现在两个方面：

对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。

装饰器完美吻合这一原则，在不改变被修饰函数以及业务逻辑前提下，额外的添加功能。

三、带参数的装饰器

 1 import time
 2 
 3 flag = False
 4 def out(flag):
 5     flag = flag
 6     def wrapper(func):
 7         def inner(*args,**kwargs):
 8             if flag:
 9                 start_time = time.time()
10                 time.sleep(1)
11                 ret = func(*args,**kwargs)
12                 end_time = time.time()
13                 return end_time - start_time
14             else:
15                 func(*args,**kwargs)
16         return inner
17     return wrapper
18 
19 @out(True)  #out(True/False)   ->  返回的是wrapper ===>>>  @wrapper
20 def func():
21     print('666')
22 
23 func()

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

 1 def wrapper1(func):
 2     def inner1(*args,**kwargs):
 3         print('wrapper1  before')
 4         func()
 5         print('wrapper1  after')
 6     return inner1
 7 
 8 def wrapper2(func):
 9     def inner2(*args,**kwargs):
10         print('wrapper2  before')
11         func()  #wrapper1 的 inner
12         print('wrapper2  after')
13     return inner2
14 
15 @wrapper2  # func() = wrapper2(func)  -> inner2
16 @wrapper1 # func = wrapper1(func)  wrapper1的inner
17 def func():
18     print('6666')
19 
20 func()

执行流程：

 1 '''
 2 1.执行wrapper1 -> func = wrapper1(func) -> func = inner1(func)
 3 2.执行wrapper2 -> func = wrapper2(func) -> func = inner2(inner1)
 4 
 5 3. -> fun()==>inner2   : print('wrapper2  before') 
 6 4. func()  wrapper2 中的func()实际上是wrapper1的inner     print('wrapper1  before')
 7 6. 执行wrapper1 中的 func()  --->   6666  
 8 7.执行完wrapper1中的func() 继续往下，执行print('wrapper1  after')
 9 7.执行完inner1  之后，返回，程序继续往下执行  print('wrapper2  after')
10 '''

 

来源：https://www.cnblogs.com/weihengblog/p/8418160.html