Python-有人拥有可以处理不可散列参数的备注修饰符吗？

Question

我一直在使用以下记忆修饰符（来自很棒的书Python Algorithms：掌握Python语言中的基本算法…喜欢它，顺便说一句）。

def memo(func):
    cache = {}
    @ wraps(func)
    def wrap(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrap

这个装饰器的问题是基于字典的缓存意味着我所有的参数都必须是可哈希的。

有没有人有一个允许使用不可散列参数（例如字典）的实现（或对此进行了调整）？

我知道缺少哈希值意味着存在“这是在缓存中吗？”的问题。变得微不足道，但我只是想问一下。

===编辑以提供上下文===

我正在研究一个函数，该函数在给定模块字典的情况下返回Parnas样式的“使用层次”：依赖项。设置如下：

def uses_hierarchy(requirements):
    """
    uses_hierarchy(requirements)

    Arguments:
    requirements - a dictionary of the form {mod: list of dependencies, }

    Return value:
    A dictionary of the form {level: list of mods, ...}

    Assumptions:
    - No cyclical requirements (e.g. if a requires b, b cannot require a).
    - Any dependency not listed as a mod assumed to be level 0.

    """

    levels = dict([(mod, _level(mod, requirements))
                   for mod in requirements.iterkeys()])
    reversed = dict([(value, []) for value in levels.itervalues()])
    for k, v in levels.iteritems():
        reversed[v].append(k)
    return reversed


def _level(mod, requirements):
    if not requirements.has_key(mod):
        return 0
    dependencies = requirements[mod]
    if not dependencies:
        return 0
    else:
        return max([_level(dependency, requirements)
                    for dependency in dependencies]) + 1

以便：

>>> requirements = {'a': [],
...                 'b': [],
...                 'c': ['a'],
...                 'd': ['a','b'],
...                 'e': ['c','d'],
...                 'f': ['e']
...                 }

>>> uses_hierarchy(requirements)
{0: ['a', 'b'], 1: ['c', 'd'], 2: ['e'], 3: ['f']}

_level是我要记住的功能，以使此设置更具可伸缩性。在没有备忘录的情况下实现时，它将多次计算依赖级别（例如，我在上面的示例中认为“ a”被计算了8次）。

谢谢，

麦克风

Answer 1

这是Alex Martelli Python Cookbook中的示例，展示了如何使用cPickle为带有可变参数（
原始版本 ）的函数创建备忘录装饰器：

import cPickle

class MemoizeMutable:
    def __init__(self, fn):
        self.fn = fn
        self.memo = {}
    def __call__(self, *args, **kwds):
        import cPickle
        str = cPickle.dumps(args, 1)+cPickle.dumps(kwds, 1)
        if not self.memo.has_key(str): 
            print "miss"  # DEBUG INFO
            self.memo[str] = self.fn(*args, **kwds)
        else:
            print "hit"  # DEBUG INFO

        return self.memo[str]

这是一个链接。

编辑： 使用您给定的代码和此备忘录装饰器：

_level = MemoizeMutable(_level)

equirements = {'a': [],
               'b': [],
               'c': ['a'],
               'd': ['a','b'],
               'e': ['c','d'],
               'f': ['e']
                 }

print uses_hierarchy(equirements)

我能够重现此：

miss
miss
hit
miss
miss
hit
miss
hit
hit
hit
miss
hit
{0: ['a', 'b'], 1: ['c', 'd'], 2: ['e'], 3: ['f']}