day14-函数（3）装饰器

一、闭包函数

闭包函数=函数嵌套定义+函数对象+名称空间与作用域

闭包函数

1、闭：指的是该函数是定义在一个函数内部的函数
2、包：值得是该函数访问了一个来自于外层函数的变量

为函数体传参：
方案一：直接使用参数的形式传递

def wrapper(x):
    print(x)

wrapper(111)
wrapper(222)

方案二：把函数体想要的参数包给它

def outter(x):
    # x = 111

    def wrapper():  # wrapper = 闭包函数的内存地址
        print(x)

    return wrapper  # 一定不要加括号
    # return 闭包函数的内存地址


f1 = outter(111)  # f = 闭包函数的内存地址
f2 = outter(222)  # f = 闭包函数的内存地址

二、无参装饰器

常用三连：

1、什么是装饰器
器：工具
装饰：为被装饰者添加额外的功能

2、为何要有装饰器
软件一旦上线运行之后，就应该遵循开放封闭原则：
1、开放指的是对拓展新功能开放
2、封闭指的是对修改源代码封闭

定义装饰器的目的：

定义装饰器就是为了在遵循1和2的前提下来为其他函数添加新功能的

ps：
不修改被装饰对象指的是定义与调用都不能修改
所以下述行为都违反了开放封闭原则：
(1)、修改被装饰对象定义时的源代码
(2)、修改被装饰对象的调用方式

3、如何用装饰器

一、被装饰器对象index如下：

import time

def index(x,y):
    time.sleep(1)
    print('index===>',x,y)

index(1,2)

二、为index添加新功能（顺流而下地步步接近装饰器）
2.1 方案一：直接修改源代码为被装饰对象index添加新功能
问题：修改了源代码

import time

def index(x,y):
    start_time = time.time()
    time.sleep(1)
    print('index===>',x,y)
    stop_time = time.time()
    print('run time is: %s' %(stop_time - start_time))

index(1,2)

2.2 方案二：找到所有调用index的位置，然添加代码
问题：需要写好多段重复代码

import time

def index(x,y):
    time.sleep(1)
    print('index===>',x,y)


start_time = time.time()
index(1,2)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))

2.3 方案三：把装饰功能写到一个函数内
问题：装饰功能被写死了，只能用来装饰index函数了

import time

def index(x,y):
    time.sleep(1)
    print('index===>',x,y)

def wrapper():
    start_time = time.time()
    index(1,2)
    stop_time = time.time()
    print('run time is: %s' %(stop_time - start_time))

wrapper()

2.4 方案四：把wrapper函数内的index修改为参数的形式
问题：直接为wrapper函数传参的方案不行，因为原函数的调用
是在全局调用index(1,2), 而现在的调用统一都变成了wrapper(index)，着修改被装饰的调用方式

import time

def index(x,y):
    time.sleep(1)
    print('index===>',x,y)


def wrapper(func):
    start_time = time.time()
    func(1,2)
    stop_time = time.time()
    print('run time is: %s' %(stop_time - start_time))

wrapper(index)

2.5 方案五：基于闭包函数把wrapper函数想要的参数包给它，然后基于函数对象把闭包函数wrapper返回到全局，赋值给原函数名
问题：把index伪装成了wrapper，但伪装的不够像：参数的传递与原函数不一致

import time

def index(x,y):
    time.sleep(1)
    print('index===>',x,y)

def outter(func):
    # func = index
    def wrapper():
        start_time = time.time()
        func(1,2)
        stop_time = time.time()
        print('run time is: %s' %(stop_time - start_time))
    return wrapper

index=outter(index)

index()

2.6 方案六：在方案五的基础上基于args,*kwargs把wrapper的参数伪装成跟被装饰函数一模一样
问题：返回值与原函数不一致

import time

def index(x,y):
    time.sleep(1)
    print('index===>',x,y)

def home(name):
    time.sleep(0.5)
    print('welcome %s to home page' %name)
    return 123

