下面是一个解决方案，将工作与列表或dict类型参数没有抱怨:

def memoize(fn):
    """returns a memoized version of any function that can be called
    with the same list of arguments.
    Usage: foo = memoize(foo)"""

    def handle_item(x):
        if isinstance(x, dict):
            return make_tuple(sorted(x.items()))
        elif hasattr(x, '__iter__'):
            return make_tuple(x)
        else:
            return x

    def make_tuple(L):
        return tuple(handle_item(x) for x in L)

    def foo(*args, **kwargs):
        items_cache = make_tuple(sorted(kwargs.items()))
        args_cache = make_tuple(args)
        if (args_cache, items_cache) not in foo.past_calls:
            foo.past_calls[(args_cache, items_cache)] = fn(*args,**kwargs)
        return foo.past_calls[(args_cache, items_cache)]
    foo.past_calls = {}
    foo.__name__ = 'memoized_' + fn.__name__
    return foo

请注意，通过在handle_item中实现您自己的哈希函数，这种方法可以自然地扩展到任何对象。例如，为了使这种方法适用于一个接受set作为输入参数的函数，你可以在handle_item中添加:

if is_instance(x, set):
    return make_tuple(sorted(list(x)))

cache = {}
def fib(n):
    if n <= 1:
        return n
    else:
        if n not in cache:
            cache[n] = fib(n-1) + fib(n-2)
        return cache[n]

下面是一个解决方案，将工作与列表或dict类型参数没有抱怨:

def memoize(fn):
    """returns a memoized version of any function that can be called
    with the same list of arguments.
    Usage: foo = memoize(foo)"""

    def handle_item(x):
        if isinstance(x, dict):
            return make_tuple(sorted(x.items()))
        elif hasattr(x, '__iter__'):
            return make_tuple(x)
        else:
            return x

    def make_tuple(L):
        return tuple(handle_item(x) for x in L)

    def foo(*args, **kwargs):
        items_cache = make_tuple(sorted(kwargs.items()))
        args_cache = make_tuple(args)
        if (args_cache, items_cache) not in foo.past_calls:
            foo.past_calls[(args_cache, items_cache)] = fn(*args,**kwargs)
        return foo.past_calls[(args_cache, items_cache)]
    foo.past_calls = {}
    foo.__name__ = 'memoized_' + fn.__name__
    return foo

请注意，通过在handle_item中实现您自己的哈希函数，这种方法可以自然地扩展到任何对象。例如，为了使这种方法适用于一个接受set作为输入参数的函数，你可以在handle_item中添加:

if is_instance(x, set):
    return make_tuple(sorted(list(x)))

其他答案很好地涵盖了它的本质。我不是在重复。只是一些可能对你有用的观点。

通常，memoisation是一种可以应用在任何函数上的操作，该函数计算一些东西(昂贵的)并返回一个值。因此，它通常被实现为一个装饰器。实现很简单，大概是这样的

memoised_function = memoise(actual_function)

或者表示为装饰者

@memoise
def actual_function(arg1, arg2):
   #body

记忆是保留昂贵的计算结果并返回缓存的结果，而不是不断地重新计算它。

这里有一个例子:

def doSomeExpensiveCalculation(self, input):
    if input not in self.cache:
        <do expensive calculation>
        self.cache[input] = result
    return self.cache[input]

更完整的描述可以在维基百科关于记忆的条目中找到。

记忆实际上是指根据方法输入记住(“记忆”→“备忘录”→被记住)方法调用的结果，然后返回记住的结果，而不是重新计算结果。您可以把它看作是方法结果的缓存。更多详细信息，请参阅第387页的算法介绍(3e)， Cormen等人的定义。

在Python中使用内存计算阶乘的简单示例如下:

factorial_memo = {}
def factorial(k):
    if k < 2: return 1
    if k not in factorial_memo:
        factorial_memo[k] = k * factorial(k-1)
    return factorial_memo[k]

你可以做得更复杂一些，把记忆过程封装到一个类中:

class Memoize:
    def __init__(self, f):
        self.f = f
        self.memo = {}
    def __call__(self, *args):
        if not args in self.memo:
            self.memo[args] = self.f(*args)
        #Warning: You may wish to do a deepcopy here if returning objects
        return self.memo[args]

然后:

def factorial(k):
    if k < 2: return 1
    return k * factorial(k - 1)

factorial = Memoize(factorial)

Python 2.4中添加了一个被称为“装饰器”的特性，它允许你现在简单地编写以下代码来完成同样的事情:

@Memoize
def factorial(k):
    if k < 2: return 1
    return k * factorial(k - 1)

Python装饰器库有一个类似的装饰器，称为memoized，它比这里显示的Memoize类稍微健壮一些。