''''''
"""
闭包函数
1.闭:定义在函数内部的函数
2.包:内部函数引用了外部函数作用域的名字
"""
# def outter(): # 定义一个外层函数
# x = 111 # 在外层函数的局部名称空间定义变量x = 111
# def inner(): # 定义一个内层函数
# print(x) # 打印x
# return inner # 外层函数返回值为 内层函数名
# res = outter() # res就是inner函数内存地址，调用外层函数 三步：定义x，定义内层函数，返回内层函数名
#
# def func(): # 定义函数 检查语法不执行
# x = 333 # 在函数的局部名称空间定义变量x = 333
# res() # 调用res 即调用inner() 内层函数 检查语法不执行
# func() # 执行func()
# # 执行顺序： 执行func：
# # 第一步 在函数的局部名称空间定义变量x = 333，
# # 第二部 执行inner()，打印x，在inner的局部名称空间找不到，去上层outter的局部名称空间找，找到了，打印111
# 给函数体传值的第一种方式 传参
# def index1(username):
# print(username)
#
# # 给函数体传参的第二种方式 闭包 # 执行顺序
# def outter(x,y): # 定义一个外层函数并设置位置形参 x y 定义函数，检查语法不执行 # 2
# # x = 1 # 调用函数时候，传入位置形参，默认在 外层函数的局部命名空间 做了赋值操作 # 3
# # y = 40 # 调用函数时候，传入位置形参，默认在 外层函数的局部命名空间 做了赋值操作 # 4
# def my_max(): # 定义内层函数 # 5
# if x > y: # 判断条件 # 9
# return x # 执行判断条件下的代码 # 10
# return y # 判断条件非会执行什么 # 10
# return my_max # 返回内层函数名 # 6
# res1 = outter(1,40) # res就是my_max函数的内存地址 # 7 1
# # 这一步看似是个赋值操作，其实后面是个调用outter()函数的操作，然后把函数执行的返回结果赋值给res1 #
# # 这一步因为有调用函数，执行优先级别最高，所以是先执行函数然后再赋值给res1，不是先赋值 #
# # 调用函数，执行函数时，需要传递两个位置形参 #
# print(res1()) # 打印res1的执行结果，即打印 my_max的执行结果 先执行函数 后打印 # 11 8
# print(res1()) # 打印res1的执行结果，即打印 my_max的执行结果 先执行函数 后打印 #
# res2 = outter(90,200)
# print(res2())
# print(res2())
"""
装饰器:
器:就是一个工具
装饰:给被装饰对象添加新的功能
为什么要用装饰器
开放封闭原则:
开放:对扩展开放
封闭:对修改封闭
装饰器(可调用对象)必须遵循的两个原则:
1.不改变被装饰对象源代码
2.不改变被装饰对象(可调用对象)调用方式
def index():
pass
index()
如何用
"""
# import time # 导入时间模块
# print(time.time()) # 打印时间戳
# # 结果为1562812014.731474 时间戳 当前时间距离1970-1-1 00:00:00相差的秒数
# # 1970-1-1 00:00:00是Unix诞生元年
# import time
# time.sleep(3) # 让cpu暂停三秒 让你的程序暂停三秒
# print('FBI warning!')
# # 执行结果，过三秒会打印字符串
#
"""
1.统计index函数执行的时间
"""
# import time
# def index():
# time.sleep(3)
# print('澳门最大线上赌场开业啦 性感tank在线发牌!')
#
# start = time.time()
# index()
# end = time.time()
# print('index run time:%s'%(end-start))
# # 打印 结束时间戳减去开始时间戳，中间的时间差 就是执行时间，主要是sleep的时间
"""
1.统计index函数执行的时间
装饰器(可调用对象)必须遵循的两个原则:
1.不改变被装饰对象源代码
2.不改变被装饰对象(可调用对象)调用方式
"""
# # 1.统计index函数执行的时间
# import time # 导入时间模块
# def index(): # 定义被装饰函数
# time.sleep(3) # cpu暂停三秒再继续执行
# print('澳门最大线上赌场开业啦 性感tank在线发牌!') # 打印字符串
# # index() 单独执行效果，延迟三秒打印字符串
# # 装饰器如下
# def outter(func): # func = 最原始的index函数的内存地址 # 定义外层函数outter，位置参数func
# # func = index # 执行外层函数时，被传参，位置实参为index，即有参数赋值这一步
# def get_time(): # 定义内层函数（新增功能获取执行时间）
# start = time.time() # 开始时间 = 打印当前时间戳
# func() # func = index函数的内存地址() 直接调用 # 执行func函数
# end = time.time() # 结束时间 = 打印结束时间戳
# print('index run time:%s'%(end-start)) # 打印执行func()前后时间差
# return get_time # 返回内层函数名（新增功能）
# index = outter(index) # outter(最原始的index函数内存地址)
# # 使用原被装饰函数名为变量 = 执行装饰器外层函数(位置实参为原始被装饰函数函数名)
# # index指向get_time函数的内存地址
# index() # 执行 （使用原被装饰函数名为新函数名的）函数 # 就执行上面这个变量名作为函数名的函数
'''
分析：
执行步骤; 全局名称空间下 一共执行五步
第一步：导入时间模块
第二步：定义被装饰函数 outter(func)（装饰器外层函数 位置形参为func）
第三步：定义装饰器函数 get_time()
第四步：将原函数名作为新函数名，并赋值，值为（调用装饰器函数 且 传入参数为（被装饰函数名））的执行结果
全局名称空间下 第四步，有两个操作 执行装饰器函数（优先级高），并赋值给新函数名（与原函数名相同）
言外之意，需要将第四步装饰器函数执行了，并且赋值，才能走到第五步，执行新的函数名（调用被装饰后的函数）
第四步 执行装饰器 步骤如下：
1 ：参数赋值，装饰器被传入的位置实参为 func = index（这个index为原函数名称），这个赋值被存在 '装饰器外层函数的局部名称空间'中
2 ：定义内层函数get_time，定义函数不执行，内层函数为新增功能函数
3 ：返回内层函数名get_time，将内层函数名get_time作为返回结果返回
第四步 赋值 步骤如下：
1 ：将（装饰器外层函数返回的内层新增功能函数的函数名）get_time 赋值给新函数名index（与原函数名称一样）
第五步：执行新函数名 index（这个为新函数名）
全局名称空间下，第四步执行完毕，执行第五步
第五步是执行装饰后的新函数，因为新函数名index 被赋值 （装饰器外层函数返回的内层新增功能函数的函数名）get_time
也就是，执行新增功能函数，即执行内层函数，执行内层函数步骤如下：
1：在装饰器内层函数的局部名称空间中定义 开始时间 = 打印当前时间戳
2：执行func函数，这一步需要找func这个变量的值，查找顺序 和 执行顺序如下：
1. 在装饰器内层函数的局部名称空间中找，没有找到
2. 在上一层装饰器外层函数的局部名称空间中找，找到了，在 四-1 这一步 func = index，这个index为原函数名称
3.执行index原函数 两步;
1. cpu暂停三秒
2. 打印 '澳门最大线上赌场开业啦 性感tank在线发牌!'字符串
3：在装饰器内层函数的局部名称空间中定义 结束时间 = 打印当前时间戳
4：打印时间差 结束时间减去开始时间
第五步执行完毕 执行效果为 延迟三秒打印字符串，打印执行时间差
定义原函数 1
定义装饰器函数 2
执行装饰器，传参原函数名，定义新功能函数 并 返回新功能函数名赋值给新函数名， 3
原函数名和新函数名一样 4
执行新函数，就是执行新功能函数，就是执行装饰器内层函数， 5
装饰器内层函数中的操作 有 执行函数为新功能函数 + 原函数 6 结束
'''
"""
函数参数的问题
无参函数和有参函数都可以直接调用???
函数可以接收任意数量的参数
"""
# # 无参数的被装饰函数
# import time # 导入时间模块
# def index(): # 定义原函数 （无参函数）
# time.sleep(3) # cpu暂停三秒之后打印
# print('澳门最大线上赌场开业啦 性感tank在线发牌!') # 打印字符串
# return 'index' # 返回index 字符串
# # res1 = index() # res1 为index函数执行结果的返回值（需要先执行函数，执行函数的优先级比较高）
#
# def outter(func): # func = 最原始的login函数的内存地址 # 定义装饰器外层函数，有位置形参func
# def get_time(*args, **kwargs): # args = ('egon',) kwargs = {} # 定义装饰器内层函数，有可变长形参
# start = time.time() # 赋值start 为 被装饰函数开始执行的时间戳
# res1 = func(*args, **kwargs) # 最原始的login函数的内存地址() 直接调用 func('egon')
# end = time.time() # 赋值end 为 被装饰函数结束执行时间戳
# print('func run time:%s'%(end-start)) # 打印时间差
# return res1 # 返回func函数执行结果返回值
# return get_time # 返回内层函数名
#
# # 无参数的被装饰函数
# index = outter(index) # 先执行调用装饰器，
# # 执行三步：1.定义内层函数，2.把index当位置实参传入装饰器，即func= index 3.将返回的内层函数函数名赋值给新函数名
# res1 = index() # 调用执行被装饰后的新函数，即执行装饰器内层函数，
# # 一共五步：1.赋值开始时间戳 2.执行index（此时func已经等于index，在上层局部名称空间找到的）：停三秒 打印 返回字符串并赋值给res1
# # 3. 赋值结束时间戳 4. 打印时间差 5. 返回res1，即返回index字符串
# print(res1) # 6. 打印字符串 结束
# # 有参数的被装饰函数
# import time
# def login(name): # 定义原函数 （有参函数，位置参数name）
# time.sleep(1) # cpu暂停三秒之后打印
# print('%s is sb'%name) # 打印字符串 字符串拼接格式化输出，%s占位符 输入变量
# return 'login' # 返回login 字符串
# # res = login('egon') # res1 为login函数传参egon后执行结果的返回值（需要先执行函数，执行函数的优先级比较高）
#
# def outter(func): # func = 最原始的login函数的内存地址 # 定义装饰器外层函数，有位置形参func
# def get_time(*args, **kwargs): # args = ('egon',) kwargs = {} # 定义装饰器内层函数，有可变长形参
# start = time.time() # 打印被装饰函数开始执行时间戳
# res = func(*args, **kwargs) # 最原始的login函数的内存地址() 直接调用 func('egon')
# end = time.time() # 打印被装饰函数结束执行时间戳
# print('func run time:%s'%(end-start)) # 打印时间差
# return res # 返回func函数执行结果返回值
# return get_time # 返回内层函数名
#
# # 有参数的被装饰函数
# login = outter(login) # outter(最原始的login函数的内存地址) # 先执行调用装饰器
# # 执行三步：1.定义内层函数，2.把index当位置实参传入装饰器，即外层函数局部名称空间中func= login 3.将返回的内层函数函数名赋值给新函数名
# res = login('egon') # 调用执行被装饰后的新函数，即执行装饰器内层函数，并传实参egon
# # # 一共五步：1.可变长形参接传入的位置实参egon，即args = egon，没有关键字实参kwargs为空字典{}
# # 2.赋值开始时间戳 3.执行login（此时func已经等于login，在上层局部名称空间找到的）：
# # 在本层局部名称空间找到args = egon，停三秒 打印拼接字符串 返回字符串login并赋值给res1
# # # 3. 赋值结束时间戳 4. 打印时间差 5. 返回res1，即返回login字符串
# print(res) # 6. 打印字符串login 结束
''''''
"""
语法糖在书写的时候应该与被装饰对象紧紧挨着
两者之间不要有空格
"""
# # 下面这个装饰器已经在上面叙述了执行过程，不再赘述，主要将装饰器语法糖
# import time
# def outter(func): # func = 最原始的index函数的内存地址
# def get_time(*args, **kwargs):
# start = time.time()
# res = func(*args, **kwargs) # 最原始的login函数的内存地址() 直接调用 func('egon')
# end = time.time()
# print('func run time:%s'%(end-start))
# return res
# return get_time
# # login = outter(login) # outter(最原始的login函数的内存地址)
# # index = outter(index)
# # home = outter(home)
'''
语法糖的用法以及含义
作用就是 把 原始被装修函数的函数名 当作参数 传值给装饰器函数
然后将装饰器外层函数执行结果的返回值（内层函数函数名）当作返回值返回 并赋值给 新函数名（与原函数名一致）
如下语法糖使用：就是将index函数名当作参数传递给outter函数，并将返回结果赋值给新的index 等同与 index = outter(index)
装饰器语法糖需要跟被装饰函数紧紧挨在一起，中间不能空行 ！
'''
# @outter # index = outter(index) outter(最原始的index的函数的内存地址)
# def index():
# time.sleep(3)
# print('澳门最大线上赌场开业啦 性感tank在线发牌!')
# return 'index'
# # res1 = index()
'''
装饰器模板如下
'''
# def outter(func):
# def inner(*args,**kwargs):
# print('执行被装饰函数之前 你可以做的操作')
# res = func(*args,**kwargs)
# print('执行被装饰函数之后 你可以做的操作')
# return res
# return inner
"""
认证装饰器 需求：
执行函数index之前必须先输入用户名和密码 正确之后才能执行index
否则提示用户输入错误 结束程序
"""
# import time # 导入时间模块
# user_dic = {'is_login':None} # 定义一个空字典，记录登陆状态
#
# def index(name): # 定义index函数
# time.sleep(1) # 停1秒
# print('%s is dsb'%name) # 打印字符串
# return 666 # 返回666
#
# def home(): # 定义index函数
# time.sleep(1) # 停1秒
# print('home') # 打印字符串
# return 999 # 返回666
#
# def login_auth(func): # 定义装饰器外层函数，有位置形参func
# # func = index # 执行语法糖 传参调用装饰器时才会发生这个，定义新函数名（与原函数名一致）为 装饰器的返回值
# # #执行语法糖 或者 将原函数名当作参数传递时，会在外层函数的局部名称空间中定义func等于原函数，这一步容易被忽略
# def inner(*args,**kwargs): # 定义内层函数
# if user_dic['is_login']: # 判断原函数中记录登陆状态的字典中key的value是否为True
# res = func(*args, **kwargs) # 如果为True就是登陆了，则执行变量函数
# return res # 并且返回执行变量函数的执行结果
# else: # 否则输入用户名密码 登陆
# username = input('please input your username>>>:').strip()
# password = input('please input your password>>>:').strip()
# if username == '123' and password == '123': # 如果用户名密码为123，这里写死了
# user_dic['is_login'] = True # 如果用户名密码正确都是123，则修改原函数登陆状态
# res = func(*args,**kwargs) # 执行变量函数 并且返回执行变量函数的执行结果赋值res
# return res # 打印res，打印变量函数的执行结果
# else:
# print('username or password error') # 如果密码不一致，打印密码用户名错了
# return inner # 定义内层函数之后，返回内层函数函数名
# index = login_auth(index) # 执行装饰器 调用装饰器，定义新函数名（与原函数名一致）为 装饰器的返回值
# index('egon') # 执行新函数 新函数名加括号传值
# # index('egon')
# print(index) # 打印这个新函数名，发现就是装饰器内层函数的内存地址
#
# home = login_auth(home) # 执行装饰器 调用装饰器，定义新函数名（与原函数名一致）为 装饰器的返回值
# home() # 执行新函数 新函数名加括号
# # home()
# print(home) # 打印这个新函数名，发现就是装饰器内层函数的内存地址
#
# @login_auth # 用语法糖装饰执行原函数
# def index(name):
# time.sleep(1)
# print('%s is dsb'%name)
# return 666
#
# @login_auth # 用语法糖装饰执行原函数
# def home():
# time.sleep(1)
# print('home')
# return 999
'''
三层装饰器嵌套使用，解决问题;
给内层函数，新功能函数需要额外参数的解决方案
'''
# import time # 导入时间模块
# user_dic = {'is_login':None}
# def outter(func): # func = 最原始的login函数的内存地址
# def get_time(*args, **kwargs): # args = ('egon',) kwargs = {}
# start = time.time()
# res = func(*args, **kwargs) # 最原始的login函数的内存地址() 直接调用 func('egon')
# end = time.time()
# print('func run time:%s'%(end-start))
# return res
# return get_time
#
# def login_auth2(data_source,x,t):
# # data_source = 'file'
# def login_auth(func):
# # func = index
# def inner(*args,**kwargs): # 这里的参数是跟被装饰函数的参数一一对应
# if user_dic['is_login']:
# res = func(*args, **kwargs)
# return res
# else:
# if data_source == 'file':
# username = input('please input your username>>>:').strip()
# password = input('please input your password>>>:').strip()
# if username == '123' and password == '123':
# user_dic['is_login'] = True
# res = func(*args,**kwargs)
# return res
# else:
# print('username or password error')
# elif data_source == 'MySQL':
# print('from MySQL')
# elif data_source == 'ldap':
# print('ldap')
# else:
# print('暂无该数据来源')
# return inner
# return login_auth
#
# # res = login_auth2('MySQL')
# @login_auth2('file',1,2) # index = login_auth(get_time) index = inner函数的内存地址
# # @login_auth
# @outter # get_time = outter(index) index是最原始的index
# def index():
# time.sleep(1)
# print('index')
# return 'index'
# index()
#
# 装饰器在装饰的时候 顺序从下往上 上层装饰下层，下层被上层装饰
# 装饰器在执行的时候 顺序从上往下 先执行最上层，返回下层函数名，再执行，再返回更下层函数名，最后赋值给新函数名，调用执行
'''
传参调用执行三层装饰器，如下：
@三层装饰器外层函数名 或者 三层装饰器外层函数名（） 这一步执行如下，一共包含三步
装饰器外层函数， 1.传参后实参赋值形参，多少个参数都可以，装饰器每部需要额外的变量参数
内层函数所需额外参数 = 外层函数传进来的实参
2.定义装饰器中层函数，3.并且返回中层函数的函数名
@三层装饰器中层函数 或者 新函数名 = 装饰器中层函数（原函数名）
装饰器中层函数， 1.传参后实参赋值形参，这一步只是将 原函数名 赋值给 变量函数名，变量函数名 = 原函数名
只有一个赋值，没有多余的参数
2.定义装饰器内层函数
3.并且返回中层函数的函数名
4.将内层函数名作为返回值，返回值赋值给新函数名 即 新函数名 = 内层函数名，后面就跟两层装饰器执行步骤一致
调用新函数，并传实参，即调用三层装饰器的内层函数，并传参：
1.将调用新函数传进来的实参，位置实参和关键字实参 赋值给 args 和 kwargs
位置实参 = args 关键字实参 = kwargs
1.执行新功能，需要参数会在内层函数局部名称空间找，没有，然后去中层函数局部名称空间找，也没有
去外层函数局部名称空间找到了，内层函数所需额外参数 = 外层函数传进来的实参
2.执行变量函数，内层函数局部名称空间没有找到变量函数，去中层函数局部名称空间找到了
变量函数名 = 原函数名，
原函数需要参数，会在内层函数局部名称空间找，找到了，位置实参 = args 关键字实参 = kwargs
即执行原函数
'''
''''''
"""
用户查看被装饰函数的函数名的时候查看到的就是被装饰函数本身
用户查看被装饰函数的注释的时候查看到的就是被装饰函数的注释
"""
# from functools import wraps
# def outter(func):
# @wraps(func) # 装饰器修复技术
# def inner(*args,**kwargs):
# """
# 我是inner函数
# :param args:
# :param kwargs:
# :return:
# """
# print('执行被装饰函数之前 你可以执行的操作')
# res = func(*args,**kwargs)
# print('执行被装饰函数之后 你可以执行的操作')
# return res
# return inner
#
# @outter # index = outter(最原始的index内存地址)
# def index():
# """
# 这是index函数
# :return:
# """
# pass
#
# print(index)
# print(help(index)) # 查看函数的注释 index是函数名，这个是查看index的注释，修改函数名可以查看别的函数的注释
# print(index.__name__) # 查看函数名字符串形式 打印函数名 字符串
# index()
#
# from functools import wraps
# def outter(func):
# @wraps(func) # 装饰器修复技术
# def inner(*args,**kwargs):
# pass
# return what # 没有定义 所以红
# return inner
# # 装饰器修复技术 两个作用
'''
用户查看被装饰函数的函数名的时候查看到的就是被装饰函数本身
用户查看被装饰函数的注释的时候查看到的就是被装饰函数的注释
'''
'''
多层装饰器经典案例
'''
# def outter1(func1):
# print('加载了outter1')
# def wrapper1(*args,**kwargs):
# print('执行了wrapper1')
# res1=func1(*args,**kwargs)
# return res1
# return wrapper1
# def outter2(func2):
# print('加载了outter2')
# def wrapper2(*args,**kwargs):
# print('执行了wrapper2')
# res2=func2(*args,**kwargs)
# return res2
# return wrapper2
# def outter3(func3):
# print('加载了outter3')
# def wrapper3(*args,**kwargs):
# print('执行了wrapper3')
# res3=func3(*args,**kwargs)
# return res3
# # return wrapper3
# @outter1
# @outter2
# @outter3
# def index():
# print('from index')
# index()
'''
解析：
'''
# @outter1
# index = outter1(wapper2)
'''
第三步，从下往上执行，加载了outter1，将装饰器2的内层函数传入装饰器1，返回装饰器1内层函数
'''
# @outter2 # wrapper2 = outter2(wrapper3)
'''
第二步，从下往上执行，加载了outter2，将装饰器3的内层函数传入装饰器2，返回装饰器2内层函数
'''
# @outter3 # wrapper3 = outter3(最原始的index函数内存地址)
'''
第一步，从下往上执行，加载了outter3，将原函数名index传入装饰器3，返回装饰器3内层函数
'''
"""
加载了outter3，第一步，从下往上执行，加载了outter3，将原函数名index传入装饰器3，返回装饰器3内层函数
加载了outter2，第二步，从下往上执行，加载了outter2，将装饰器3的内层函数传入装饰器2，返回装饰器2内层函数
加载了outter1，第三步，从下往上执行，加载了outter1，将装饰器2的内层函数传入装饰器1，返回装饰器1内层函数
执行了wrapper1，第四步，返回的装饰器1的内层函数赋值给了新函数名，被执行，
即执行装饰器1内层函数，执行打印了wrapper1，继续执行，因为是调用装饰器1时，
传入的参数是装饰器2的内层函数名，装饰器1中的内层函数中的 func = 装饰器2的内层函数，即执行装饰器2的内层函数
执行了wrapper2，第五步，执行装饰器2的内层函数，执行打印了wrapper2，继续执行，因为是调用装饰器2时，
传入的参数是装饰器3的内层函数名，装饰器2中的内层函数中的 func = 装饰器3的内层函数，即执行装饰器3的内层函数
执行了wrapper3 第五步，执行装饰器3的内层函数，执行打印了wrapper3，继续执行，因为是调用装饰器3时，
传入的参数是原函数函数名index，装饰器3中的内层函数中的 func = 原函数函数名index，即执行原函数index
from index
新函数执行完毕
"""
