Python装饰器

　　找来找去，装饰器这篇只有武sir的例子更容易清晰易懂，所以还是拿武sir的博客来练习。

1.需求

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

############### 基础平台提供的功能如下 ###############
 
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，他是这么做的：

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

　　当天Low B 被开除了...

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

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

############### 基础平台提供的功能如下 ############### 

def f1():
    # 验证1
    # 验证2
    # 验证3
    print 'f1'

def f2():
    # 验证1
    # 验证2
    # 验证3
    print 'f2'

def f3():
    # 验证1
    # 验证2
    # 验证3
    print 'f3'

def f4():
    # 验证1
    # 验证2
    # 验证3
    print 'f4'

############### 业务部门不变 ############### 
### 业务部门A 调用基础平台提供的功能### 

f1()
f2()
f3()
f4()

### 业务部门B 调用基础平台提供的功能 ### 

f1()
f2()
f3()
f4()

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

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

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

############### 基础平台提供的功能如下 ############### 

def check_login():
    # 验证1
    # 验证2
    # 验证3
    pass


def f1():
    
    check_login()

    print 'f1'

def f2():
    
    check_login()

    print 'f2'

def f3():
    
    check_login()

    print 'f3'

def f4():
    
    check_login()
    
    print 'f4'

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

　　老大说：

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

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

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

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为例：

def w1(func):
    def inner():
        # 验证1
        # 验证2
        # 验证3
        return func()
    return inner
 
@w1
def f1():
    print 'f1'

　　当写完这段代码后（函数未被执行、未被执行、未被执行），python解释器就会从上到下解释代码，步骤如下：

def w1(func): ==>将w1函数加载到内存
@w1

　　没错，从表面上看解释器仅仅会解释这两句代码，因为函数在没有被调用之前其内部代码不会被执行。

　　从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章，@函数名 是python的一种语法糖。

　　如上例@w1内部会执行一下操作：

执行w1函数，并将 @w1 下面的函数作为w1函数的参数，即：@w1 等价于 w1(f1)
所以，内部就会去执行：
def inner:
#验证
return f1() # func是参数，此时 func 等于 f1
return inner # 返回的 inner，inner代表的是函数，非执行函数
其实就是将原来的 f1 函数塞进另外一个函数中

将执行完的 w1 函数返回值赋值给@w1下面的函数的函数名
w1函数的返回值是：
def inner:
#验证
return 原来f1() # 此处的 f1 表示原来的f1函数
然后，将此返回值再重新赋值给 f1，即：
新f1 = def inner:
#验证
return 原来f1()
所以，以后业务部门想要执行 f1 函数时，就会执行新f1 函数，在新f1 函数内部先执行验证，再执行原来的f1函数，然后将原来f1 函数的返回值返回给了业务调用者。
如此一来，即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值返回给业务调用着

　　简单来说，为什么装饰器会有2层函数？

　　因为如果只是一层

def w1(func):

#def inner():

# 验证1

# 验证2

# 验证3

return func()

#return inner

　　看看以上代码？python解释器在解析代码的时候，执行了w1函数，那么验证的函数只要解析代码就会被执行，所以这里装了2层，仔细看看，如果是2层，那么w1里面的inner并没有被执行，只有返回inner的内存地址，用户调用的时候才会被执行，所以需要2层，这样说是不是清晰理解很多？

2.扩展来了，有参数？多参数？返回值？怎么办？

　　非常简单？仔细看代码？一般都是做个小小的改动即可

2.1 有参数？一个参数？

def w1(func):
    def inner(arg):             #看这里
        # 验证1
        # 验证2
        # 验证3
        return func(arg)        #看这里，2个注释的地方，是吧？
    return inner

@w1
def f1(arg):
    print 'f1'


#以上可以看出，由于执行到w1函数，就会返回inner函数，那么inner函数包含用户输入的函数即可。这个就没必要多解释了

2.2 有参数？二个参数？

def w1(func):
    def inner(arg1,arg2):
        # 验证1
        # 验证2
        # 验证3
        return func(arg1,arg2)
    return inner

@w1
def f1(arg1,arg2):
    print 'f1'

#这不和一个参数一样嘛？

2.3 有参数？三个参数？

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'

#这不还是一样嘛？

　　问题：可以装饰具有处理n个参数的函数的装饰器？

2.4 真正多参数

　　记得之前学过函数的*args和**kwargs嘛？一个道理。

def w1(func):
    def inner(*args,**kwargs):
        # 验证1
        # 验证2
        # 验证3
        return func(*args,**kwargs)
    return inner
 
@w1
def f1(arg1,arg2,arg3):
print 'f1'

#这不是香香？

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

　　其实感觉这个也没啥用，具体输出结果可以看11期本人学习视频的博客或者练习一下。

def w1(func):
    def inner(*args,**kwargs):
        # 验证1
        # 验证2
        # 验证3
        return func(*args,**kwargs)
    return inner
 
def w2(func):
    def inner(*args,**kwargs):
        # 验证1
        # 验证2
        # 验证3
        return func(*args,**kwargs)
    return inner
 
 
@w1
@w2
def f1(arg1,arg2,arg3):
    print 'f1'

2.6 终结版，更吊的装饰器，三层包裹

#!/usr/bin/env python
#coding:utf-8
  
def Before(request,kargs):
    print 'before'
      
def After(request,kargs):
    print 'after'
  
  
