装饰器的编写与使用

233倔强不秃

# 创建几个函数

1. def add(a , b):
   
2.     '''
   
3.         求任意两个数的和
   
4.     '''
   
5.     r = a + b
   
6.     return r
   
7. 
   
8. 
   
9. def mul(a , b):
   
10.     '''
    
11.         求任意两个数的积
    
12.     '''
    
13.     r = a * b
    
14.     return r   
    

复制代码

# 希望函数可以在计算前，打印开始计算，计算结束后打印计算完毕
#  我们可以直接通过修改函数中的代码来完成这个需求，但是会产生以下一些问题
#   ① 如果要修改的函数过多，修改起来会比较麻烦
#   ② 并且不方便后期的维护
#   ③ 并且这样做会违反开闭原则（OCP）
#           程序的设计，要求开放对程序的扩展，要关闭对程序的修改


# r = add(123,456)
# print(r)

# 我们希望在不修改原函数的情况下，来对函数进行扩展

1. def fn():
   
2.     print('我是fn函数....')
   

复制代码

# 只需要根据现有的函数，来创建一个新的函数

1. def fn2():
   
2.     print('函数开始执行~~~')
   
3.     fn()
   
4.     print('函数执行结束~~~')
   

复制代码

# fn2()   

1. def new_add(a,b):
   
2.     print('计算开始~~~')
   
3.     r = add(a,b)
   
4.     print('计算结束~~~')
   
5.     return r
   
6. 
   
7. # r = new_add(111,222)   
   
8. # print(r)
   

复制代码

# 上边的方式，已经可以在不修改源代码的情况下对函数进行扩展了
#   但是，这种方式要求我们每扩展一个函数就要手动创建一个新的函数，实在是太麻烦了
#   为了解决这个问题，我们创建一个函数，让这个函数可以自动的帮助我们生产函数

1. def begin_end(old):
   
2.     '''
   
3.         用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束
   
4. 
   
5.         参数：
   
6.             old 要扩展的函数对象
   
7.     '''
   
8.     # 创建一个新函数
   
9.     def new_function(*args , **kwargs):   #这里是参数装包
   
10.         print('开始执行~~~~')
    
11.         # 调用被扩展的函数
    
12.         result = old(*args , **kwargs)        #这里是参数解包
    
13.         print('执行结束~~~~')
    
14.         # 返回函数的执行结果
    
15.         return result
    
16. 
    
17.     # 返回新函数        
    
18.     return new_function
    
19. 
    
20. f = begin_end(fn)
    
21. f2 = begin_end(add)
    
22. f3 = begin_end(mul)
    
23. 
    
24. # r = f()
    
25. # r = f2(123,456)
    
26. # r = f3(123,456)
    
27. # print(r)
    

复制代码

# 像begin_end()这种函数我们就称它为装饰器

#   通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
#   在开发中，我们都是通过装饰器来扩展函数的功能的
# 在定义函数时，可以通过@装饰器，来使用指定的装饰器，来装饰当前的函数
#   可以同时为一个函数指定多个装饰器，这样函数将会按照从内向外的顺序被装饰

1. 
   
2. def fn3(old):
   
3.     '''
   
4.         用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束
   
5. 
   
6.         参数：
   
7.             old 要扩展的函数对象
   
8.     '''
   
9.     # 创建一个新函数
   
10.     def new_function(*args , **kwargs):
    
11.         print('fn3装饰~开始执行~~~~')
    
12.         # 调用被扩展的函数
    
13.         result = old(*args , **kwargs)
    
14.         print('fn3装饰~执行结束~~~~')
    
15.         # 返回函数的执行结果
    
16.         return result
    
17. 
    
18.     # 返回新函数        
    
19.     return new_function
    

复制代码

# 指定多个装饰器会按照从内向外的顺序，这里就是先begin_end，再fn3

1. @fn3
   
2. @begin_end
   
3. def say_hello():
   
4.     print('大家好~~~')
   
5. 
   
6. say_hello()
   

复制代码