如何在 Python 中创建有界记忆装饰器？

Question

显然，快速搜索会产生 Python 中记忆化装饰器的一百万种实现和风格。然而，我对一种我一直找不到的味道感兴趣。我希望存储值的缓存可以具有固定的容量。当添加新元素时，如果达到容量，则删除最旧的值并用最新的值替换。

我担心的是，如果我使用记忆化来存储大量元素，那么程序会因为内存不足而崩溃。 （我不知道这个问题在实践中是否合理。）如果缓存的大小是固定的，那么内存错误就不会成为问题。当程序执行时，我处理的许多问题都会发生变化，因此初始缓存值看起来与后来的缓存值非常不同（并且以后重现的可能性要小得多）。这就是为什么我希望用最新的东西取代最旧的东西。

我找到了 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)

编辑：根据本的建议，我创建了以下装饰器，我相信它按照我想象的方式工作。对我来说，能够在多处理中使用这些修饰函数非常重要，这在过去一直是一个问题。但对该代码的快速测试似乎工作正常，即使将作业分包给线程池也是如此。

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/< /a>

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

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

这相当于：

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

另外，我不确定是否会为此使用 OrderedDict，我会使用环形缓冲区，它们非常简单来实施。