Python中装饰器高级用法详解
作者:fasionchan 发布时间:2023-09-30 09:46:42
在Python中,装饰器一般用来修饰函数,实现公共功能,达到代码复用的目的。在函数定义前加上@xxxx,然后函数就注入了某些行为,很神奇!然而,这只是语法糖而已。
场景
假设,有一些工作函数,用来对数据做不同的处理:
def work_bar(data):
pass
def work_foo(data):
pass
我们想在函数调用前/后输出日志,怎么办?
傻瓜解法
logging.info('begin call work_bar')
work_bar(1)
logging.info('call work_bar done')
如果有多处代码调用呢?想想就怕!
函数包装
傻瓜解法无非是有太多代码冗余,每次函数调用都要写一遍logging。可以把这部分冗余逻辑封装到一个新函数里:
def smart_work_bar(data):
logging.info('begin call: work_bar')
work_bar(data)
logging.info('call doen: work_bar')
这样,每次调用smart_work_bar即可:
smart_work_bar(1)
# ...
smart_work_bar(some_data)
通用闭包
看上去挺完美……然而,当work_foo也有同样的需要时,还要再实现一遍smart_work_foo吗?这样显然不科学呀!
别急,我们可以用闭包:
def log_call(func):
def proxy(*args, **kwargs):
logging.info('begin call: {name}'.format(name=func.func_name))
result = func(*args, **kwargs)
logging.info('call done: {name}'.format(name=func.func_name))
return result
return proxy
这个函数接收一个函数对象(被代理函数)作为参数,返回一个代理函数。调用代理函数时,先输出日志,然后调用被代理函数,调用完成后再输出日志,最后返回调用结果。这样,不就达到通用化的目的了吗?——对于任意被代理函数func,log_call均可轻松应对。
smart_work_bar = log_call(work_bar)
smart_work_foo = log_call(work_foo)
smart_work_bar(1)
smart_work_foo(1)
# ...
smart_work_bar(some_data)
smart_work_foo(some_data)
第1行中,log_call接收参数work_bar,返回一个代理函数proxy,并赋给smart_work_bar。第4行中,调用smart_work_bar,也就是代理函数proxy,先输出日志,然后调用func也就是work_bar,最后再输出日志。注意到,代理函数中,func与传进去的work_bar对象紧紧关联在一起了,这就是闭包。
再提一下,可以覆盖被代理函数名,以smart_为前缀取新名字还是显得有些累赘:
work_bar = log_call(work_bar)
work_foo = log_call(work_foo)
work_bar(1)
work_foo(1)
语法糖
先来看看以下代码:
def work_bar(data):
pass
work_bar = log_call(work_bar)
def work_foo(data):
pass
work_foo = log_call(work_foo)
虽然代码没有什么冗余了,但是看是去还是不够直观。这时候,语法糖来了~~~
@log_call
def work_bar(data):
pass
因此,注意一点(划重点啦),这里@log_call的作用只是:告诉Python编译器插入代码work_bar = log_call(work_bar)。
求值装饰器
先来猜猜装饰器eval_now有什么作用?
def eval_now(func):
return func()
看上去好奇怪哦,没有定义代理函数,算装饰器吗?
@eval_now
def foo():
return 1
print foo
这段代码输出1,也就是对函数进行调用求值。那么到底有什么用呢?直接写foo = 1不行么?在这个简单的例子,这么写当然可以啦。来看一个更复杂的例子——初始化一个日志对象:
# some other code before...
# log format
formatter = logging.Formatter(
'[%(asctime)s] %(process)5d %(levelname) 8s - %(message)s',
'%Y-%m-%d %H:%M:%S',
)
# stdout handler
stdout_handler = logging.StreamHandler(sys.stdout)
stdout_handler.setFormatter(formatter)
stdout_handler.setLevel(logging.DEBUG)
# stderr handler
stderr_handler = logging.StreamHandler(sys.stderr)
stderr_handler.setFormatter(formatter)
stderr_handler.setLevel(logging.ERROR)
# logger object
logger = logging.Logger(__name__)
logger.setLevel(logging.DEBUG)
logger.addHandler(stdout_handler)
logger.addHandler(stderr_handler)
# again some other code after...
用eval_now的方式:
# some other code before...
@eval_now
def logger():
# log format
formatter = logging.Formatter(
'[%(asctime)s] %(process)5d %(levelname) 8s - %(message)s',
'%Y-%m-%d %H:%M:%S',
)
# stdout handler
stdout_handler = logging.StreamHandler(sys.stdout)
stdout_handler.setFormatter(formatter)
stdout_handler.setLevel(logging.DEBUG)
# stderr handler
stderr_handler = logging.StreamHandler(sys.stderr)
stderr_handler.setFormatter(formatter)
stderr_handler.setLevel(logging.ERROR)
# logger object
logger = logging.Logger(__name__)
logger.setLevel(logging.DEBUG)
logger.addHandler(stdout_handler)
logger.addHandler(stderr_handler)
return logger
# again some other code after...
两段代码要达到的目的是一样的,但是后者显然更清晰,颇有代码块的风范。更重要的是,函数调用在局部名字空间完成初始化,避免临时变量(如formatter等)污染外部的名字空间(比如全局)。
带参数装饰器
定义一个装饰器,用于记录慢函数调用:
def log_slow_call(func):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > 1:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
第3、5行分别在函数调用前后采样当前时间,第7行计算调用耗时,耗时大于一秒输出一条警告日志。
@log_slow_call
def sleep_seconds(seconds):
time.sleep(seconds)
sleep_seconds(0.1) # 没有日志输出
sleep_seconds(2) # 输出警告日志
然而,阈值设置总是要视情况决定,不同的函数可能会设置不同的值。如果阈值有办法参数化就好了:
def log_slow_call(func, threshold=1):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
然而,@xxxx语法糖总是以被装饰函数为参数调用装饰器,也就是说没有机会传递threshold参数。怎么办呢?——用一个闭包封装threshold参数:
def log_slow_call(threshold=1):
def decorator(func):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
return decorator
@log_slow_call(threshold=0.5)
def sleep_seconds(seconds):
time.sleep(seconds)
这样,log_slow_call(threshold=0.5)调用返回函数decorator,函数拥有闭包变量threshold,值为0.5。decorator再装饰sleep_seconds。
采用默认阈值,函数调用还是不能省略:
@log_slow_call()
def sleep_seconds(seconds):
time.sleep(seconds)
处女座可能会对第一行这对括号感到不爽,那么可以这样改进:
def log_slow_call(func=None, threshold=1):
def decorator(func):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
if func is None:
return decorator
else:
return decorator(func)
这种写法兼容两种不同的用法,用法A默认阈值(无调用);用法B自定义阈值(有调用)。
# Case A
@log_slow_call
def sleep_seconds(seconds):
time.sleep(seconds)
# Case B
@log_slow_call(threshold=0.5)
def sleep_seconds(seconds):
time.sleep(seconds)
用法A中,发生的事情是log_slow_call(sleep_seconds),也就是func参数是非空的,这是直接调decorator进行包装并返回(阈值是默认的)。
用法B中,先发生的是log_slow_call(threshold=0.5),func参数为空,直接返回新的装饰器decorator,关联闭包变量threshold,值为0.5;然后,decorator再装饰函数sleep_seconds,即decorator(sleep_seconds)。注意到,此时threshold关联的值是0.5,完成定制化。
你可能注意到了,这里最好使用关键字参数这种调用方式——使用位置参数会很丑陋:
# Case B-
@log_slow_call(None, 0.5)
def sleep_seconds(seconds):
time.sleep(seconds)
当然了,函数调用尽量使用关键字参数是一种极佳实践,含义清晰,在参数很多的情况下更是如此。
智能装饰器
上节介绍的写法,嵌套层次较多,如果每个类似的装饰器都用这种方法实现,还是比较费劲的(脑子不够用),也比较容易出错。
假设有一个智能装饰器smart_decorator,修饰装饰器log_slow_call,便可获得同样的能力。这样,log_slow_call定义将变得更清晰,实现起来也更省力啦:
@smart_decorator
def log_slow_call(func, threshold=1):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
脑洞开完,smart_decorator如何实现呢?其实也简单:
def smart_decorator(decorator):
def decorator_proxy(func=None, **kwargs):
if func is not None:
return decorator(func=func, **kwargs)
def decorator_proxy(func):
return decorator(func=func, **kwargs)
return decorator_proxy
return decorator_proxy
smart_decorator实现了以后,设想就成立了!这时,log_slow_call,就是decorator_proxy(外层),关联的闭包变量decorator是本节最开始定义的log_slow_call(为了避免歧义,称为real_log_slow_call)。log_slow_call支持以下各种用法:
# Case A
@log_slow_call
def sleep_seconds(seconds):
time.sleep(seconds)
用法A中,执行的是decorator_proxy(sleep_seconds)(外层),func非空,kwargs为空;直接执行decorator(func=func, **kwargs),即real_log_slow_call(sleep_seconds),结果是关联默认参数的proxy。
# Case B
# Same to Case A
@log_slow_call()
def sleep_seconds(seconds):
time.sleep(seconds)
用法B中,先执行decorator_proxy(),func及kwargs均为空,返回decorator_proxy对象(内层);再执行decorator_proxy(sleep_seconds)(内层);最后执行decorator(func, **kwargs),等价于real_log_slow_call(sleep_seconds),效果与用法A一致。
# Case C
@log_slow_call(threshold=0.5)
def sleep_seconds(seconds):
time.sleep(seconds)
用法C中,先执行decorator_proxy(threshold=0.5),func为空但kwargs非空,返回decorator_proxy对象(内层);再执行decorator_proxy(sleep_seconds)(内层);最后执行decorator(sleep_seconds, **kwargs),等价于real_log_slow_call(sleep_seconds, threshold=0.5),阈值实现自定义!
来源:https://www.jianshu.com/p/f74624e43226
猜你喜欢
- Oracle物理结构故障是指构成数据库的各个物理文件损坏而导致的各种数据库故障。这些故障可能是由于硬件故障造成的,也可能是人为误操作而引起。
- Python 中使用线程有两种方式:函数或者用类来包装线程对象。函数式:调用 thread 模块中的start_new_thread()函数
- 我在跑爬虫程序的时候,由于爬虫程序的等待目标服务器返回数据的时间很长,而cpu占用很低,所以经常挂着代理一跑就跑好几百个。但是爬虫程序通常是
- 快速排序的基本思想:首先选定一个数组中的一个初始值,将数组中比该值小的放在左边,比该值大的放在右边,然后分别对左边的数组进行如上的操作,对右
- 本文实例讲述了php中$_GET与$_POST过滤sql注入的方法,分享给大家供大家参考。具体分析如下:此函数只能过滤一些敏感的sql命令了
- __init__ 方法是什么?使用Python写过面向对象的代码的同学,可能对 __init__ 方法已经非常熟悉了,__init__ 方法
- 但是有时候,可以视看处进逻辑程度,可以把三者写成一个触发器,只是在其中稍作判断而已。 你可以根据从下面方法判断触发器是是处理了插入,删除还是
- 一、读者指引读者指引帮助你掌握本文的梗概。以免你看了大半才明白这编文章不适合你,给你造成视觉污染。如果你正在用ASP+XML写一些程序,或者
- 啥也不说了,还是看代码吧! [root@yyjk DATABASE]# cat DBI.py# -*- coding: utf-8 -*-
- 在python中有很多字符串连接方式,今天就在这里具体总结一下:①.最原始的字符串连接方式:str1 + str2②.python 新字符串
- 后台数据库用是Access,客户用了一年后说打开界面非常慢,查看了数据库后发现数据表中的记录已有五万多条,自己试过将记录复制到10 万条,打
- BP神经网络是最简单的神经网络模型了,三层能够模拟非线性函数效果。难点:如何确定初始化参数?如何确定隐含层节点数量?迭代多少次?如何更快收敛
- /* 功能: 通用分页存储过程 参数: @PK varchar(50), 主键,用来排序的单一字段,空的话,
- 因为工作(懒惰),几年了,断断续续学习又半途而废了一个又一个技能。试着开始用博客记录学习过程中的问题和解决方式,以便激励自己和顺便万一帮助了
- 今天在写PHP程序的时候总是出现这样的错误:Parse error: syntax error, unexpected end of fil
- 对于windows平台来说安装完MySQL后,系统就已经默认生成了许可表和账户,你不需要像在Unix平台上那样执行 mysql_instal
- Python pip安装lxml出错的问题解决办法1. 在使用pip安装lxml过程中出现了一下错误: &
- 学习vue和nodejs的过程当中,涉及到了axios,今天为了测试,写了get和post两个方法来跟node服务端交互,结果因为heade
- 前言网站登录的时候我们常常会看到随机的验证码需要输入后台验证,如图:现在我们来实现在Django中通过自定制插件来实现随机验证check_c
- 日志日志是跟踪软件运行时所发生的事件的一种方法。软件开发者在代码中调用日志函数,表明发生了特定的事件。事件由描述性消息描述,该描述性消息可以