8

显然，快速搜索会产生一百万种 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
4

3 回答 3

4 
@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可以通过调用set to 来实现微不足道的实现bounded_memoize，因此在实现或维护方面不会花费您任何费用。maxlenNone

通常，根据经验，我会尽量避免修改一个函数来实现两个仅相切相关的功能集，尤其是当它们具有如此不同的签名时。但是在这种情况下，它确实使装饰器的使用是自然的（要求@memoize()很容易出错，即使从理论角度来看它更一致），并且您可能会实现一次并多次使用它，所以使用时的可读性可能是更重要的问题。

于 2012-02-22T05:13:15.893 回答
0

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

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
于 2012-02-22T05:21:43.337 回答
-2

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

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

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

这相当于：

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

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

于 2012-02-22T05:13:07.557 回答