All 15 Descriptors & Properties questions
More in Descriptors & Properties
How would you implement a lazy, cached property using a custom descriptor (or functools.cached_property) that only computes its value once? 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 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? How would you use a WeakKeyDictionary inside a descriptor to store per-instance data without relying on the instance's own __dict__ or requiring a dedicated __slots__ entry? How does @property's read-only behavior (no setter defined) actually raise an AttributeError, and how would you customize that error message?
Advertisement
Python › Descriptors & Properties

How do you implement a descriptor-based ORM-style field that lazily loads related data only when actually accessed?

Advanced

Answer

Implement __get__ to check if the related data has already been fetched and cached on the instance; if not, perform the (potentially expensive) lookup, cache the result, and return it — this pattern underlies 'lazy loading' relationship fields in ORMs like Django and SQLAlchemy, deferring expensive queries until genuinely needed.
class LazyForeignKey:
    def __set_name__(self, owner, name):
        self.cache_name = f"_{name}_cache"
    def __get__(self, instance, owner):
        if instance is None:
            return self
        if not hasattr(instance, self.cache_name):
            related_id = getattr(instance, f"{self.name}_id")
            setattr(instance, self.cache_name, fetch_related_object(related_id))  # lazy DB query
        return getattr(instance, self.cache_name)
Real-world example Implementing a lazy-loaded relationship field (like Django's ForeignKey) that only queries the database when the related object is actually accessed.

Common follow-ups: What's the downside (N+1 query risk) of this lazy-loading pattern when accessed in a loop over many instances?

Debugging & Profiling
All 15 Descriptors & Properties questions