''''''
"""
闭包函数
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
新函数执行完毕
"""