免责声明:我是kids.cache的作者。

你应该检查孩子。Cache，它提供了一个在python 2和python 3上工作的@cache装饰器。没有依赖关系，大约100行代码。它的使用非常简单，例如，在你的代码中，你可以这样使用:

pip install kids.cache

Then

from kids.cache import cache
...
class MyClass(object):
    ...
    @cache            # <-- That's all you need to do
    @property
    def name(self):
        return 1 + 1  # supposedly expensive calculation

或者你可以把@cache装饰器放在@属性之后(同样的结果)。

在属性上使用缓存被称为惰性求值。缓存可以做更多的事情(它适用于带有任何参数、属性、任何类型的方法，甚至是类的函数……)对于高级用户，儿童。cache支持cachetools，它为python 2和python 3提供了漂亮的缓存存储(LRU, LFU, TTL, RR缓存)。

重要提示:孩子的默认缓存存储。缓存是一个标准字典，不建议长时间运行具有不同查询的程序，因为它会导致缓存存储不断增长。对于这种用法，你可以使用插件其他缓存存储使用例如(@cache(use=cachetools.LRUCache(maxsize=2))来装饰你的函数/属性/类/方法…)

啊，只需要给这个找到一个正确的名字:“懒惰的属性评估”。

我也经常这样做;也许有一天我会在我的代码中使用这个配方。

在Python Wiki中还有另一个备忘录装饰器的例子:

http://wiki.python.org/moin/PythonDecoratorLibrary#Memoize

这个例子有点聪明，因为如果参数是可变的，它不会缓存结果。(检查代码，它非常简单和有趣!)

class memorize(dict):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args):
        return self[args]

    def __missing__(self, key):
        result = self[key] = self.func(*key)
        return result

示例使用:

>>> @memorize
... def foo(a, b):
...     return a * b
>>> foo(2, 4)
8
>>> foo
{(2, 4): 8}
>>> foo('hi', 3)
'hihihi'
>>> foo
{(2, 4): 8, ('hi', 3): 'hihihi'}

听起来好像您不是在要求一个通用的记忆化装饰器(也就是说，您对想要缓存不同参数值的返回值的一般情况不感兴趣)。也就是说，你想要这样:

x = obj.name  # expensive
y = obj.name  # cheap

而一个通用的记忆装饰器会给你这样的:

x = obj.name()  # expensive
y = obj.name()  # cheap

我认为方法调用语法是更好的风格，因为它暗示了昂贵计算的可能性，而属性语法暗示了快速查找。

[更新:我之前链接并引用的基于类的记忆化装饰器不适用于方法。我用decorator函数替换了它。如果你愿意使用通用的记忆装饰器，这里有一个简单的:

def memoize(function):
  memo = {}
  def wrapper(*args):
    if args in memo:
      return memo[args]
    else:
      rv = function(*args)
      memo[args] = rv
      return rv
  return wrapper

使用示例:

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

可以在这里找到另一个对缓存大小有限制的内存装饰器。

Python 3.8 functools。cached_property装饰

https://docs.python.org/dev/library/functools.html#functools.cached_property

来自Werkzeug的cached_property在:https://stackoverflow.com/a/5295190/895245上提到过，但据说派生版本将合并到3.8中，这是非常棒的。

这个装饰器可以被看作是缓存@property，或者是清洁器@functools。Lru_cache，当你没有任何参数时。

医生说:

@functools.cached_property(func) Transform a method of a class into a property whose value is computed once and then cached as a normal attribute for the life of the instance. Similar to property(), with the addition of caching. Useful for expensive computed properties of instances that are otherwise effectively immutable. Example: class DataSet: def __init__(self, sequence_of_numbers): self._data = sequence_of_numbers @cached_property def stdev(self): return statistics.stdev(self._data) @cached_property def variance(self): return statistics.variance(self._data) New in version 3.8. Note This decorator requires that the dict attribute on each instance be a mutable mapping. This means it will not work with some types, such as metaclasses (since the dict attributes on type instances are read-only proxies for the class namespace), and those that specify slots without including dict as one of the defined slots (as such classes don’t provide a dict attribute at all).