11

所以我最近问了一个关于记忆的问题并得到了一些很好的答案，现在我想把它提升到一个新的水平。经过一番谷歌搜索，我找不到能够缓存接受关键字参数的函数的 memoize 装饰器的参考实现。事实上，它们中的大多数只是用作*args缓存查找的键，这意味着如果你想记住一个接受列表或字典作为参数的函数，它也会中断。

在我的例子中，函数的第一个参数本身就是一个唯一标识符，适合用作缓存查找的字典键，但是我希望能够使用关键字参数并仍然访问相同的缓存。我的意思是，my_func('unique_id', 10)两者my_func(foo=10, func_id='unique_id')都应该返回相同的缓存结果。

为了做到这一点，我们需要一种简洁且 Python 式的方式来表达“检查 kwargs 以获取与第一个参数相对应的关键字）”。这就是我想出的：

class memoize(object):
    def __init__(self, cls):
        if type(cls) is FunctionType:
            # Let's just pretend that the function you gave us is a class.
            cls.instances = {}
            cls.__init__ = cls
        self.cls = cls
        self.__dict__.update(cls.__dict__)

    def __call__(self, *args, **kwargs):
        """Return a cached instance of the appropriate class if it exists."""
        # This is some dark magic we're using here, but it's how we discover
        # that the first argument to Photograph.__init__ is 'filename', but the
        # first argument to Camera.__init__ is 'camera_id' in a general way.
        delta = 2 if type(self.cls) is FunctionType else 1
        first_keyword_arg = [k
            for k, v in inspect.getcallargs(
                self.cls.__init__,
                'self',
                'first argument',
                *['subsequent args'] * (len(args) + len(kwargs) - delta)).items()
                    if v == 'first argument'][0]
        key = kwargs.get(first_keyword_arg) or args[0]
        print key
        if key not in self.cls.instances:
            self.cls.instances[key] = self.cls(*args, **kwargs)
        return self.cls.instances[key]

疯狂的是，这确实有效。例如，如果你这样装饰：

@memoize
class FooBar:
    instances = {}

    def __init__(self, unique_id, irrelevant=None):
        print id(self)

然后从您的代码中，您可以调用FooBar('12345', 20)或实际获取 FooBar 的相同实例。然后，您可以为第一个参数定义一个具有不同名称的不同类，因为它以一般方式工作（即，装饰器不需要知道任何关于它正在装饰的类的特定信息才能使其工作）。FooBar(irrelevant=20, unique_id='12345')

问题是，这是一团糟；-)

它之所以有效，是因为inspect.getcallargs返回了一个将定义的关键字映射到您提供的参数的字典，所以我提供了一些虚假参数，然后检查字典是否有传递的第一个参数。

如果这样的事情甚至存在，那会更好的是，它类似于inspect.getcallargs返回统一为参数列表而不是关键字参数的字典的两种参数。这将允许这样的事情：

def __call__(self, *args, **kwargs):
    key = inspect.getcallargsaslist(self.cls.__init__, None, *args, **kwargs)[1]
    if key not in self.cls.instances:
        self.cls.instances[key] = self.cls(*args, **kwargs)
    return self.cls.instances[key]

我可以看到解决此问题的另一种方法是直接使用提供的 dictinspect.getcallargs作为查找缓存键，但这需要一种可重复的方式来从相同的哈希中生成相同的字符串，这是我听说的不能依赖的上（我想我必须在对键进行排序后自己构造字符串）。

有人对此有任何想法吗？想要使用关键字参数调用函数并缓存结果是错误的吗？或者只是非常困难？

4

3 回答 3

6

我建议如下：

import inspect

class key_memoized(object):
    def __init__(self, func):
       self.func = func
       self.cache = {}

    def __call__(self, *args, **kwargs):
        key = self.key(args, kwargs)
        if key not in self.cache:
            self.cache[key] = self.func(*args, **kwargs)
        return self.cache[key]

    def normalize_args(self, args, kwargs):
        spec = inspect.getargs(self.func.__code__).args
        return dict(kwargs.items() + zip(spec, args))

    def key(self, args, kwargs):
        a = self.normalize_args(args, kwargs)
        return tuple(sorted(a.items()))

例子： 

@key_memoized
def foo(bar, baz, spam):
    print 'calling foo: bar=%r baz=%r spam=%r' % (bar, baz, spam)
    return bar + baz + spam

print foo(1, 2, 3)
print foo(1, 2, spam=3)         #memoized
print foo(spam=3, baz=2, bar=1) #memoized

请注意，您还可以扩展key_memoized和覆盖其key()方法以提供更具体的记忆策略，例如忽略一些参数：

class memoize_by_bar(key_memoized):
    def key(self, args, kwargs):
        return self.normalize_args(args, kwargs)['bar']

@memoize_by_bar
def foo(bar, baz, spam):
    print 'calling foo: bar=%r baz=%r spam=%r' % (bar, baz, spam)
    return bar

print foo('x', 'ignore1', 'ignore2')
print foo('x', 'ignore3', 'ignore4')
于 2012-06-06T20:06:55.813 回答
3

尝试lru_cache：

@functools.lru_cache(maxsize=128, typed=False)

装饰器用一个可保存最多 maxsize 最近调用的记忆可调用函数来包装函数。当使用相同的参数定期调用昂贵的或 I/O 绑定的函数时，它可以节省时间。

lru_cache 在 python 3.2 中添加，但可以向后移植到 2.x

于 2012-06-06T18:47:42.917 回答
0

你可以看看我的包：https ://github.com/Yiling-J/cacheme ，实际上我使用一个容器来存放所有的 args/kwargs：

@cacheme(key=lambda c: 'cat:{name}'.format(name=c.cat.name))
def get_cat(self, cat):
    return some_function(cat)
于 2020-04-26T15:07:37.580 回答