python装饰器简单例子,python 类装饰器和函数装饰器区别
本文主要详细介绍Python函数式编程的adorner。本文中的示例代码非常详细，具有一定的参考价值。感兴趣的朋友可以参考一下，希望能帮到你。
00-1010一、装饰者的本质：functionclosure: II。如何使用decorator:保持函数参数和返回值的函数闭包：III。多个decorators的执行顺序：IV。使用参数创建装饰器：摘要
目录
decorator的本质是函数闭包的语法糖。
一、装饰器的本质：
函数闭包是函数式语言中的一个术语(函数是一等公民，可以作为变量)。函数闭包:一种函数，其参数和返回值都是函数，在增强函数功能和面向切面编程（AOP）.使用
导入时间
#控制台打印100以内的奇数：
def print_odd():
对于范围(100):内的I
如果i % 2==1:
打印(一)
#函数闭包：用于增强函数func:函数func增加统计时间的功能：
定义计数时间包装器(函数):
def改进_func():
start_time=time.time()
函数()
end_time=time.time()
print(f 查找范围内的所有赔率需要{end_time - start_time} S！)
返回改进的_func
if __name__==__main__:
#调用计数时间包装增强函数
print_odd=计数时间包装器(print_odd)
print _奇数()
闭包本质上是一个函数。闭包函数的输入参数和返回值都是函数，闭包函数得到的返回值函数是输入函数增强的结果。
日志装饰器：
定义日志_包装器(函数):
闭包，用来增强func:给func增加日志功能。
def改进_func():
start _ time=time . strftime( % y-% m-% d % h :% m :% s ，time.local time (time.time ())) #开始时间
Func() #执行函数
end _ time=time . strftime( % y-% m-% d % h :% m :% s ，time.localtime (time.time ())) #结束时间
print(Logging: func:{}从{}运行到{})。格式(func。__name__，start_time，end_time))
返回改进的_func
函数闭包（function closure）：
通过decorator的函数增强只是一种语法糖，本质上和上一个程序完全一样(使用函数闭包)。
导入时间
#函数闭包：用于增强函数func:函数func增加统计时间的功能：
定义计数时间包装器(函数):
def改进_func():
start_time=time.time()
函数()
end_time=time.time()
print(f"It takes {end_time - start_time} S to find all the odds in range !!!")
return improved_func
# 控制台打印100以内的奇数：
@count_time_wrapper # 添加装饰器
def print_odd():
for i in range(100):
if i % 2 == 1:
print(i)
if __name__ == __main__:
# 使用 @装饰器（增强函数名） 给当前函数添加装饰器，等价于执行了下面这条语句：
# print_odd = count_time_wrapper(print_odd)
print_odd()
装饰器在第一次调用被装饰函数时进行增强，只增强一次，下次调用仍然是调用增强后的函数，不会重复执行增强！
保留函数参数和返回值的函数闭包：
- 之前所写的函数闭包，在增强主要功能函数时，没有保留原主要功能函数的参数列表和返回值。
- 一个保留参数列表和返回值的函数闭包写法：
def general_wrapper(func):def improved_func(*args, **kwargs):
# 增强函数功能：
ret = func(*args, **kwargs)
# 增强函数功能：
return ret
return improved_func
优化装饰器（参数传递、设置返回值）：
import time# 函数闭包：用于增强函数func：给函数func增加统计时间的功能：
def count_time_wrapper(func):
# 增强函数：
def improved_func(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"It takes {end_time - start_time} S to find all the odds in range !!!")
# 原函数返回值
return result
return improved_func
# 计算0-lim奇数之和：
@count_time_wrapper
def count_odds(lim):
cnt = 0
for i in range(lim):
if i % 2 == 1:
cnt = cnt + i
return cnt
if __name__ == __main__:
result = count_odds(10000000)
print(f"计算结果为{result}!")
三、多个装饰器的执行顺序：
# 装饰器1：def wrapper1(func1):
print("set func1") # 在wrapper1装饰函数时输出
def improved_func1(*args, **kwargs):
print("call func1") # 在wrapper1装饰过的函数被调用时输出
func1(*args, **kwargs)
return None
return improved_func1
# 装饰器2：
def wrapper2(func2):
print("set func2") # 在wrapper2装饰函数时输出
def improved_func2(*args, **kwargs):
print("call func1") # 在wrapper2装饰过的函数被调用时输出
func2(*args, **kwargs)
return None
return improved_func2
@wrapper1
@wrapper2
def original_func():
pass
if __name__ == __main__:
original_func()
print("------------")
original_func()
这里得到的执行结果是，wrapper2装饰器先执行，原因是因为：程序从上往下执行，当运行到：
@wrapper1@wrapper2
def original_func():
pass
这段代码时，使用函数闭包的方式解析为：
original_func = wrapper1(wrapper2(original_func))
所以先进行wrapper2装饰，然后再对被wrapper2装饰完成的增强函数再由wrapper1进行装饰，返回最终的增强函数。
四、创建带参数的装饰器：
装饰器允许传入参数，一个携带了参数的装饰器将有三层函数，如下所示：
import functoolsdef log_with_param(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(call %s(): % func.__name__)
print(args = {}.format(*args))
print(log_param = {}.format(text))
return func(*args, **kwargs)
return wrapper
return decorator
@log_with_param("param!!!")
def test_with_param(p):
print(test_with_param.__name__)
if __name__ == __main__:
test_with_param("test")
将其@语法去除，恢复函数调用的形式：
# 传入装饰器的参数，并接收返回的decorator函数decorator = log_with_param("param!!!")
# 传入test_with_param函数
wrapper = decorator(test_with_param)
# 调用装饰器函数
wrapper("Im a param")
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注盛行IT软件开发工作室的更多内容!
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。