25

类Foo有一个bar，并且在访问它之前不会加载。进一步访问bar应该不会产生开销。

class Foo(object):

    def get_bar(self):
        print "initializing"
        self.bar = "12345"
        self.get_bar = self._get_bar
        return self.bar

    def _get_bar(self):
        print "accessing"
        return self.bar

是否可以使用属性或更好的属性来做这样的事情，而不是使用 getter 方法？

目标是延迟加载，而不会对所有后续访问产生开销...

4

3 回答 3

18

目前的答案存在一些问题。具有属性的解决方案要求您指定一个额外的类属性，并且在每次查找时都要检查该属性。解决方案__getattr__的问题是在首次访问之前隐藏此属性。这不利于自省，并且解决方法__dir__不方便。

比两个提议的更好的解决方案是直接使用描述符。werkzeug 库已经有一个解决方案，如werkzeug.utils.cached_property. 它有一个简单的实现，因此您可以直接使用它而无需将 Werkzeug 作为依赖项：

_missing = object()

class cached_property(object):
    """A decorator that converts a function into a lazy property.  The
    function wrapped is called the first time to retrieve the result
    and then that calculated result is used the next time you access
    the value::

        class Foo(object):

            @cached_property
            def foo(self):
                # calculate something important here
                return 42

    The class has to have a `__dict__` in order for this property to
    work.
    """

    # implementation detail: this property is implemented as non-data
    # descriptor.  non-data descriptors are only invoked if there is
    # no entry with the same name in the instance's __dict__.
    # this allows us to completely get rid of the access function call
    # overhead.  If one choses to invoke __get__ by hand the property
    # will still work as expected because the lookup logic is replicated
    # in __get__ for manual invocation.

    def __init__(self, func, name=None, doc=None):
        self.__name__ = name or func.__name__
        self.__module__ = func.__module__
        self.__doc__ = doc or func.__doc__
        self.func = func

    def __get__(self, obj, type=None):
        if obj is None:
            return self
        value = obj.__dict__.get(self.__name__, _missing)
        if value is _missing:
            value = self.func(obj)
            obj.__dict__[self.__name__] = value
        return value
于 2013-07-05T11:15:51.700 回答
14

当然，只需让您的属性设置在后续访问时返回的实例属性：

class Foo(object):
    _cached_bar = None 

    @property
    def bar(self):
        if not self._cached_bar:
            self._cached_bar = self._get_expensive_bar_expression()
        return self._cached_bar

描述property符是一个数据描述符（它实现__get__和描述符钩子），因此即使实例上存在属性也会调用它__set__，最终结果是 Python 忽略该属性，因此需要测试一个单独的属性每次访问。__delete__bar

您可以编写自己的仅实现 的描述符，__get__此时 Python 在描述符上使用实例上的属性（如果存在）：

class CachedProperty(object):
    def __init__(self, func, name=None):
        self.func = func
        self.name = name if name is not None else func.__name__
        self.__doc__ = func.__doc__

    def __get__(self, instance, class_):
        if instance is None:
            return self
        res = self.func(instance)
        setattr(instance, self.name, res)
        return res

class Foo(object):
    @CachedProperty
    def bar(self):
        return self._get_expensive_bar_expression()

如果您更喜欢一种__getattr__方法（有话要说），那就是：

class Foo(object):
    def __getattr__(self, name):
        if name == 'bar':
            bar = self.bar = self._get_expensive_bar_expression()
            return bar
        return super(Foo, self).__getattr__(name)

后续访问会找到bar实例上的属性，__getattr__不会被查询。

演示：

>>> class FooExpensive(object):
...     def _get_expensive_bar_expression(self):
...         print 'Doing something expensive'
...         return 'Spam ham & eggs'
... 
>>> class FooProperty(FooExpensive):
...     _cached_bar = None 
...     @property
...     def bar(self):
...         if not self._cached_bar:
...             self._cached_bar = self._get_expensive_bar_expression()
...         return self._cached_bar
... 
>>> f = FooProperty()
>>> f.bar
Doing something expensive
'Spam ham & eggs'
>>> f.bar
'Spam ham & eggs'
>>> vars(f)
{'_cached_bar': 'Spam ham & eggs'}
>>> class FooDescriptor(FooExpensive):
...     bar = CachedProperty(FooExpensive._get_expensive_bar_expression, 'bar')
... 
>>> f = FooDescriptor()
>>> f.bar
Doing something expensive
'Spam ham & eggs'
>>> f.bar
'Spam ham & eggs'
>>> vars(f)
{'bar': 'Spam ham & eggs'}

>>> class FooGetAttr(FooExpensive):
...     def __getattr__(self, name):
...         if name == 'bar':
...             bar = self.bar = self._get_expensive_bar_expression()
...             return bar
...         return super(Foo, self).__getatt__(name)
... 
>>> f = FooGetAttr()
>>> f.bar
Doing something expensive
'Spam ham & eggs'
>>> f.bar
'Spam ham & eggs'
>>> vars(f)
{'bar': 'Spam ham & eggs'}
于 2013-07-05T10:04:05.130 回答
5

当然可以，试试：

class Foo(object):
    def __init__(self):
        self._bar = None # Initial value

    @property
    def bar(self):
        if self._bar is None:
            self._bar = HeavyObject()
        return self._bar

请注意，这不是线程安全的。cPython 有 GIL，所以这是一个相对的问题，但是如果您打算在真正的多线程 Python 堆栈（例如 Jython）中使用它，您可能希望实现某种形式的锁安全。

于 2013-07-05T10:08:04.610 回答