Python 装饰器的形成过程

装饰器
  定义：本质是函数，(装饰其他函数)，即为其他函数添加附加功能。
  原则： 1、不能修改被装饰的函数的源代码；
            2、不能修改被装饰的函数的调用方式。

实现装饰器知识储备：
   1. 函数即'变量'        
   2. 高阶函数
       a. 把一个函数名当作实参传递给另一个函数(在不修改被装饰函数源代码的前提下为其添加新功能)
       b. 返回值中包含函数名(不修改函数的调用方式)
   3. 嵌套函数

高阶函数 + 嵌套函数 (组成)--> 装饰器

  1、必备                                                

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies


'''第一波'''

def foo():
    print('in the foo')

foo               # 函数名，相当于变量
print(foo)        # <function foo at 0x0000000001CFCBF8>  变量的索引地址
foo()             # in the foo    执行/调用函数foo


'''第二波'''

def foo(x):
    print('in the foo_%d' %x)

foo = lambda x:x+1

print(foo)

print(foo(1))     # 执行下面的lambda表达式，而不再是原来的foo函数，因为函数 foo 被重新定义了


'''
<function foo at 0x0000000001CFCBF8>
in the foo
<function <lambda> at 0x0000000001CFCBF8>
2
'''

 

  2、需求来了                                       

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

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

def f1():
    print('in the f1')

def f2():
    print('in the f2')

def f3():
    print('in the f3')

def f4():
    print('in the f4')

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

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

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

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

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

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

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

 当天Low B 被开除了...

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

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

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

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

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

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

def f4():
    # 验证1
    # 验证2
    # 验证3
    print('in the 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一个实现方案：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

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

@w1
def f1():
    print('in the f1')

@w1
def f2():
    print('in the f2')

@w1
def f3():
    print('in the f3')

@w1
def f4():
    print('in the f4')

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

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

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

以下面为例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

import time

def timer(func):
    def deco():
        start_time = time.time()
        func()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco

@timer        # test1 = timer(test1)
def test1():
    time.sleep(3)
    print('in the test1')

test1()

下面解析一下以上代码的执行(解释器解释)过程：

1. 解释 import time

2. 初始化 def timer(func):  ，即将函数变量timer和形参入栈内存

3. 解释 第5行和第6行代码，因为@timer;def test1(): 是一个整体结构（语法糖），相当于第2步的初始化，解释的结果是： test1 = timer(test1)

4. 执行test1 = timer(test1)，注意此时timer(test1)中的test1是def test1(): 中的函数名，存储于栈内存，timer(test1)将函数名test1作为实参传入timer()函数

5. 接着初始化def deco(): 入栈内存，并将函数名deco以返回值的形式赋值给第3步中的test1 = timer(test1)，故此时test1的值为函数deco的函数体的内存地址

6. 接着至第20行解析test1()，由于此时test1的值为deco的内存地址，故接下来会调用函数deco

7. 依次执行函数deco的函数体start_time = time.time()，func()

8. 由于第3步中有实参传入，故此时的形参func即为test1， 即执行test1()，调用函数def test1(): 并执行之

9. 接着执行第11和12行。整个程序模块执行完毕。

执行结果：

in the test1
the func run time is 9.18652606010437（debug模式下得出的结果）

先把上述流程看懂，之后还会继续更新...

  3、问答时间                                         

问题：当被装饰（或扩充）的函数有参数，而且参数个数不一致时：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

import time

def timer(func):
    def deco(argv1,argv2):
        start_time = time.time()
        func(argv1,argv2)
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco

@timer
def test2(name, age):
    time.sleep(2)
    print('in the test2: %s %d' %(name, age))

test2('alex',22)

'''
in the test2: alex 22
the func run time is 2.000114917755127
'''

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

import time

def timer(func):
    def deco():
        start_time = time.time()
        func()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco

@timer        # test1 = timer(test1)
def test1():
    time.sleep(2)
    print('in the test1')

@timer
def test2(name, age):
    time.sleep(2)
    print('in the test2: %s %d' %(name, age))

test1()
test2('alex',22)

'''
D:\Python\python.exe E:/python14_workspace/s14/day04/decorator_4_2.py
in the test1
the func run time is 2.0001139640808105
Traceback (most recent call last):
  File "E:/python14_workspace/s14/day04/decorator_4_2.py", line 26, in <module>
    test2('alex',22)
TypeError: deco() takes 0 positional arguments but 2 were given

Process finished with exit code 1
'''

发现当参数不固定时，会出现错误，故需将其改进：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

import time

def timer(func):
    def deco(*argv):
        start_time = time.time()
        func(*argv)
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco

@timer        # test1 = timer(test1)
def test1():
    time.sleep(2)
    print('in the test1')

@timer
def test2(name, age):
    time.sleep(2)
    print('in the test2: %s %d' %(name, age))

test1()
test2('alex',22)

'''
in the test1
the func run time is 2.000114917755127
in the test2: alex 22
the func run time is 2.0001139640808105
'''

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

import time

def timer(func):
    def deco(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco

@timer        # test1 = timer(test1)
def test1():
    time.sleep(2)
    print('in the test1')

@timer
def test2(name, age):
    time.sleep(2)
    print('in the test2: %s %d' %(name, age))

test1()
test2('alex',age = 22)   # 有关键参数时

'''
in the test1
the func run time is 2.0001139640808105
in the test2: alex 22
the func run time is 2.000114917755127
'''

装饰器应用实例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

usr,passwd = 'alex','abc123'

def auth(func):
    def wrapper(*args, **kwargs):
        username = input("username:").strip()
        password = input("password:").strip()
        if username == usr and password == passwd:
            print('\033[32;1mUser has passed authentication.\033[0m')
            return func(*args,**kwargs)
        else:
            exit('\033[31;1mInvalid username or password.\033[0m')
    return wrapper


def index():
    print('welcome to index page.')

@auth
def home():
    print('welcome to home page.')
    return 'from home'

@auth
def bbs():
    print('welcome to bbs page.')

index()
print(home())
bbs()

出现以上的当登录home()和bbs模块时，需要通过验证。但是当不同的登录渠道需要不同的验证处理时，以上模块代码就傻眼了。故针对不同的登录渠道需要个性化的验证：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

usr,passwd = 'alex','abc123'

def auth(auth_type):                   # 增加个性化定制参数 
    print('auth func:', auth_type)
    def outer_wrapper(func):         
        def wrapper(*args, **kwargs):
            print('auth func args:', *args, **kwargs)
            if auth_type == 'local':
                username = input("username:").strip()
                password = input("password:").strip()
                if username == usr and password == passwd:
                    print('\033[32;1mUser has passed authentication.\033[0m')
                    return func(*args, **kwargs)
                else:
                    exit('\033[31;1mInvalid username or password.\033[0m')
            elif auth_type == 'ldap':
                print('get hell out here!')
        return wrapper
    return outer_wrapper


def index():
    print('welcome to index page.')

@auth(auth_type = 'local')         # 个性化定制
def home():
    print('welcome to home page.')
    return 'from home'

@auth(auth_type = 'ldap')
def bbs():
    print('welcome to bbs page.')

index()
print(home())
bbs()

 

  4、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模块中的@functools.wraps装饰的装饰器内的函数，那么就会代指元信息和函数。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: antcolonies

import functools

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

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

function()

'''

    decorator
    asdfasd
    :return:

func
'''