def Filter(before_func,after_func):
    def outer(main_func):
        def inner(request,kargs):
              
            before_result = before_func(request,kargs)
            if(before_result != None):
                return before_result;
              
            main_result = main_func(request,kargs)
            if(main_result != None):
                return main_result;
              
            after_result = after_func(request,kargs)
            if(after_result != None):
                return after_result;
              
        return inner
    return outer
      
@Filter(Before, After)
def Index(request,kargs):
    print 'index'

　　这个就有必要解释一下了，虽然实际中用的不多。

　　其实跟2层装饰器就多了一步。

　　首先纵观整个代码，

　　解释器解析到

　　@Filter(Before,After)

　　def Index(request,kargs):

　　首先打比方

　　@Filter没有参数，这个装饰器怎么解释？打比方按照之前的例子，这里只有2层

　　那么他会执行Filter的函数。为什么会自动执行，因为@符号的特殊性。

　　执行Filter，他会把自己装饰的函数的函数名当作参数，这里拿之前的例子举例更加清晰。比如之前的例子tv = login(tv),这时候，login函数返回是传入的值“tv”的内存地址。然后执行了login不就是等于执行了login+tv？

　　这是简单装饰器的原理。

　　现在看新的，其实就只有一个不同，只是代码比较多，看着比较绕。

　　那就是执行到@Filter（Before，After）的时候。

1.解释器从上往下执行，会先执行Filter这个函数，先不会管@符号。执行这个函数是不是就返回了outer。

2.函数有返回值？这个函数返回值就是outer的内存地址。

3.那么Filter执行完成之后是不是就变成了outer，这时候outer加上@符号就是@outer。

4.那么接下去，@outer也就是变成了2层装饰器？接下来2层装饰器可可以理解了吧。

　　所以说就是多了一部Filter函数先执行。其余的和2层装饰器没有什么区别。

2.7 functools.wraps

　　上述的装饰器虽然已经完成了其应有的功能，即：装饰器内的函数代指了原函数，注意其只是代指而非相等，原函数的元信息没有被赋值到装饰器函数内部。例如：函数的注释信息。

def outer(func):
    def inner(*args, **kwargs):
        print(inner.__doc__)  # None
        return func()
    return inner

@outer
def function():
    """
    asdfasd
    :return:
    """
    print('func')

无元信息

　　如果使用@functools.wraps装饰装饰器内的函数，那么就会代指元信息和函数。

def outer(func):
    @functools.wraps(func)
    def inner(*args, **kwargs):
        print(inner.__doc__)  # None
        return func()
    return inner

@outer
def function():
    """
    asdfasd
    :return:
    """
    print('func')

含元信息

3.实例

　　以上都是武sir的经验，根据学习笔记，这里一笔一笔拆分做一个更简单的记录。如果上述没看懂的可以往下看，看懂的就不用了。

　　以下实例根据一个网站例子来演示，比如，一个网站有主页，有TV页，有image页，需要在登陆这这些页面的时候来一个验证。

3.1 第一版:自己写装饰器功能简单完成需求

　　Login函数作为验证使用

　　那么具体看以下图示

　　最后报错,TypeError，是因为虽然login验证函数和tv函数都执行了，但是login函数是没有返回值的，在执行tv()，那么就是执行None()，当然会报错。

3.2 第二版:完善简单完成需求-加入返回值不让报错

　　Return func的内存地址，然后手动调用执行。

3.3 第三版:TV主函数也要加入参数

　　看到以上，可以看到已经可以带了参数？那么是否实现了装饰器呢？但是装饰器有专门的语法堂，不用每次专门tv=login(tv)一下调用。所以，接下来第4版，看看装饰器语法堂使用。

3.4 第四版:装饰器语法糖使用

　　以上，已经实现了装饰器的使用？

　　不对，貌似看没问题，我们这里把tv()执行函数取消看看结果？

　　可以看到，以上什么都没做，还是执行了验证？因为python把代码加载到内存的时候，就执行了login()的函数了，这不是我们想要的效果。所以，装饰器还没完成。

3.5 第五版:装饰器初版

　　实现带了简单参数，并且，只有执行tv函数的时候才会执行验证。

　　看一下例子，简单来说，就是包2层，执行第二层函数的时候才会做验证以及执行主体函数。第二层函数包含了验证、以及主体函数，但是并不执行，只有调用的时候执行这个第二层函数，第二层函数因为包含了验证和主体函数，所以就一并执行了。

　　看图片里面的注释，是否已经实现了简单的装饰器功能？不调用就不执行验证，并且还可以传参数。

　　那么，以上实现了简单装饰器，也实现了传一个参数，但是你会不会有其它需求，复杂一点的？比如，传2个参数？或者多个参数？或者说带返回值的函数？

3.6 第六版:多参数装饰器

　　比如可以传入*args和**kwargs。

3.7 第七版:多参数装饰器带返回值版

　　上面的例子可以看到，虽然可以传入多个参数，但是返回确实None？

　　其实这个也非常好解决。

3.8 第八版:带参数的3层装饰器，终极版

　　其实这种3重函数的装饰器在实际中很少碰到，但是也有可能碰到这种场景，所以还是需要学习。

　　比如，要在装饰器传入参数判断，比如有个场景，这里要先登录验证，登录验证的时候要传入参数，然后在执行主函数，得到主函数的返回值什么的之后，在判断是否输入一些内容。总结简单来说，就是装饰器带参数的联系。

　　before_func 是之前需要传入的函数

　　after_func 是之后需要传入参数的函数

　　main_func是被装饰的函数