Python装饰器处理装饰函数的默认参数
我想为类方法创建一个“缓存”修饰符,它在一个内部类属性中注册该方法的结果,以避免多次计算它(我不想使用一个简单的属性,在Python装饰器处理装饰函数的默认参数,python,decorator,python-decorators,Python,Decorator,Python Decorators,我想为类方法创建一个“缓存”修饰符,它在一个内部类属性中注册该方法的结果,以避免多次计算它(我不想使用一个简单的属性,在\uuuuu init\uuuuuu中计算,因为我不确定每次都要计算一次) 第一个想法是创建类似以下内容的装饰器“缓存”: def cache(func): name = "_{:s}".format(func.__name__) def wrapped(obj): if not hasattr(obj, name) or getattr(obj
\uuuuu init\uuuuuu
中计算,因为我不确定每次都要计算一次)
第一个想法是创建类似以下内容的装饰器“缓存”:
def cache(func):
name = "_{:s}".format(func.__name__)
def wrapped(obj):
if not hasattr(obj, name) or getattr(obj, name) is None:
print "Computing..."
setattr(obj, name, func(obj))
else:
print "Already computed!"
return getattr(obj, name)
return wrapped
class Test:
@cache
def hello(self):
return 1000 ** 5
一切正常:
In [121]: t = Test()
In [122]: hasattr(t, '_hello')
Out[122]: False
In [123]: t.hello()
Computing...
Out[123]: 1000000000000000
In [124]: t.hello()
Already computed!
Out[124]: 1000000000000000
In [125]: hasattr(t, '_hello')
Out[125]: True
现在让我们说我想做同样的事情,但是当方法可以用参数(关键字和/或不)调用时。
当然,现在我们不会将结果存储在不同的属性中(名称是什么?…),而是存储在字典中,字典的键由*args和**kwargs组成。让我们用元组来做:
def cache(func):
name = "_{:s}".format(func.__name__)
def wrapped(obj, *args, **kwargs):
if not hasattr(obj, name) or getattr(obj, name) is None:
setattr(obj, name, {})
o = getattr(obj, name)
a = args + tuple(kwargs.items())
if not a in o:
print "Computing..."
o[a] = func(obj, *args, **kwargs)
else:
print "Already computed!"
return o[a]
return wrapped
class Test:
@cache
def hello(self, *args, **kwargs):
return 1000 * sum(args) * sum(kwargs.values())
In [137]: t = Test()
In [138]: hasattr(t, '_hello')
Out[138]: False
In [139]: t.hello()
Computing...
Out[139]: 0
In [140]: hasattr(t, '_hello')
Out[140]: True
In [141]: t.hello(3)
Computing...
Out[141]: 0
In [142]: t.hello(p=3)
Computing...
Out[142]: 0
In [143]: t.hello(4, y=23)
Computing...
Out[143]: 92000
In [144]: t._hello
Out[144]: {(): 0, (3,): 0, (4, ('y', 23)): 92000, (('p', 3),): 0}
由于方法items
将字典转换为元组,而不考虑字典中的顺序,因此,如果关键字参数的调用顺序不同,则该方法可以完美地工作:
In [146]: t.hello(2, a=23,b=34)
Computing...
Out[146]: 114000
In [147]: t.hello(2, b=34, a=23)
Already computed!
Out[147]: 114000
我的问题是:如果该方法有默认参数,那么它将不再工作:
class Test:
@cache
def hello(self, a=5):
return 1000 * a
In [155]: t = Test()
In [156]: t.hello()
Computing...
Out[156]: 5000
In [157]: t.hello(a=5)
Computing...
Out[157]: 5000
In [158]: t.hello(5)
Computing...
Out[158]: 5000
In [159]: t._hello
Out[159]: {(): 5000, (5,): 5000, (('a', 5),): 5000}
现在它不再工作了:
class Test:
@cache
def hello(self, a=5):
return 1000 * a
In [155]: t = Test()
In [156]: t.hello()
Computing...
Out[156]: 5000
In [157]: t.hello(a=5)
Computing...
Out[157]: 5000
In [158]: t.hello(5)
Computing...
Out[158]: 5000
In [159]: t._hello
Out[159]: {(): 5000, (5,): 5000, (('a', 5),): 5000}
结果计算了3次,因为参数的给出方式不同(即使它们是“相同”的参数!)
有人知道我如何在decorator中捕获给定给函数的“默认”值吗
谢谢根据参数函数结构的复杂程度,可以有各种解决方案。我喜欢的解决方案是在
hello
中添加内部函数。如果不想更改缓存的名称,请使用与外部函数相同的名称:
class Test:
def hello(self, a=5):
@cache
def hello(self, a):
return 1000 * a
return hello(self, a)
t = Test()
t.hello()
t.hello(a=5)
t.hello(5)
t._hello
Out[111]: Computing...
Already computed!
Already computed!
{(5,): 5000}
另一种方法是在decorator中添加默认变量检查,例如:
def cache(func):
name = "_{:s}".format(func.__name__)
def wrapped(obj, *args, **kwargs):
if not hasattr(obj, name) or getattr(obj, name) is None:
setattr(obj, name, {})
o = getattr(obj, name)
a = args + tuple(kwargs.items())
if func.func_defaults: # checking if func have default variable
for k in kwargs.keys():
if k in func.func_code.co_varnames and kwargs[k] == func.func_defaults[0]:
a = ()
if args:
if args[0] == func.func_defaults[0]:
a = ()
if not a in o:
print "Computing..."
o[a] = func(obj, *args, **kwargs)
else:
print "Already computed!"
return o[a]
return wrapped
class Test:
@cache
def hello(self, a=5):
return 1000 * a
t = Test()
t.hello()
t.hello(a=5)
t.hello(5)
t._hello
Out[112]: Computing...
Already computed!
Already computed!
{(): 5000}
例如,如果您有两个默认变量,第一个代码(带有内部函数)仍然可以工作,而第二个代码需要更改“默认变量检查规则”。如果您使用的是足够新的Python版本,您可以使用获取一个
签名
对象,该对象完全封装了有关函数参数的信息。然后,您可以使用包装器传递的参数调用其bind
方法,以获得BoundArguments
对象。调用BoundArguments
上的apply\u defaults
方法来填充任何缺少的具有默认值的参数,并检查arguments
有序字典以查看函数参数及其此调用值的明确列表:
import inspect
def cache(func):
name = "_{:s}".format(func.__name__)
sig = inspect.signature(func)
def wrapped(obj, *args, **kwargs):
cache_dict = getattr(obj, name, None)
if cache_dict is None:
cache_dict = {}
setattr(obj, name, cache_dict)
bound_args = sig.bind(obj, *args, **kwargs)
bound_args.apply_defaults()
cache_key = tuple(bound_args.arguments.values())
if not cache_key in cache_dict:
print("Computing...")
cache_dict[cache_key] = func(obj, *args, **kwargs)
else:
print("Already computed!")
return cache_dict[cache_key]
return wrapped
请注意,我重命名了a
和o
变量,以获得更有意义的名称。我还改变了在对象上设置缓存字典的方式。这样调用的getattr
和setattr
更少
Python 3.3中添加了
inspect.signature
函数和相关类型,但是BoundArguments
对象上的apply\u defaults
方法在Python 3.5中是新的。对于较旧的Python版本,有一个基本功能的后端口,但它似乎还不包括apply\u defaults
。我将在backport上报告这一问题。你知道吗?@Jonas Wielicki它在Python 3.2以下版本中不可用。他正在使用Python 2。x@VadimShkaberda是的,我没有注意到它是在3.2中添加的。谢谢您的快速回答!两种方式我都喜欢,但我想我会选择第二种,它更符合我的需要!