装饰器

（1）介绍

装饰器：本质就是函数，其目的为其他函数添加功能

原则：（1）不修改被装饰函数的源代码（开放封闭原则）

         （2）为被装饰函数添加新功能后，不修改被修饰函数的调用方式

组成：高阶函数、嵌套函数、闭包

（2）组成分析

高阶函数定义:

1.函数接收的参数是一个函数名

2.函数的返回值是一个函数名

3.满足上述条件任意一个,都可称之为高阶函数

#仅仅使用高阶函数实现函数增加功能
import time#导入时间模块
def use_1():#原函数
    time.sleep(3)
    print("hello")
def fo(func):#高阶函数
    start_time = time.time()
    func()#当传入的参数为函数名时，此时便会执行该函数
    end_time = time.time()
    print("函数运行的时间是%s"%(end_time-start_time))#添加时间计算功能
    return func
use_1 = fo(use_1)#函数的返回值是一个函数名，可以用原变量接受
use_1()#在此基础上，可以以原来调用方式调用该函数
#打印结果
#hello
#函数运行的时间是3.000171661376953
#hello

由上面函数可知，当只使用高阶函数来为目标函数增加功能时，虽然没有改变原函数的源代码跟执行方式，但不可避免的是函数会执行第二次

嵌套函数：在函数内定义新函数，函数内变量查找遵循L(local）、E（enclosed）、G（global）、B（built）

# def qt(func):#
#     def inner():
#         def oc():
#             print(func)#变量查找遵循LEGB原则
#         oc()
#     inner()
# qt("hello")#将hello赋值给参数func

闭包：

如果在一个内部函数里：us(y)就是这个内部函数，

对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域occ里面，但不在全局作用域里，

则这个内部函数us就是一个闭包。

def occ(x):
    def us(y):#us是闭包
        print( x + y )#对外部作用域变量x进行引用
    return us
aa = occ(6)
aa(4)#

（3）装饰器

注意：@为python内置方法，等价于目标函数名=装饰器函数名(目标函数名),装饰器函数写好，哪个函数要调用直接在其上部写@装饰器名字即可

import time
def abc(func):
    def ooo(*args,**kwargs):
        start_time = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        print("函数运行时间为%s"%(end_time-start_time))
        return res
    return ooo
@abc#@为python内置方法，等价于aaa=abc(aaa),装饰器函数写好，哪个函数要调用直接在其上部写@装饰器名字即可
def aaa(*args,**kwargs):
    time.sleep(2)
    print("运行函数了！")
    print("函数运行结束了！")
    return "这是aaa的返回值"
ccc = aaa()#注意，此时的ccc接受到的是ooo()函数的返回值，并非aaa()的返回值
print(ccc)

例子：

不含参数的装饰器

use_list = [{"name":"tom","passwd":“123”},
            {"name":"eric","passwd":“123”}]
use_time = {"name":None,"log":False}

def ente(func):
    # use_name = input("请输入用户名：").strip()
    # use_passwd = input("请输入密码：").strip()
    def en(*args,**kwargs):
        if use_time["name"] and use_time["log"]:
            res = func(*args,**kwargs)
            return res
        use_name = input("请输入用户名：").strip()
        use_passwd = input("请输入密码：").strip()
        for i in use_list:
            if use_name == i["name"] and use_passwd == i["passwd"]:
                use_time["name"] = use_name
                use_time["passwd"] = use_passwd
                res = func(*args,**kwargs)
                return res
        else:
            print("用户名或密码错误！")
    return en
@ente
def home():
    print("欢迎来到京东主页！")
@ente
def shopping_list():
    print("欢迎来到shoping_list!")
@ente
def shoping_car():
    print("欢迎来到shoping_car!")
home()
shopping_list()

 含参数的装饰器

use_list = [{"name":"tom","passwd":"123"},
            {"name":"eric","passwd":"123"}]
use_time = {"name":None,"log":False}
def firt(ente_1 = "test")
    def ente(func):
        # use_name = input("请输入用户名：").strip()
        # use_passwd = input("请输入密码：").strip()
        def en(*args,**kwargs):
            if use_time["name"] and use_time["log"]:
                res = func(*args,**kwargs)
                return res
            use_name = input("请输入用户名：").strip()
            use_passwd = input("请输入密码：").strip()
            for i in use_list:
                print(i["name"],i["passwd"])
                if use_name == i["name"] and use_passwd == i["passwd"]:
                    use_time["name"] = use_name
                    use_time["log"] = True
                    res = func(*args,**kwargs)
                    return res
            else:
                print("用户名或密码错误！")
        return en
    return ente
@firt(ente_1 = "test")#相当于运行firt函数，返回entc函数名，结果等价于@ente,好处是最外层传入了一个参数，内层的闭包函数可以直接引用
def home():
    print("欢迎来到京东主页！")
@firt(ente_1 = "test")
def shopping_list():
    print("欢迎来到shoping_list!")
@firt(ente_1 = "test")
def shoping_car():
    print("欢迎来到shoping_car!")
home()
shopping_list()