允许不可散列参数的记忆配方

Question

常见的记忆配方（如this 或these）使用dict 来存储缓存，因此要求函数参数是可散列的。

我希望函数可以使用尽可能多的不同参数类型，当然包括dict、set、list。实现这一目标的最佳方法是什么？

我正在考虑的一种方法是将所有不可散列的参数包装到它们的可散列子类中（即，定义一个 dict 的子类来定义它自己的 __hash__ 函数）。

另外，我正在考虑创建一个 dict 的子类，它依赖于与 hash 不同的哈希函数（定义一个递归地在容器上工作的全局 my_hash 函数并不难），并使用它子类来存储缓存。但我认为没有一种简单的方法可以做到这一点。

编辑：

我想我会尝试我建议的the solution 用于python 容器的一般散列。有了这个，我应该能够将(*args, **kwargs) 的元组包装到自动哈希类中，并使用常规记忆。

Answer 1

dict/list/set/etc 是有原因的。不可散列，而是它们是可变的。

这是它们的不可变对应物存在的主要原因之一（frozendict/frozenset/tuple）。 （嗯，元组并不完全是一个冻结列表，但实际上它可以达到目的）。

因此，为了您的目的，请使用不可变的替代方案。

这里快速演示了为什么不应该散列可变对象。请记住，散列需要a==b ==> hash(a)==hash(b)。

@memoize
def f(x): ...

d1 = {'a':5}
d2 = {'a':99}
res1 = f(d1)
res2 = f(d2)
d1['a'] = 99
res3 = f(d1)  # what should be returned? not well defined...

Answer 2

方法一（拆分键和值）

这是基于字典只是压缩键和值的想法。 有了这个想法，我们可以将类似的东西做成一个字典来存储键（函数参数）和值（函数的返回值）。

由于它使用list.index，所以不确定它会有多慢。也许zipping 会更快？

class memoize:
    def __init__(self, func):
        self.func = func
        self.known_keys = []
        self.known_values = []

    def __call__(self, *args, **kwargs):
        key = (args, kwargs)

        if key in self.known_keys:
            i = self.known_keys.index(key)
            return self.known_values[i]
        else:
            value = self.func(*args, **kwargs)
            self.known_keys.append(key)
            self.known_values.append(value)

            return value

有效！：

>>> @memoize
... def whatever(unhashable):
...     print(*unhashable) # Just to know when called for this example
...     return 12345
...
>>> whatever([1, 2, 3, 4])
1 2 3 4
12345
>>> whatever([1, 2, 3, 4])
12345
>>> whatever({"a": "b", "c": "d"})
a c
12345
>>> whatever({"a": "b", "c": "d"})
12345

方法 2（假哈希）

class memoize:
    def __init__(self, func):
        self.func = func
        self.known = {}

    def __call__(self, *args, **kwargs):
        key = give_fake_hash((args, kwargs))

        try:
            return self.known[key]
        except KeyError:
            value = self.func(*args, **kwargs)
            self.known[key] = value
            return value

def give_fake_hash(obj):
    cls = type(obj)
    name = "Hashable" + cls.__name__

    def fake_hash(self):
        return hash(repr(self))

    t = type(name, (cls, ), {"__hash__": fake_hash})

    return t(obj)

方法 2.5（用于 dicts）

import operator

class memoize:
    def __init__(self, func):
        self.func = func
        self.known = {}

    def __call__(self, *args, **kwargs):
        key = give_fake_hash((args, kwargs))

        try:
            return self.known[key]
        except KeyError:
            value = self.func(*args, **kwargs)
            self.known[key] = value
            return value

def fake_hash(self):
    return hash(repr(self))

class HashableTuple(tuple):
    __hash__ = fake_hash

class RereprDict(dict):
    def __repr__(self):
        try:
            self._cached_repr
        except AttributeError:
            self._cached_repr = repr(sorted(self.items(), key=operator.itemgetter(0)))
        finally:
            return self._cached_repr

    __hash__ = fake_hash

def fix_args(args):
    for elem in args:
        if isinstance(elem, dict):
            elem = RereprDict(elem)
        yield elem

def give_fake_hash(tup):
    args, kwargs = tup

    args = tuple(fix_args(args))
    kwargs = RereprDict(kwargs)

    return HashableTuple((args, kwargs))