def outter(func):
    # func = index
    def wrapper(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        stop_time = time.time()
        print('run time is: %s' %(stop_time - start_time))
    return wrapper

index=outter(index)
home=outter(home)

# index(1,2)
res=home('egon')
print(res)

2.7 方案七：在方案六的基础上把wrapper函数的返回值与被装饰函数保持一致
问题：装饰器的使用不够简洁

import time
from functools import wraps

def timmer(func):
    # func = index
    @wraps(func)
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs)
        stop_time = time.time()
        print('run time is: %s' %(stop_time - start_time))
        return res
    return wrapper

def index(x,y):
    time.sleep(1)
    print('index===>',x,y)

def home(name):
    "home的文档注释"
    time.sleep(0.5)
    print('welcome %s to home page' %name)
    return 123

help(home)

2.8 方案八：在方案7的基础上使用装饰器的语法糖@符号让装饰器的使用变得简洁

import time
from functools import wraps

def timmer(func):
    # func = index
    @wraps(func)
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs)
        stop_time = time.time()
        print('run time is: %s' %(stop_time - start_time))
        return res
    return wrapper

@timmer  # index=timmer(index)
def index(x,y):
    time.sleep(1)
    print('index===>',x,y)

@timmer  # home=timmer(home)
def home(name):
    "home的文档注释"
    time.sleep(0.5)
    print('welcome %s to home page' %name)
    return 123


res=index(1,2)
res=home('yan')

三、装饰器叠加

1、无参装饰器的模板

def outter(func):
    def wrapper(*args,**kwargs):
        res=func(*args,**kwargs)
        return res
    return wrapper

2、叠加多个装饰器

加载顺序:自下而上
执行顺序:自上而下运行内层的wrapper函数

def deco1(func1):  # func1 = wrapper2的内存地址
    def wrapper1(*args,**kwargs):
        print('wrapper1====>')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def deco2(func2):  # func2 = wrapper3的内存地址
    def wrapper2(*args,**kwargs):
        print('wrapper2====>')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def deco3(func3):  # func3 = 最原始的那个被装饰函数的内存地址
    def wrapper3(*args,**kwargs):
        print('wrapper3====>')
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3

        # index=wrapper1的内存地址
@deco1  # deco1(wrapper2的内存地址)=>wrapper1的内存地址
@deco2  # deco2(wrapper3的内存地址)=>wrapper2的内存地址
@deco3  # deco3(最原始的那个被装饰函数的内存地址)=>wrapper3的内存地址
def index(x,y):
    print('index=>',x,y)

index(1,2)

预测输出结果：
"""
wrapper1====>'
wrapper2====>
wrapper3====>
index=>1,2
"""

3 案例

import time

# 计算某个函数运行时间的装饰器
def deco1(func1):
    def wrapper1(*args,**kwargs):
        start_time = time.time()
        res1=func1(*args,**kwargs)
        stop_time = time.time()
        print(stop_time - start_time)
        return res1
    return wrapper1


# 简单的认证登录装饰器
def deco2(func2):
    def wrapper2(*args,**kwargs):
        inp_name = input('username>>>: ').strip()
        inp_pwd = input('password>>>: ').strip()
        if inp_name == "yan" and inp_pwd == "123":
            print('login successful')
            res2=func2(*args,**kwargs)
            return res2
        else:
            print('username or password error')
    return wrapper2

@deco2
@deco1
def index(x,y):
    time.sleep(1)
    print('index=>',x,y)

index(1,2)

四、有参装饰器

有参装饰器的模板：

def outter2(x,y,z,a,b):
    def outter1(func):
        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            return res
        return wrapper
    return outter1

案例：

def outter(engine = 'file'):
    def deco2(func2):
        def wrapper2(*args,**kwargs):
            inp_name = input('username>>>: ').strip()
            inp_pwd = input('password>>>: ').strip()

            if engine == "file":
                print('基于file的认证')
                if inp_name == "yan" and inp_pwd == "123":
                    print('login successful')
                    res2=func2(*args,**kwargs)
                    return res2
                else:
                    print('username or password error')
            elif engine == 'mysql':
                print('基于mysql的认证')
            elif engine == 'ldap':
                print('基于ldap的认证')
            else:
                print('未知的engine')
        return wrapper2
    return deco2

@outter(engine='mysql')  # @deco2 # index=deco2(index)
def index(x,y):
    print('index=>',x,y)

index(1,2)  # index=>wrapper