Question

显然，快速搜索会在Python中产生一百万个memoization装饰器的实现和风格。但是，我感兴趣的是一种我无法找到的味道。我希望它能够使存储值的缓存具有固定容量。添加新元素时，如果达到容量，则删除最旧的值并替换为最新值。

我担心的是，如果我使用memoization来存储很多元素，那么程序会因为缺少内存而崩溃。（我不知道这种担忧在实践中有多好。）如果缓存的大小固定，那么内存错误就不是问题。我工作的许多问题随着程序的执行而发生变化，因此初始缓存的值看起来与以后的缓存值非常不同（以后不太可能再次发生）。这就是为什么我希望用最新的东西取代最古老的东西。

我找到了OrderedDict类，并展示了如何将其子类化以指定最大大小的示例。我想将它用作我的缓存，而不是普通的dict。问题是，我需要memoize装饰器来获取一个名为maxlen的参数，默认为None。如果它是None，那么缓存是无限的并且正常运行。任何其他值都用作缓存的大小。

我希望它能像以下一样工作：

@memoize
def some_function(spam, eggs):
    # This would use the boundless cache.
    pass

和

@memoize(200)  # or @memoize(maxlen=200)
def some_function(spam, eggs):
    # This would use the bounded cache of size 200.
    pass

下面是我到目前为止的代码，但是我没有看到如何将参数传递给装饰器，同时使它既“裸”又带参数。

import collections
import functools

class BoundedOrderedDict(collections.OrderedDict):
    def __init__(self, *args, **kwds):
        self.maxlen = kwds.pop("maxlen", None)
        collections.OrderedDict.__init__(self, *args, **kwds)
        self._checklen()

    def __setitem__(self, key, value):
        collections.OrderedDict.__setitem__(self, key, value)
        self._checklen()

    def _checklen(self):
        if self.maxlen is not None:
            while len(self) > self.maxlen:
                self.popitem(last=False)

def memoize(function):
    cache = BoundedOrderedDict()  # I want this to take maxlen as an argument
    @functools.wraps(function)
    def memo_target(*args):
        lookup_value = args
        if lookup_value not in cache:
            cache[lookup_value] = function(*args)
        return cache[lookup_value]
    return memo_target

@memoize
def fib(n):
    if n < 2: return 1
    return fib(n-1) + fib(n-2)

if __name__ == '__main__':
    x = fib(50)
    print(x)

编辑：使用Ben的建议，我创建了以下装饰器，我相信它的工作方式与我想象的一样。能够将这些装饰函数与multiprocessing一起使用对我来说很重要，这在过去一直是个问题。但是对这段代码的快速测试似乎可以正常工作，即使将工作分配到一堆线程中也是如此。

def memoize(func=None, maxlen=None):
    if func:
        cache = BoundedOrderedDict(maxlen=maxlen)
        @functools.wraps(func)
        def memo_target(*args):
            lookup_value = args
            if lookup_value not in cache:
                cache[lookup_value] = func(*args)
            return cache[lookup_value]
        return memo_target
    else:
        def memoize_factory(func):
            return memoize(func, maxlen=maxlen)
        return memoize_factory

Answer 1

@memoize
def some_function(spam, eggs):
    # This would use the boundless cache.
    pass

这里memoize用作在单个函数参数上调用的函数，并返回一个函数。 memoize是装饰者。

@memoize(200)  # or @memoize(maxlen=200)
def some_function(spam, eggs):
    # This would use the bounded cache of size 200.
    pass

这里memoize用作在单个整数参数上调用的函数并返回一个函数，返回的函数本身用作装饰器，即在单个函数参数上调用它并返回一个函数。 memoize是装饰工厂。

所以要统一这两个，你将不得不写一些丑陋的代码。我可能会这样做的方法是让memoize看起来像这样：

def memoize(func=None, maxlen=None):
    if func:
        # act as decorator
    else:
        # act as decorator factory

这种方式如果你想传递参数，总是将它们作为关键字参数传递，留下func（应该是位置参数）未设置，如果你只想要一切都默认它会神奇地直接作为装饰者。这确实意味着@memoize(200)会给你一个错误;你可以避免这种做法，而是做一些类型检查，看看func是否可以调用，这在实践中应该运行良好，但实际上并不是非常“pythonic”。

另一种选择是拥有两个不同的装饰器，比如memoize和bounded_memoize。无限制的memoize可以通过调用bounded_memoize并将maxlen设置为None来实现简单的实现，因此在实施或维护方面不会花费任何费用。

通常作为经验法则，我试图避免修改一个函数来实现两个与切向相关的功能集，特别是，当它们具有不同的签名时。但在这种情况下它确实使装饰器的使用是自然的（要求@memoize()非常容易出错，即使它从理论角度来看更加一致），并且你可能是要实现这一次并多次使用它，因此在使用时的可读性可能是更重要的问题。

Answer 2

你想要写一个带有参数的装饰器（BoundedOrderedDict的最大长度）并返回一个装饰器，它将使用适当大小的BoundedOrderedDict来记忆你的函数：

def boundedMemoize(maxCacheLen):
    def memoize(function):
        cache = BoundedOrderedDict(maxlen = maxCacheLen)
        def memo_target(*args):
            lookup_value = args
            if lookup_value not in cache:
                cache[lookup_value] = function(*args)
            return cache[lookup_value]
        return memo_target
    return memoize

你可以像这样使用它：

@boundedMemoize(100)
def fib(n):
    if n < 2: return 1
    return fib(n - 1) + fib(n - 2)

编辑：哎呀，错过了部分问题。如果你想让装饰器的maxlen参数是可选的，你可以这样做：

def boundedMemoize(arg):
    if callable(arg):
        cache = BoundedOrderedDict()
        @functools.wraps(arg)
        def memo_target(*args):
            lookup_value = args
            if lookup_value not in cache:
                cache[lookup_value] = arg(*args)
            return cache[lookup_value]
        return memo_target

    if isinstance(arg, int):
        def memoize(function):
            cache = BoundedOrderedDict(maxlen = arg)
            @functools.wraps(function)
            def memo_target(*args):
                lookup_value = args
                if lookup_value not in cache:
                    cache[lookup_value] = function(*args)
                return cache[lookup_value]
            return memo_target
        return memoize

Answer 3

来自http://www.python.org/dev/peps/pep-0318/

当前语法还允许装饰器声明调用返回装饰器的函数：

@decomaker(argA, argB, ...)
def func(arg1, arg2, ...):
    pass

这相当于：

func = decomaker(argA, argB, ...)(func)

另外，我不确定我是否会使用OrderedDict，我会使用Ring Buffer，它们很容易实现。

如何在Python中创建有界的memoization装饰器？

3 个答案: