All 15 Descriptors & Properties questions
More in Descriptors & Properties
How would you convert an existing plain attribute into a property later, without breaking any existing code that reads or writes it directly? What is a descriptor, and which dunder methods define the descriptor protocol? What is the difference between a data descriptor and a non-data descriptor, and how does this affect attribute lookup priority? How does __set_name__ let a descriptor automatically learn the attribute name it's being assigned to on the owning class? How do you write a descriptor that behaves differently when accessed on the CLASS itself versus on an INSTANCE? How would you implement a type-validating descriptor that enforces a specific type constraint, reusable across multiple attributes and classes? How does Python's own implementation of instance methods use the descriptor protocol to achieve automatic 'self' binding? How do you implement a descriptor-based ORM-style field that lazily loads related data only when actually accessed? How would you write a descriptor supporting attribute DELETION via __delete__, and what real use case does that enable? How do properties and descriptors interact with __slots__, and what special consideration is needed?
Advertisement
Python › Descriptors & Properties

How would you implement a lazy, cached property using a custom descriptor (or functools.cached_property) that only computes its value once?

Advanced

Answer

functools.cached_property computes the decorated method's value on FIRST access, then STORES the result directly in the instance's __dict__ (overriding further descriptor-based lookups for that name, since instance __dict__ takes priority for non-data descriptors) — subsequent accesses skip recomputation entirely, unlike @property which recomputes every single time.
from functools import cached_property

class DataProcessor:
    def __init__(self, data):
        self.data = data
    @cached_property
    def expensive_summary(self):
        print("Computing...")
        return sum(self.data) / len(self.data)

dp = DataProcessor([1, 2, 3, 4, 5])
print(dp.expensive_summary)  # 'Computing...' printed, then 3.0
print(dp.expensive_summary)  # 3.0, NO 'Computing...' -- cached from __dict__
Real-world example Caching an expensive, rarely-changing computed value (like a parsed configuration or aggregated statistic) on first access.

Common follow-ups: Why does cached_property specifically require the CLASS to NOT use __slots__, unlike a regular @property?

Memory Management & Garbage Collection
All 15 Descriptors & Properties questions