python装饰器

装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。

简单的来说在不修改原函数的情况下，在对原函数进行包装！

 

一、初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：

 

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
############### 基础平台提供的功能如下 ###############
  
def f1():
    print 'f1'
  
def f2():
    print 'f2'
  
def f3():
    print 'f3'
  
def f4():
    print 'f4'
  
############### 业务部门A 调用基础平台提供的功能 ###############
  
f1()
f2()
f3()
f4()
  
############### 业务部门B 调用基础平台提供的功能 ###############
  
f1()
f2()
f3()
f4()

 目前公司有条不紊的进行着，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题，即：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。

老大把工作交给 Low B，他是这么做的：

 

1
跟每个业务部门交涉，每个业务部门自己写代码，调用基础平台的功能之前先验证。诶，这样一来基础平台就不需要做任何修改了。

 

 当天Low B 被开除了...

老大把工作交给 Low BB，他是这么做的：

1
只对基础平台的代码进行重构，让N业务部门无需做任何修改
 修改原基础平台代码

过了一周 Low BB 被开除了...

老大把工作交给 Low BBB，他是这么做的：

1
只对基础平台的代码进行重构，其他业务部门无需做任何修改
 新建立一个函数把函数应用到原基础函数上

老大看了下Low BBB 的实现，嘴角漏出了一丝的欣慰的笑，语重心长的跟Low BBB聊了个天：

老大说：

写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：

  • 封闭：已实现的功能代码块
  • 开放：对扩展开发

如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码，老板就给了Low BBB一个实现方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def w1(func):
    def inner():
        # 验证1
        # 验证2
        # 验证3
        return func()
    return inner
  
@w1
def f1():
    print 'f1'
@w1
def f2():
    print 'f2'
@w1
def f3():
    print 'f3'
@w1
def f4():
    print 'f4'

 

对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。

Low BBB心惊胆战的问了下，这段代码的内部执行原理是什么呢？

老大正要生气，突然Low BBB的手机掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一紧一抖，喜笑颜开，交定了Low BBB这个朋友。详细的开始讲解了：

单独以f1为例：

1
2
3
4
5
6
7
8
9
10
11
12
def w1(func):
    def inner():
        print 'gongneng1'
        func()
        print 'gongneng2'
    return inner
 
@w1
def f1():
    print 'f1'
 
f1()

 当执行的时候，python是由上到下执行的，首先执行到def w1(func):这里把def w1(func)加载到内存

当执行到@w1的时候@w1是python的语法糖！他会把他下面的函数进行封装。

把f1这个函数作为def w1(func)的参数传进去！就是：f1()=w1(f1)

然后def w1(func):  == w1(f1)就会执行：

1
2
3
4
5
def inner():
    print 'gongneng1'
    func()   #func()  == f1()“原函数”
    print 'gongneng2'
return inner  #然后把封装后的函数输出给原函数

@w1就相当于做了一个替换

def f1()  <==> def inner()

1
2
3
4
5
@w1
def f1():         #  ==def inner() :
    print 'f1'    #           print 'gongneng1'
                  #           func()
                  #           print 'gongneng2'

 

二、被装饰的函数如果有参数呢？

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def w1(func):
    def inner(arg):
        # 验证1
        # 验证2
        # 验证3
        return func(arg)
    return inner
 
@w1
def f1(arg):
    print 'f1'
 
一个参数
 
 
################################
def w1(func):
    def inner(arg1,arg2):
        # 验证1
        # 验证2
        # 验证3
        return func(arg1,arg2)
    return inner
 
@w1
def f1(arg1,arg2):
    print 'f1'
 
两个参数
################################
def w1(func):
    def inner(arg1,arg2,arg3):
        # 验证1
        # 验证2
        # 验证3
        return func(arg1,arg2,arg3)
    return inner
 
@w1
def f1(arg1,arg2,arg3):
    print 'f1'
 
三个参数

 用动态参数搞定！

1
2
3
4
5
6
7
8
9
10
11
def w1(func):
    def inner(*args,**kwargs):
        # 验证1
        # 验证2
        # 验证3
        return func(*args,**kwargs)
    return inner
  
@w1
def f1(arg1,arg2,arg3):
    print 'f1'

三、一个函数可以被多个装饰器装饰吗？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def w1(func):
    def inner(*args,**kwargs):
        print 'gongneng1'
        func(*args,**kwargs)
        print 'gongneng2'
    return inner
def w2(func):
    def inner(*args,**kwargs):
        print 'gongneng3'
        func(*args,**kwargs)
        print 'gongneng4'
    return inner
 
@w1
@w2
def f1(arg,arg2,arg3):
    print arg,arg2,arg3
 
f1('nihao','tianshuai','shuaige')

 输出结果：

1
2
3
4
5
gongneng1
gongneng3
nihao tianshuai shuaige
gongneng4
gongneng2

 这个被多个装饰器装饰，其实就是套完一层在套一层！勿把自己绕进去！

 四、还有什么更吊的装饰器吗？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def Filter(a1,a2):
    def outer(main_func):
        def wrapper(request,kargs):
            print a1
            main_result = main_func(request,kargs)
            print a2
                return main_result
        return wrapper
    return outer
 
@Filter(f5, f6)
def Index(request,kargs):
    print 'index'
     
'''
1、第一步：把def Filter(a1,a2): 加载到内存
2、第二步：@Filter(f5, f6)  == 调用了装饰器  == @outer 然后返回给函数
3、第散步：执行outer函数并返回给index函数  Index == wrapper
4、执行wrapper 函数，这样做的意义就是除了原函数给的参数外，装饰器也可以调用自己定义的参数
 
'''

 这样做的意义就是除了原函数给的参数外，装饰器也可以调用自己定义的参数

posted @ 2021-07-06 17:58  rmticocean  阅读(633)  评论(0)    收藏  举报