python 实用编程技巧 —— 装饰器使用问题与技巧
如何使用函数装饰器
常用的斐波那契的写法
def fibonacci(n):
if n<=1:
return 1
return fibonacci(n-1)+fibonacci(n-2)
这种方法也是C语言常用的递归算法。会进行大量的重复计算。如计算（10）时需要计算（8）和（9），计算（9）时需要计算（7）和（8）
改写传统的斐波那契
def fibonacci(n,cache=None):
#cache(n) #计算开始时先去缓存里找是否计算过n，如存在直接返回，否则计算，并把计算结果放在缓存中。
if cache is None: #创建一个空的字典
cache = {}
if n in cache:
return cache[n]
if n<=1:
return 1
cache[n] = fibonacci(n-1,cache) + fibonacci(n-2,cache)
return cache[n]
if __name__ == '__main__':
print(fibonacci(50))
可以发现瞬间计算出数值
使用装饰器
def memo(func):
cache = {}
def wrap(n):
if n not in cache:
cache[n] = func(n)
return cache[n]
return wrap
@memo
def fibonacci(n):
if n <= 1:
return 1
return fibonacci(n - 1) + fibonacci(n - 2)
if __name__ == '__main__':
print(fibonacci(50))
如何为被装饰的函数保存元数据
在函数对象中保存着一些函数的元数据， 例如：
- f.__name__: 函数的名字
- f.__doc__: 函数文档字符串
- f.__module__: 函数所属模块名
- f.__dict__: 属性字典
- f.__defaults__: 默认参数元组
我们在使用装饰器后， 再访问上面这些属性访问时，
看到的是内部包裹函数的元数组， 原来函数的元数据便丢失掉了， 应该如何解决？
解决方案
- 使用update_wrapper
- 使用wraps
from functools import wraps
def mydecorator(func): #装饰器，本例没增加功能，只做为演示
@wraps(func)
def wrapper(*args,**kargs):
"""wrapper function"""
print ('In wrapper')
func(*args,**kargs)
# update_wrapper(wrap, func)
return wrapper
@mydecorator
def example():
"""example function"""
print ('In example')
if __name__ == '__main__':
example()
print(example.__name__)
如何定义带参数的装饰器
实际案例
- 实现一个装饰器， 它用来检查被装饰函数的参数类型。
- 装饰器可以态可以通过参数指明函数参数的类型， 调用时如果检测出类型不匹配则抛出异常。
@type_assert(str, int, int)
def f(a, b, c):
...
@type_assert(y=list)
def g(x, y):
.解决方案
- 提取函数签名： inspect.signature()
- 带参数的装饰器， 也就是根据参数定制化一个装饰器， 可以看成生产装饰器的工厂。 每次调用type_assert, 返回一个特定的装饰器，然后用它去修饰其他函数
import inspect
def type_assert(*ty_args, **ty_kwargs): # 带参数的装饰器函数， 要增加一层包裹 参数是 装饰器的参数
def decorator(func):
# inspect.signature(func) 函数观察对象， 方便后面获取 参数-类型 字典与参数-值字典
func_sig = inspect.signature(func) # (a,b,c)
# 将装饰器参数 组成参数-类型 字典 如 {a:int, b:str}
bind_type = func_sig.bind_partial(*ty_args, **ty_kwargs).arguments # OrderedDict([('c', <class 'str'>)])
# func_sig.bind_partial 绑定部分参数可以得到 参数类型字典，
# 比如 参数是a=1, b='bbbb', c=2 装饰器参数是 a=int, b=str ,则得到{'a':int, 'b':str}
# 如果使用 func_sig.bind 则装饰器参数中 不能缺少 c 的类型
def wrap(*args, **kwargs): # 参数是func的 参数
for name, obj in func_sig.bind(*args, **kwargs).arguments.items(): # 得到 参数-值 字典
type_ = bind_type.get(name) # 从 参数-类型 字典中 得到 参数 应该属于的 类型
if type_:
if not isinstance(obj, type_):
raise TypeError('%s must be %s' % (name, type_))
return func(*args, **kwargs)
return wrap
return decorator
@type_assert(c=str)
def f(a, b, c):
pass
if __name__ == '__main__':
f(5, 10, 's') # 校验通过
f(5, 10, 1) # 检验失败 1 不是字符串类型
如何实现属性可修改的函数装饰器
实际案例
在某项目中， 程序运行效率差， 为分析程序内哪些函数执行时间开销大， 我们实现一个带timeout参数的函数装饰器。 装饰功能如下：
- 1.统计被装饰函数单次调用运行时间
- 2.时间大于参数 timeout的， 将此次函数调用记录到log 日志中
- 3.运行时可修改 timeout 的值
@warn_timeout(1.5)
def func(a, b):
...
解决方案
- 为包裹函数添加一个函数， 用来修改闭包中使用的自由变量。 在python3中：使用nonlocal 来访问潜逃作用域中的变量引用
import time
import logging
def warn_timeout(timeout):
def decorator(func):
# _timeout = [timeout]
def wrap(*args, **kwargs):
# timeout = _timeout[0]
t0 = time.time()
res = func(*args, **kwargs)
used = time.time() - t0
if used > timeout:
logging.warning('%s: %s > %s', func.__name__, used, timeout) # logging.warning 打印 输出到控制台
return res
def set_timeout(new_timeout):
nonlocal timeout # timeout 是闭包 变量
timeout = new_timeout
# _timeout[0] = new_timeout
wrap.set_timeout = set_timeout # 使timeout 可修改
return wrap
return decorator
import random
@warn_timeout(1.5)
def f(i):
print('in f [%s]' % i)
while random.randint(0, 1):
time.sleep(0.6)
for i in range(3):
f(i)
f.set_timeout(1) # 修改timeout 参数 从1.5 变为1
for i in range(3):
f(i)
输出结果如下
如何在类中定义装饰器
实际案例
- 实现一个能将函数调用信息记录到日志的装饰器：
- 把每次函数的调用时间， 执行时间， 调用次数写入日志
- 可以对被装饰函数分组， 调用信息记录到不同日志
- 动态修改参数， 比如日志格式
- 动态打开关闭日志输出功能
解决方案
- 为了让装饰器在使用上更加灵活， 可以把类的实例方法作为装饰器，此时在包裹函数中就可以持有实例对象， 便于修改属性和拓展功能
import time
import logging
DEFAULT_FORMAT = '%(func_name)s -> %(call_time)s\t%(used_time)s\t%(call_n)s'
class CallInfo:
def __init__(self, log_path, format_=DEFAULT_FORMAT, on_off=True):
self.log = logging.getLogger(log_path)
self.log.addHandler(logging.FileHandler(log_path))
# 这样可以通过log 往 log_path 输出信息
self.log.setLevel(logging.INFO) # 设置log级别
self.format = format_
self.is_on = on_off
# 装饰器方法
def info(self, func):
_call_n = 0 # 被调用次数
def wrap(*args, **kwargs):
func_name = func.__name__
call_time = time.strftime('%x %X', time.localtime())
# localtime 格式化时间戳为本地的时间 strftime 则得到时间字符串
# % x
# 本地相应的日期表示
# % X
# 本地相应的时间表示
t0 = time.time()
res = func(*args, **kwargs)
used_time = time.time() - t0
nonlocal _call_n
_call_n += 1
call_n = _call_n
if self.is_on:
self.log.info(self.format % locals()) # locals 即wrap函数中的变量 对应的字典
return res
return wrap
def set_format(self, format_):
self.format = format_
def turn_on_off(self, on_off):
self.is_on = on_off
# 测试代码
import random
ci1 = CallInfo('mylog1.log')
ci2 = CallInfo('mylog2.log')
@ci1.info
def f():
sleep_time = random.randint(0, 6) * 0.1
time.sleep(sleep_time)
@ci1.info
def g():
sleep_time = random.randint(0, 8) * 0.1
time.sleep(sleep_time)
@ci2.info
def h():
sleep_time = random.randint(0, 7) * 0.1
time.sleep(sleep_time)
for _ in range(3):
random.choice([f, g, h])()
ci1.set_format('%(func_name)s -> %(call_time)s\t%(call_n)s') # 去掉使用时间
for _ in range(3):
random.choice([f, g])()
