一. 装饰器
装饰器：可以拆解来看，器本质就是函数，装饰就是修饰的意思，所以装饰器的功能就是为其他函数添加附加功能。
装饰器的两个原则：
1. 不修改被修饰函数的源代码
2. 不修改被修饰函数的调用方式
实现装饰器的知识储备： 装饰器 = 高阶函数 + 函数嵌套 + 闭包
高阶函数
高阶函数的定义：
1. 函数接收的参数是一个函数名
2. 函数的返回值是一个函数名
3.满足上述条件任意一个，都可以称之为高阶函数
import time
# 示例1： 函数接收的参数是一个函数名
# def foo():
# print("Hello")
#
# def test(func):
# print(func)
# func()
#
# test(foo) # 示例2：函数test接收的参数是一个函数名foo,可以直接为foo函数增加一个功能
# 需求：想统计foo运行的时间，结果这个高阶函数修改了函数的源代码 # def foo():
# time.sleep(2)
# print("Hello")
#
# def test(func):
# print(func)
# start_time = time.time()
# func()
# stop_time = time.time()
# print('函数的运行时间是:%s '%(stop_time-start_time)) # 统计的是func()的运行时间，即foo的运行时间
#
# test(foo) # 示例3：函数的返回值是一个函数名 def foo():
print("from the foo")
def test(func):
return func # 实现了装饰器的不改变函数的调用方式这个功能
foo = test(foo)
foo() # 示例4： 示例2+示例3就能实现一个半完整的装饰器
def foo():
time.sleep(3)
print('来自foo') # 不修改foo源代码
# 不修改foo调用方式
# 没有修改被修饰函数的源代码，也没有修改被修饰函数的调用方式，但是也没有为被修饰函数添加新功能
def timer(func):
start_time = time.time()
func()
stop_time = time.time()
print('函数的运行时间是:%s '%(stop_time-start_time)) # 统计的是func()的运行时间，即foo的运行时间
return func
foo = timer(foo) # timer函数的返回值是foo，在把返回值又赋值给了foo，得到一个内存地址
foo() # 有了内存地址，直接加个()就可以运行。
# 结果
# 来自foo
# 函数的运行时间是:3.001082420349121
# 来自foo # 上面说的是半完整的装饰器，是因为这里多运行了一次foo，肯定不行那，这就导致这个装饰器就不合格了
函数嵌套
# 函数嵌套及作用域
# father()函数里嵌套了一层son()函数，son()函数里又嵌套了一层grandson()函数 def father(name):
print('from father %s' %name) # name变量的作用域，是传进来的DDD
def son(): # 函数也是变量
name='abc'
print('我的爸爸是%s' %name) # 作用域是son函数自己定义的name变量
def grandson():
print('我的爷爷是%s' % name) # grandson函数没有自己的name变量，需要往上一级一级找，找到了son函数，就是abc
# 同调用son的道理一样，需要通过father调用son，通过son函数再调用grandson函数
grandson()
# 如果要调用son函数，不能跑到father的外面去调用，会报错；只能通过调用father来调用son函数
# 此处是调用son函数
son()
father('DDD')
son('abcx') # 报错 # son函数定义在father里，所以只能通过father调用son函数
闭包
上面理解了函数的层级嵌套，就很好理解闭包的概念。嵌套的函数换个名称叫闭包
包:就像一个盒子套着一个盒子，一层层往外套，每一次都是一个包
闭：就是封装，封装变量。每个包都有被封装的变量。
下面画图解释
闭包如何找变量？
还是先从自己的闭包里开始找变量，自己没有在往上一层包里找变量，如果还没有，可以一直往外找，可以一直找到最外层
装饰器基本实现
首先，
# 搭个装饰器的架子，满足高阶函数，满足函数嵌套
import time
def timer(func):
def wrapper():
# print(func) # 嵌套函数也可以获取传入的参数，传入的参数也是个函数，作用域在起作用 这是个内存地址
func() # 有了内存地址，加（）就可以执行func函数
return wrapper def test():
time.sleep(2)
print("test函数运行完毕") 其次，
有个需求：不修改test函数的原代码，也不修改test函数的调用方式，而且为test函数增加一个统计运行时间的功能 实现该需求的流程分析及代码运行过程： # 流程分析：
# 1. 把test函数传给timer,直接返回的是wrapper的地址，而没有运行wrapper函数
res = timer(test)
# 2. 上面返回的是wrapper函数的内存地址，所以就可以直接加()执行wrapper函数
res() # 执行的是wrapper函数
# 3. 再看wrapper函数做了什么？
# wrapper 函数运行的是func函数，而func函数就是传入的test()函数，所以执行wrapper就可以执行test()函数
# 所以，这个时候就可以添加代码来统计test函数的运行时间了。 至此，
# 上面的代码就演化成为：
def timer(func):
def wrapper():
start_time = time.time()
func()
stop_time = time.time()
print("test函数的运行时长是： %s" % (stop_time - start_time))
return wrapper def test():
time.sleep(2)
print("test函数运行完毕") res = timer(test)
res()
# 运行结果
test函数运行完毕
test函数的运行时长是： 2.000473976135254 但是，这里有 个问题，需求是不修改test函数的调研方式，test函数的调用方式应该是test(),而这里的调用方式是res() 所以，解决修改了test函数调用方式这个问题的方法：
# 将timer(test)的值赋给变量test
test = timer(test)
# 然后再test()调用，这样就达到了没有修改test函数调用方式的目的
test() #到这里，一个装饰器的架子和调用模型就初步成型了，但是还需要赋值给test变量这一步操作 # 所以，最后，
python为了实现这个不修改test函数调用方式，也省略赋值这行代码，而产生了一个装饰器的概念 # 上面的代码就进化为：
# 装饰器
def timer(func):
def wrapper():
start_time = time.time()
func()
stop_time = time.time()
print("test函数的运行时长是： %s" % (stop_time - start_time))
return wrapper @timer #在test函数的顶头加上 @timmer来修饰test函数， 就相当于 test=timmer(test) 这个赋值动作
def test():
time.sleep(2)
print("test函数运行完毕") # 有了装饰器，就可以直接调用test函数
test() # 终于啊，老天爷啊，历经千辛万苦，终于完美的满足了最开始的需求
为闭包加上返回值
还是接上面的基本装饰器来说
def timer(func):
def wrapper():
start_time = time.time()
func()
stop_time = time.time()
print("test函数的运行时长是： %s" % (stop_time - start_time))
return wrapper # 需求：给test函数加一个返回值: “test函数返回好消息了”
@timer
def test():
time.sleep(2)
print("test函数运行完毕")
return "test函数返回好消息了" res=test()
print(res)
#结果
test函数运行完毕
test函数的运行时长是： 2.000929117202759
None 返回None了 # 为什么会这样呢？分析如下：
# 1. 运行test函数，因为有装饰器，实际上运行的是wrapper这个闭包，而wrapper函数却没有返回值，所以返回的是None，那么给wrapper函数加个返回值呢？
代码如下：
def timer(func):
def wrapper():
start_time = time.time()
func()
stop_time = time.time()
print("test函数的运行时长是： %s" % (stop_time - start_time))
return 123 # 给wrapper函数加的返回值
return wrapper @timer
def test():
time.sleep(2)
print("test函数运行完毕")
return "test函数返回好消息了" res = test()
print(res)
# 结果
test函数运行完毕
test函数的运行时长是： 2.0010011196136475
123 # 返回的是123， # 上面运行返回的是123，而我们的需求是要返回“test函数返回好消息了”
# 接着开，wrapper函数运行的是func函数，而func函数就是传入的test函数，所以把 func（）赋值给变量 res呢？ # 代码如下：
def timer(func):
def wrapper():
start_time = time.time()
res = func() # 赋值给res
stop_time = time.time()
print("test函数的运行时长是： %s" % (stop_time - start_time))
return res # 返回res
return wrapper @timer
def test():
time.sleep(2)
print("test函数运行完毕")
return "test函数返回好消息了" res = test()
print(res) # 结果
test函数运行完毕
test函数的运行时长是： 2.0009818077087402
test函数返回好消息了 # 至此，给装饰器加上返回值就实现了。 # 但是还有个问题，如果直接调用test呢？
test()
# 结果如下，为什么？暂时还不明白
test函数运行完毕
test函数的运行时长是： 2.0001914501190186
为闭包加上参数
# 需求：给test传入参数 import time
def timmer(func): #func=test1
def wrapper():
start_time=time.time()
res=func()
stop_time = time.time()
print('运行时间是%s' %(stop_time-start_time))
return res
return wrapper @timmer #test=timmer(test)
def test(name,age):
time.sleep(3)
print('test函数运行完毕,名字是【%s】 年龄是【%s】' %(name,age))
return '这是test的返回值' res=test('lixiao',age=18) #就是在运行wrapper
print(res)
#结果：
报错 为什么呢？
因为运行test就是在运行wrapper，而test传入了参数，wrapper里却没有接受参数，所以就报错了。那怎么改呢？
1. 礼尚往来，你给我得接着呀，所有wrapper需要有参数接受test传来的值。
2. wrapper 接受到了传来的值，wrapper函数体内，运行的res=func()实际上就是test（），所以，wrapper接受的参数也要传给func()才行。 import time
def timmer(func): #func=test1
def wrapper(*args,**kwargs):
start_time=time.time()
res=func(*args,**kwargs)
stop_time = time.time()
print('运行时间是%s' %(stop_time-start_time))
return res
return wrapper @timmer #test=timmer(test)
def test(name,age):
time.sleep(3)
print('test函数运行完毕,名字是【%s】 年龄是【%s】' %(name,age))
return '这是test的返回值' #备注：
wrapper(*args,**kwargs)：表示的是可变长参数
# *args: 代表把所有的位置参数接成列表
# **kwargs: 代表可能用户传值的时候通过关键字传值，比如用户传的值是age =18, 或者{"age": 18}形式的， 就用**kwargs来接 # 所以，*args,**kwargs ：代表可变长参数，传多少参数，任意形式的都可以接受了 @timmer
def test1(name,age,gender):
time.sleep(1)
print('test1函数运行完毕,名字是【%s】 年龄是【%s】 性别【%s】' %(name,age,gender))
return '这是test的返回值' test1('alex', 18, gender='male')
闭包：补充解压序列 （很有用）
# 需求：有个很长的列表，拿出第一个和最后一个值 l = [1,2,4,5,6,123,34,1,6] 方式1：索引的方式
print(l[0])
print(l[-1]) 方式2：解压序列方式 l = [1,2,4,5,6,123,34,1,6] a, *_, c = l
print(a) #
print(*_) # 2 4 5 6 123 34 1
print(c) # # a 代表取第一个值
# * 代表所有的值，下划线_表示不要了,当然下划线可以有任意字符替换， 如 *b, *d都可以
# c 代表最后一个值了 # 需求：a =1, b=2， 交换a,b的值
a = 1
b = 2 a,b = b,a
print(a) #
print(b) #
函数闭包为函数加上认证功能
def auth_func(func):
def wrapper(*args, **kwargs):
username = input('用户名： ').strip()
password = input("密码： ").strip()
if username =="sb" and password == "": # 用户是写死了
res = func(*args, **kwargs)
return res # 切记要有返回值那
else:
print("用户名或密码错误")
return wrapper @auth_func
def index():
print("欢迎来到京东") @auth_func
def home():
print("欢迎回家") @auth_func
def shopping_box(name):
print("%s的购物车里有%s,%s,%s" % (name, '娃娃', '电脑','手机')) index()
home()
shopping_box('韩梅梅')
函数闭包模拟session
上面为每个功能都加了验证功能，但是每次运行其他功能都需要重新登陆，这显然是不合理的，可以用session和cookie来解决，那怎么模拟解决这个问题呢？
还有一个问题，就是用户是写死的，而实战中，我们的用户不可能只有一个，而且写死，所以这里也是需要改造的。
# 用户一般都是存在数据库里，这里为了方便模拟，就把用户存储在一个列表里
user_list = [
{'name': 'sb', 'passwd': ''},
{'name': 'lhf', 'passwd': ''},
{'name': 'wpq', 'passwd': ''},
{'name': 'yh', 'passwd': ''},
] current_dic = {'username':None, 'login':False} # 模式当前登录状态是FALSE，未登录 def auth_func(func):
def wrapper(*args, **kwargs):
# 在运行wrapper之前, 先判断是否有用户登录
if current_dic['username'] and current_dic['login']: # 这个代表的是由用户登录且是true，然后直接运行func()
res= func(*args, **kwargs)
return res
# 如果上面的判断不为True,则输入用户名和密码
username = input("用户名：")
password = input("密 码：")
# 输完后应该从user_list里提取信息
for user in user_list:
# 然后判断输入的用户名和密码与user_list里的是否一致
if username == user['name'] and password == user['passwd']:
# 如果有一致的, 要把当前状态改一下
current_dic['username'] = username # 记录状态的字典里用户名 = 用户输入的用户名
current_dic['login'] = True # 登陆状态改为true
res = func(*args, **kwargs)
return res # 切记要有返回值那
# 如果遍历了一遍,都没有匹配的
else:
print("用户名或密码错误")
return wrapper @auth_func
def index():
print("欢迎来到京东") @auth_func
def home():
print("欢迎回家") @auth_func
def shopping_box(name):
print("%s的购物车里有%s,%s,%s" % (name, '娃娃', '电脑','手机')) index()
home()
shopping_box('韩梅梅')
函数闭包带参数装饰器-----带参数的装饰器
user_list=[
{'name':'alex','passwd':''},
{'name':'linhaifeng','passwd':''},
{'name':'wupeiqi','passwd':''},
{'name':'yuanhao','passwd':''},
]
current_dic={'username':None,'login':False} def auth(auth_type='filedb'):
def auth_func(func):
def wrapper(*args,**kwargs):
print('认证类型是',auth_type)
if auth_type == 'filedb':
if current_dic['username'] and current_dic['login']:
res = func(*args, **kwargs)
return res
username=input('用户名：').strip()
passwd=input('密码：').strip()
for user_dic in user_list:
if username == user_dic['name'] and passwd == user_dic['passwd']:
current_dic['username']=username
current_dic['login']=True
res = func(*args, **kwargs)
return res
else:
print('用户名或者密码错误')
elif auth_type == 'ldap':
print('鬼才特么会玩')
res = func(*args, **kwargs)
return res
else:
print('鬼才知道你用的什么认证方式')
res = func(*args, **kwargs)
return res return wrapper
return auth_func @auth(auth_type='filedb') #auth_func=auth(auth_type='filedb')-->@auth_func 附加了一个auth_type --->index=auth_func(index)
def index():
print('欢迎来到京东主页') @auth(auth_type='ldap')
def home(name):
print('欢迎回家%s' %name)
#
@auth(auth_type='sssssss')
def shopping_car(name):
print('%s的购物车里有［%s,%s,%s］' %(name,'奶茶','妹妹','娃娃')) # print('before-->',current_dic)
index()
# print('after--->',current_dic)
home('产品经理')
shopping_car('产品经理')