python - 在对象中存储计算值

Question

最近我一直在写一堆这样的代码:

class A:
  def __init__(self, x):
    self.x = x
    self._y = None

  def y(self):
    if self._y is None:
      self._y = big_scary_function(self.x)

    return self._y

  def z(self, i):
    return nice_easy_function(self.y(), i)

在给定的类中，我可能有许多像 y 这样工作的东西，我可能还有其他使用存储的预先计算值的东西。这是做事的最佳方式还是您会推荐一些不同的方式？

请注意，我没有在这里进行预先计算，因为您可能会在不使用 y 的情况下使用 A 的实例。

我已经用 Python 编写了示例代码，但如果相关的话，我会对特定于其他语言的答案感兴趣。相反，我想听听 Pythonistas 是否认为这段代码是 Pythonic 的。

Answer 1

第一件事:这是 Python 中非常常见的模式(在某处甚至有一个 cached_property 描述符类 - 在 Django IIRC 中)。

据说这里至少有两个潜在问题。

第一个是所有“缓存属性”实现所共有的事实，即人们通常不希望属性访问触发一些繁重的计算。这是否真的是一个问题取决于上下文(以及读者近乎宗教的观点......)

第二个问题 - 更具体到你的例子 - 是传统的缓存失效/状态一致性问题:这里你有 y 作为 x 的函数 - 或者至少这就是人们所期望的——但是重新绑定(bind) x 不会相应地更新 y。在这种情况下，通过使 x 也成为一个属性并使 setter 上的 _y 无效，可以很容易地解决这个问题，但随后您会发生更多意想不到的繁重计算。

在这种情况下(并且取决于上下文和计算成本)我可能会保留内存(带有无效)但提供更明确的 getter 以表明我们可能正在进行一些计算。

编辑:我误读了您的代码并在 y 上想象了一个属性装饰器 - 这表明这种模式是多么普遍;)。但是当“自称 pythonista”发表支持计算属性的答案时，我的言论仍然有意义。

编辑:如果你想要一个或多或少通用的“带缓存失效的缓存属性”，这里有一个可能的实现(可能需要更多测试等):

class cached_property(object):
    """
    Descriptor that converts a method with a single self argument 
    into a property cached on the instance.

    It also has a hook to allow for another property setter to
    invalidated the cache, cf the `Square` class below for
    an example.
    """
    def __init__(self, func):
        self.func = func
        self.__doc__ = getattr(func, '__doc__')
        self.name = self.encode_name(func.__name__)

    def __get__(self, instance, type=None):
        if instance is None:
            return self
        if self.name not in instance.__dict__:
            instance.__dict__[self.name] = self.func(instance)
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        raise AttributeError("attribute is read-only")

    @classmethod
    def encode_name(cls, name):
        return "_p_cached_{}".format(name)

    @classmethod
    def clear_cached(cls, instance, *names):
        for name in names:
            cached = cls.encode_name(name)
            if cached in instance.__dict__:
                del instance.__dict__[cached]

    @classmethod
    def invalidate(cls, *names):
        def _invalidate(setter):
            def _setter(instance, value):
                cls.clear_cached(instance, *names)
                return setter(instance, value)
            _setter.__name__ = setter.__name__
            _setter.__doc__ =  getattr(setter, '__doc__')
            return _setter
        return _invalidate



class Square(object):
    def __init__(self, size):
        self._size = size

    @cached_property
    def area(self):
        return self.size * self.size

    @property
    def size(self):
        return self._size

    @size.setter
    @cached_property.invalidate("area")
    def size(self, size):
        self._size = size

并不是说我认为增加的认知开销实际上物有所值 - 大多数情况下，简单的内联实现使代码更易于理解和维护(并且不需要更多的 LOC) - 但它仍然可能有用如果一个包需要大量的缓存属性和缓存失效。