32

我有一种将（除其他外）字典作为参数的方法。该方法正在解析字符串，并且字典为某些子字符串提供了替换，因此它不必是可变的。

这个函数经常被调用，并且在冗余元素上被调用，所以我认为缓存它会提高它的效率。

但是，正如您可能已经猜到的那样，因为dict它是可变的，因此不可散列，@functools.lru_cache不能装饰我的函数。那么我该如何克服呢？

如果它只需要标准库类和方法，则可以加分。理想情况下，如果它存在于我从未见过的某种frozendict标准库中，那会让我很开心。

PS：namedtuple仅在最后的手段，因为它需要一个大的语法转变。

4

7 回答 7

26

不要使用自定义的可哈希字典，而是使用它并避免重新发明轮子！这是一个完全可散列的冻结字典。

https://pypi.org/project/frozendict/

代码：

def freezeargs(func):
    """Transform mutable dictionnary
    Into immutable
    Useful to be compatible with cache
    """

    @functools.wraps(func)
    def wrapped(*args, **kwargs):
        args = tuple([frozendict(arg) if isinstance(arg, dict) else arg for arg in args])
        kwargs = {k: frozendict(v) if isinstance(v, dict) else v for k, v in kwargs.items()}
        return func(*args, **kwargs)
    return wrapped

进而

@freezeargs
@lru_cache
def func(...):
    pass

代码取自@fast_cen 的答案

注意：这不适用于递归数据结构；例如，您可能有一个参数是一个列表，它是不可散列的。邀请您进行包装递归，使其深入数据结构并使每个dict冻结和每个list元组。

（我知道 OP 不再需要解决方案，但我来这里是为了寻找相同的解决方案，所以将其留给后代）

于 2018-11-20T13:46:30.383 回答
15

这是一个使用@mhyfritz 技巧的装饰器。

def hash_dict(func):
    """Transform mutable dictionnary
    Into immutable
    Useful to be compatible with cache
    """
    class HDict(dict):
        def __hash__(self):
            return hash(frozenset(self.items()))

    @functools.wraps(func)
    def wrapped(*args, **kwargs):
        args = tuple([HDict(arg) if isinstance(arg, dict) else arg for arg in args])
        kwargs = {k: HDict(v) if isinstance(v, dict) else v for k, v in kwargs.items()}
        return func(*args, **kwargs)
    return wrapped

只需将它添加到您的 lru_cache 之前。

@hash_dict
@functools.lru_cache()
def your_function():
    ...
于 2017-06-27T09:38:15.843 回答
10

dict像这样创建一个可散列的类怎么样：

class HDict(dict):
    def __hash__(self):
        return hash(frozenset(self.items()))

substs = HDict({'foo': 'bar', 'baz': 'quz'})
cache = {substs: True}
于 2011-06-15T14:27:56.483 回答
3

子类化namedtuple和添加访问权限x["key"]怎么样？

class X(namedtuple("Y", "a b c")):
    def __getitem__(self, item):
        if isinstance(item, int):
            return super(X, self).__getitem__(item)
        return getattr(self, item)
于 2011-06-15T14:50:18.983 回答
2

这是一个可以像functools.lru_cache. 但这是针对只接受一个参数的函数，该参数是具有可散列值的平面映射，并且固定为 64。对于您的用例，您必须调整此示例或您的客户端代码。此外，要单独设置，必须实现另一个装饰器，但我没有把头绕在这个问题上，因为我不需要它。maxsizemaxsize

from functools import (_CacheInfo, _lru_cache_wrapper, lru_cache,
                       partial, update_wrapper)
from typing import Any, Callable, Dict, Hashable

def lru_dict_arg_cache(func: Callable) -> Callable:
    def unpacking_func(func: Callable, arg: frozenset) -> Any:
        return func(dict(arg))

    _unpacking_func = partial(unpacking_func, func)
    _cached_unpacking_func = \
        _lru_cache_wrapper(_unpacking_func, 64, False, _CacheInfo)

    def packing_func(arg: Dict[Hashable, Hashable]) -> Any:
        return _cached_unpacking_func(frozenset(arg.items()))

    update_wrapper(packing_func, func)
    packing_func.cache_info = _cached_unpacking_func.cache_info
    return packing_func


@lru_dict_arg_cache
def uppercase_keys(arg: dict) -> dict:
    """ Yelling keys. """
    return {k.upper(): v for k, v in arg.items()}


assert uppercase_keys.__name__ == 'uppercase_keys'
assert uppercase_keys.__doc__ == ' Yelling keys. '
assert uppercase_keys({'ham': 'spam'}) == {'HAM': 'spam'}
assert uppercase_keys({'ham': 'spam'}) == {'HAM': 'spam'}
cache_info = uppercase_keys.cache_info()
assert cache_info.hits == 1
assert cache_info.misses == 1
assert cache_info.maxsize == 64
assert cache_info.currsize == 1
assert uppercase_keys({'foo': 'bar'}) == {'FOO': 'bar'}
assert uppercase_keys({'foo': 'baz'}) == {'FOO': 'baz'}
cache_info = uppercase_keys.cache_info()
assert cache_info.hits == 1
assert cache_info.misses == 3
assert cache_info.currsize == 3

对于更通用的方法，可以使用来自第三方库的装饰器@cachetools.cache 并将key适当的函数设置为.

于 2016-12-06T16:40:39.170 回答
1

在决定暂时为我们的用例放弃 lru 缓存之后，我们仍然想出了一个解决方案。这个装饰器使用 json 序列化和反序列化发送到缓存的 args/kwargs。适用于任意数量的参数。将其用作函数的装饰器，而不是 @lru_cache。最大大小设置为 1024。

def hashable_lru(func):
    cache = lru_cache(maxsize=1024)

    def deserialise(value):
        try:
            return json.loads(value)
        except Exception:
            return value

    def func_with_serialized_params(*args, **kwargs):
        _args = tuple([deserialise(arg) for arg in args])
        _kwargs = {k: deserialise(v) for k, v in kwargs.items()}
        return func(*_args, **_kwargs)

    cached_function = cache(func_with_serialized_params)

    @wraps(func)
    def lru_decorator(*args, **kwargs):
        _args = tuple([json.dumps(arg, sort_keys=True) if type(arg) in (list, dict) else arg for arg in args])
        _kwargs = {k: json.dumps(v, sort_keys=True) if type(v) in (list, dict) else v for k, v in kwargs.items()}
        return cached_function(*_args, **_kwargs)
    lru_decorator.cache_info = cached_function.cache_info
    lru_decorator.cache_clear = cached_function.cache_clear
    return lru_decorator
于 2017-10-05T15:58:48.930 回答
0

基于@Cedar answer，按照建议为深度冻结添加递归：

def deep_freeze(thing):
    from collections.abc import Collection, Mapping, Hashable
    from frozendict import frozendict
    if thing is None or isinstance(thing, str):
        return thing
    elif isinstance(thing, Mapping):
        return frozendict({k: deep_freeze(v) for k, v in thing.items()})
    elif isinstance(thing, Collection):
        return tuple(deep_freeze(i) for i in thing)
    elif not isinstance(thing, Hashable):
        raise TypeError(f"unfreezable type: '{type(thing)}'")
    else:
        return thing


def deep_freeze_args(func):
    import functools

    @functools.wraps(func)
    def wrapped(*args, **kwargs):
        return func(*deep_freeze(args), **deep_freeze(kwargs))
    return wrapped
于 2021-03-21T05:49:24.437 回答