【摘要】 Python装饰器的学习笔记
1. 初识装饰器
接下来，我们通过一个例子来为大家讲解这个装饰器：
需求介绍：你现在xx科技有限公司的开发部分任职，领导给你一个业务需求让你完成：让你写代码测试小明同学写的函数的执行效率。
def effectiveness():
print("华为云欢迎你")
版本1：
需求分析：你要想测试此函数的执行效率，你应该怎么做？应该在此函数执行前记录一个时间， 执行完毕之后记录一个时间，这个时间差就是具体此函数的执行效率。那么执行时间如何获取呢？ 可以利用time模块，有一个time.time()功能。
import time
print(time.time())
#返回 1575997129.8832688
此方法返回的是格林尼治时间，是此时此刻距离1970年1月1日0点0分0秒的时间秒数。也叫时间戳，他是一直变化的。所以要是计算shopping_car的执行效率就是在执行前后计算这个时间戳的时间，然后求差值即可。
def effectiveness():
time.sleep(2)
print("华为云欢迎你")
start_time = time.time()
effectiveness()
end_time = time.time()
print("此函数的执行效率为:" + str(end_time-start_time))
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1575998021.69584
华为云欢迎你
此函数的执行效率为:2.0020952224731445
Process finished with exit code 0
版本1分析：你现在已经完成了这个需求，但是有什么问题没有？ 虽然你只写了四行代码，但是你完成的是一个测试其他函数的执行效率的功能，如果让你测试一下，小张，小李，小刘的函数效率呢？ 你是不是全得复制：
重复代码太多了，所以要想解决重复代码的问题，怎么做？我们是不是学过函数，函数就是以功能为导向，减少重复代码，好我们继续整改。
版本2：
def effectiveness():
time.sleep(1)
print("华为云欢迎你")
def calculate_func():
start_time = time.time()
effectiveness()
end_time = time.time()
return end_time - start_time
print("此函数的执行效率为:" + str(calculate_func()))
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1575998266.1427834
华为云欢迎你
此函数的执行效率为:1.0010716915130615
Process finished with exit code 0
但是你这样写也是有问题的，你虽然将测试功能的代码封装成了一个函数，但是这样，你只能测试小明同学的的函数index，你要是测试其他同事的函数呢？你怎么做？
你要是像上面那么做，每次测试其他同事的代码还需要手动改，这样是不是太low了？所以如何变成动态测试其他函数？我们是不是学过函数的传参？能否将被装饰函数的函数名作为函数的参数传递进去呢？
版本3：
def effectiveness():
time.sleep(1)
print("华为云欢迎你")
def diff_file():
time.sleep(2.5)
print("this is google")
def calculate_func(func):
start_time = time.time()
func()
end_time = time.time()
return end_time - start_time
print("effectiveness函数的执行效率为:" + str(calculate_func(effectiveness)))
print("diff_file函数的执行效率为:" + str(calculate_func(diff_file)))
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1575998867.014351
华为云欢迎你
effectiveness函数的执行效率为:1.0010769367218018
this is google
diff_file函数的执行效率为:2.502596139907837
Process finished with exit code 0
这样我将函数effectiveness的函数名作为参数传递给calculate_func函数，然后在calculate_func函数里面执行effectiveness函数，这样就变成动态传参了。好，你们现在将版本3的代码快速练一遍。 大家练习完了之后，发现有什么问题么？ 对比着开放封闭原则说： 首先，effectiveness函数除了完成了自己之前的功能，还增加了一个测试执行效率的功能，对不？所以也符合开放原则。 其次，effectiveness函数源码改变了么？没有，但是执行方式改变了，所以不符合封闭原则。 原来如何执行？ effectiveness() 现在如何执行？ calculate_func(effectiveness),这样会造成什么问题？ 假如effectiveness在你的项目中被100处调用，那么这相应的100处调用我都得改成calculate_func(effectiveness)。 非常麻烦，也不符合开放封闭原则。
版本4：实现真正的开放封闭原则：装饰器。
这个也很简单，就是我们昨天讲过的闭包，只要你把那个闭包的执行过程整清楚，那么这个你想不会都难。
你将上面的inner函数在套一层最外面的函数timer，然后将里面的inner函数名作为最外面的函数的返回值，这样简单的装饰器就写好了，一点新知识都没有加，这个如果不会就得多抄几遍，然后理解代码。
def diff_file():
time.sleep(2.5)
print("this is google")
def calculate_func(func):
def inner():
start_time = time.time()
func()
end_time = time.time()
print("函数的执行效率为:" + str(end_time - start_time))
return inner
ret_func = calculate_func(diff_file)
ret_func() # 等于调用了inner
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576000235.7557225
this is google
函数的执行效率为:2.5025622844696045
Process finished with exit code 0
我们分析一下，代码，代码执行到这一行：ret_func= calculate_func(diff_file) 先执行谁？看见一个等号先要执行等号右边， calculate_func(diff_file) 执行calculate_func函数将diff_file函数名传给了func形参。内层函数inner执行么？不执行，inner函数返回 给ret_func变量。所以我们执行ret_func() 就相当于执行inner闭包函数。 ret_func(),这样既测试效率又执行了原函数，有没有问题？当然有啦！！版本4你要解决原函数执行方式不改变的问题，怎么做？ 所以你可以把 ret_func换成 diff_file变量就完美了！ diff_file = calculate_func(diff_file) , diff_file()带着同学们将这个流程在执行一遍，特别要注意 函数外面的diff_file实际是inner函数的内存地址而不是diff_file函数。让学生们抄一遍，理解一下，这个calculate_func就是最简单版本装饰器，在不改变原diff_file函数的源码以及调用方式前提下，为其增加了额外的功能，测试执行效率。
2. 带返回值的装饰器
你现在这个代码，完成了最初版的装饰器，但是还是不够完善，因为你被装饰的函数index可能会有返回值，如果有返回值，你的装饰器也应该不影响，开放封闭原则嘛。但是你现在设置一下试试：
def diff_file():
time.sleep(2.5)
print("this is google")
return "姐姐"
def calculate_func(func):
def inner():
start_time = time.time()
func()
end_time = time.time()
print("函数的执行效率为:" + str(end_time - start_time))
return inner
ret_func = calculate_func(diff_file)
ret_data = ret_func() # 等于调用了inner
print(ret_data)
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576001398.9691799
this is google
函数的执行效率为:2.5025620460510254
None
Process finished with exit code 0
加上装饰器之后，他的返回值为None，为什么？因为你现在的ret_func不是函数名ret_func，这ret_func实际是inner函数名。所以ret_func() 等同于inner() 你的 '访问成功'返回值应该返回给谁？应该返回给ret_func，这样才做到开放封闭，实际返回给了谁？实际返回给了func，所以你要更改一下你的装饰器代码，让其返回给外面的ret_func函数名。 所以：你应该这么做：
def diff_file():
time.sleep(2.5)
print("this is google")
return "姐姐"
def calculate_func(func):
def inner():
start_time = time.time()
ret = func()
end_time = time.time()
print("函数的执行效率为:" + str(end_time - start_time))
return ret
return inner
ret_func = calculate_func(diff_file)
ret_data = ret_func() # 等于调用了inner
print(ret_data)
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576001170.6579535
this is google
函数的执行效率为:2.50258469581604
姐姐
Process finished with exit code 0
借助于内层函数inner，你将func的返回值，返回给了inner函数的调用者也就是函数外面的ret_func，这样就实现了开放封闭原则，ret_func返回值，确实返回给了'ret_data'。
3 被装饰函数带参数的装饰器
到目前为止，你的被装饰函数还是没有传参呢？按照我们的开放封闭原则，加不加装饰器都不能影响你被装饰函数的使用。所以我们看一下。
def diff_file(name):
time.sleep(2.5)
print(f"this is google what's your {name} ")
return "姐姐"
def calculate_func(func):
def inner():
start_time = time.time()
ret = func()
end_time = time.time()
print("函数的执行效率为:" + str(end_time - start_time))
return ret
return inner
ret_func = calculate_func(diff_file)
ret_data = ret_func("李白") # 等于调用了inner
print(ret_data)
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576002133.1686425
Traceback (most recent call last):
File "/home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py", line 30, in <module>
ret_data = ret_func("李白") # 等于调用了inner
TypeError: inner() takes 0 positional arguments but 1 was given
Process finished with exit code 1
上面那么做，显然报错了，为什么？ 你的ret_func这个变量是谁？是inner，ret_func('李白')实际是inner('李白')但是你的'李白'这个实参应该传给谁？ 应该传给diff_file函数，实际传给了谁？实际传给了inner，所以我们要通过更改装饰器的代码，让其将实参'李白'传给diff_file.
def diff_file(name):
time.sleep(2.5)
print(f"this is google what's your {name} ")
return "姐姐"
def calculate_func(func):
def inner(name):
start_time = time.time()
ret = func(name)
end_time = time.time()
print("函数的执行效率为:" + str(end_time - start_time))
return ret
return inner
ret_func = calculate_func(diff_file)
ret_data = ret_func("李白") # 等于调用了inner
print(ret_data)
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576002491.6821125
this is google what's your 李白
函数的执行效率为:2.502556562423706
姐姐
Process finished with exit code 0
这样你就实现了，还有一个小小的问题，现在被装饰函数的形参只是有一个形参，如果要是多个怎么办？有人说多少个我就写多少个不就行了，那不行呀，你这个装饰器可以装饰N多个不同的函数，这些函数的参数是不统一的。所以你要有一种可以接受不定数参数的形参接受他们。这样，你就要想到*args，**kwargs。
def effectiveness(name, age):
time.sleep(1)
print(f"华为云欢迎你{name},妹妹的年宁{age}")
return "妹妹"
def diff_file(name):
time.sleep(2.5)
print(f"this is google what's your {name} ")
return "姐姐"
def calculate_func(func):
def inner(*args, **kwargs):
start_time = time.time()
ret = func(*args, **kwargs)
end_time = time.time()
print("函数的执行效率为:" + str(end_time - start_time))
return ret
return inner
ret_func = calculate_func(diff_file)
ret_data = ret_func("李白") # 等于调用了inner
print(ret_data)
ret_func1 = calculate_func(effectiveness)
ret_data1 = ret_func1("妞妞", 16) # 等于调用了inner
print(ret_data1)
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576002922.719054
this is google what's your 李白
函数的执行效率为:2.5026206970214844
姐姐
华为云欢迎你妞妞,妹妹的年宁16
函数的执行效率为:1.001091718673706
妹妹
Process finished with exit code 0
这样利用*的打散与聚合的原理，将这些实参通过inner函数的中间完美的传递到给了相应的形参。
4. 标准版装饰器
代码优化：语法糖
根据我的学习，我们知道了，如果想要各给一个函数加一个装饰器应该是这样：
如果你想给diff_file加上装饰器，每次执行diff_file之前你要写上一句：ret_func = calculate_func(diff_func)这样你在执行ret_func函数 ret_data('妞妞',16) 才是真生的添加了额外的功能。但是每次写这一句也是很麻烦。所以，Python给我们提供了一个简化机制，用一个很简单的符号去代替这一句话。
def calculate_func(func):
def inner(*args, **kwargs):
start_time = time.time()
ret = func(*args, **kwargs)
end_time = time.time()
print("函数的执行效率为:" + str(end_time - start_time))
return ret
return inner
@calculate_func
def effectiveness(name, age):
time.sleep(1)
print(f"华为云欢迎你{name},妹妹的年宁{age}")
return "妹妹"
@calculate_func
def diff_file(name):
time.sleep(2.5)
print(f"this is google what's your {name} ")
return "姐姐"
# @calculate_func <====> ret_func = calculate_func(diff_file)
ret_data = diff_file("李白") # 等于调用了inner
print(ret_data)
# @calculate_func <====> ret_func1 = calculate_func(effectiveness)
ret_data1 = effectiveness("妞妞", 16) # 等于调用了inner
print(ret_data1)
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576003516.4458728
this is google what's your 李白
函数的执行效率为:2.5025768280029297
姐姐
华为云欢迎你妞妞,妹妹的年宁16
函数的执行效率为:1.0010745525360107
妹妹
Process finished with exit code 0
你看此时我调整了一下位置，你要是不把装饰器放在上面，calculate_func是找不到的。diff_file函数如果想要加上装饰器那么你就在diff_file函数上面加上@calculate_func，就等同于那句话 ret_func = calculate_func(diff_file)。这么做没有什么特殊意义，就是让其更简单化，比如你在影视片中见过野战军的作战时由于不方便说话，用一些简单的手势代表一些话语，就是这个意思。
至此标准版的装饰器就是这个样子：
def wrapper(func):
def inner(*args, **kwargs):
"""装饰前增加的功能代码"""
ret = func(*args, **kwargs)
"""装饰后增加的功能代码"""
return ret
return inner
这个就是标准的装饰器，完全符合代码开放封闭原则。这几行代码一定要背过，会用。
此时我们要利用这个装饰器完成一个需求：简单版模拟博客园登录。 此时带着学生们看一下博客园，说一下需求： 博客园登陆之后有几个页面，diary，comment，home，如果我要访问这几个页面，必须验证我是否已登录。 如果已经成功登录，那么这几个页面我都可以无阻力访问。如果没有登录，任何一个页面都不可以访问，我必须先登录，登录成功之后，才可以访问这个页面。我们用成功执行函数模拟作为成功访问这个页面，现在写三个函数，写一个装饰器，实现上述功能。
flags_login = True
def authenticate(func):
"""
这是一个装饰器函数
:return:
"""
def inner(*args, **kwargs):
"""执行代码前增加功能"""
global flags_login
if flags_login:
username = input("请输入用户名：")
password = input("请输入秘密：")
if username == "yuchuanduan" and password == "123456":
ret = func(*args, **kwargs)
flags_login = False
return ret
else:
ret = func(*args, **kwargs)
"""执行代码后增加功能"""
return ret
return inner
@authenticate
def diary():
print("欢迎来到diary页面!")
@authenticate
def comment():
print("欢迎来到comment页面？")
@authenticate
def home():
print("欢迎来到home页面")
diary()
comment()
home()
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576006578.762892
请输入用户名：yuchuanduan
请输入秘密：123456
欢迎来到diary页面!
欢迎来到comment页面？
欢迎来到home页面
Process finished with exit code 0
login_statues = {
"username": None,
"status": True
}
def authenticate(func):
"""
这是一个装饰器函数
:return:
"""
def inner(*args, **kwargs):
"""执行代码前增加功能"""
if login_statues["status"]:
login_statues["username"] = input("请输入用户名：")
password = input("请输入秘密：")
if login_statues["username"] == "yuchuanduan" and password == "123456":
ret = func(*args, **kwargs)
login_statues["status"] = False
return ret
else:
ret = func(*args, **kwargs)
"""执行代码后增加功能"""
return ret
return inner
@authenticate
def diary():
print("欢迎来到diary页面!")
@authenticate
def comment():
print("欢迎来到comment页面？")
@authenticate
def home():
print("欢迎来到home页面")
diary()
comment()
home()
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576006823.0322616
请输入用户名：yuchuanduan
请输入秘密：123456
欢迎来到diary页面!
欢迎来到comment页面？
欢迎来到home页面
Process finished with exit code 0
5. 带参数的装饰器
我们看，装饰器其实就是一个闭包函数，再说简单点就是两层的函数。那么是函数，就应该具有函数传参功能。
login_statues = {
"username": None,
"status": True
}
def authenticate(func):
"""
这是一个装饰器函数
:return:
"""
def inner(*args, **kwargs):
"""执行代码前增加功能"""
if login_statues["status"]:
login_statues["username"] = input("请输入用户名：")
password = input("请输入秘密：")
if login_statues["username"] == "yuchuanduan" and password == "123456":
ret = func(*args, **kwargs)
login_statues["status"] = False
return ret
else:
ret = func(*args, **kwargs)
"""执行代码后增加功能"""
return ret
return inner
你看我上面的装饰器，不要打开，他可以不可在套一层：
def authenticate(my_args):
def authenticate1(func):
"""
这是一个装饰器函数
:return:
"""
def inner(*args, **kwargs):
"""执行代码前增加功能"""
if login_statues["status"]:
login_statues["username"] = input("请输入用户名：").strip()
password = input("请输入秘密：").strip()
if login_statues["username"] == "yuchuanduan" and password == "123456":
ret = func(*args, **kwargs)
login_statues["status"] = False
return ret
else:
ret = func(*args, **kwargs)
"""执行代码后增加功能"""
return ret
return inner
return authenticate1
举例说明：抖音：绑定的是微信账号密码。 皮皮虾：绑定的是qq的账号密码。 你现在要完成的就是你的装饰器要分情况去判断账号和密码，不同的函数用的账号和密码来源不同。 但是你之前写的装饰器只能接受一个参数就是函数名，所以你写一个可以接受参数的装饰器。
login_statues = {
"username": None,
"status": True
}
def authenticate(my_args):
def authenticate1(func):
"""
这是一个装饰器函数
:return:
"""
def inner(*args, **kwargs):
"""执行代码前增加功能"""
if login_statues["status"]:
if my_args == "Wechat":
login_statues["username"] = input("请输入Wechat用户名：").strip()
password = input("请输入Wechat秘密：").strip()
if login_statues["username"] == "yuchuanduan" and password == "123456":
ret = func(*args, **kwargs)
login_statues["status"] = False
return ret
elif my_args == "qq":
login_statues["username"] = input("请输入QQ用户名：").strip()
password = input("请输入QQ秘密：").strip()
if login_statues["username"] == "yuchuanduan" and password == "123456":
ret = func(*args, **kwargs)
login_statues["status"] = False
return ret
else:
ret = func(*args, **kwargs)
"""执行代码后增加功能"""
return ret
return inner
return authenticate1
@authenticate("Wechat")
def diary():
print("欢迎来到diary页面!")
@authenticate("qq")
def comment():
print("欢迎来到comment页面？")
@authenticate("Wechat")
def home():
print("欢迎来到home页面")
diary()
comment()
home()
结果：
/usr/local/bin/python3 /home/yuchuantester/YuchuanData/PythonData/PythonProject/YuchuanDemo002.py
1576008396.1496649
请输入Wechat用户名：dsfs
请输入Wechat秘密：dsd
请输入QQ用户名：dsf
请输入QQ秘密：ds
请输入Wechat用户名：yuchuanduan
请输入Wechat秘密：123456
欢迎来到home页面
Process finished with exit code 0
@authenticate('Wechat') :分两步：
第一步先执行authenticate('Wechat')函数，得到返回值authenticate1
第二步@与authenticate1结合，形成装饰器@authenticate1 然后在依次执行。
这样就是带参数的装饰器，参数可以传入多个，一般带参数的装饰器在以后的工作中都是给你提供的， 你会用就行，但是自己也一定要会写，面试经常会遇到。
作者：Yuchuan
来源：CSDN
作者：华为云
链接：https://blog.csdn.net/devcloud/article/details/103661251