Attribute Access Laziness

Introduction

Welcome back to The Python Data Model & Protocols! We've now reached our fourth and final lesson in this course, and we're about to complete our journey through Python's core protocols and advanced language features. Great work! Throughout our previous lessons, we've explored how Python's data model provides elegant solutions to common programming challenges. We built robust value types with dunder methods, created memory-efficient data pipelines with generators, and implemented reliable resource management with context managers. Today, we're diving into another powerful aspect of Python's object model: attribute access and lazy loading . Attribute access in Python is more sophisticated than simple field lookup. We can intercept attribute requests, compute values on demand, and even create attributes that don't exist until someone asks for them. Combined with lazy loading patterns, these techniques enable us to build objects that are both memory-efficient and responsive, fetching expensive data only when needed and caching results for future use. We'll enhance our Money class from the first lesson, adding sophisticated features like lazy-loaded exchange rates and dynamic attributes. By the end of this lesson, our value type will demonstrate advanced attribute handling while maintaining the clean interface that makes Python objects so pleasant to work with.

Understanding Lazy Loading and Attribute Access

Before implementing advanced attribute behavior, let's understand why lazy loading matters and how Python's attribute access system works. In many applications, objects hold references to expensive-to-compute or expensive-to-fetch data that may never be used. Loading everything eagerly wastes time and memory. Lazy loading solves this by deferring computation until the moment someone actually needs the data. Python properties provide an elegant way to implement this pattern: we can make attribute access appear simple to users while hiding complex logic behind the scenes. When combined with caching, we get the best of both worlds: on-demand computation with the performance of pre-computed values for subsequent access. Python's attribute lookup process also provides hooks like__getattr__that let us create dynamic attributes. This method only gets called when normal attribute lookup fails, allowing us to compute and return values for attributes that don't exist in the object's dir() . This creates powerful interfaces where objects can respond to attribute requests they've never seen before.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Python

@total_ordering
class Money:
    """
    A value object representing an amount in a currency.

    This extends the Unit 1 Money with:
      - usd_rate: lazy, cached exchange-rate property
      - in_usd: convenience property to convert to USD
      - __getattr__: dynamic 'cents' attribute
    """
    _fetch_calls = 0  # counts simulated API fetches (for demonstration)

    def __init__(self, amount: Any, currency: str) -> None:
        cur = str(currency).upper()
        if len(cur) != 3 or not cur.isalpha():
            raise ValueError("Currency must be a 3-letter code like 'USD'")
        q = Decimal("0.01")
        self._amount = _to_decimal(amount).quantize(q, rounding=ROUND_HALF_EVEN)
        self._currency = cur
        self._usd_rate: Decimal | None = None  # lazy cache

Python

    @property
    def amount(self) -> Decimal:
        return self._amount

    @property
    def currency(self) -> str:
        return self._currency

Python

    @property
    def usd_rate(self) -> Decimal:
        """
        Lazily fetch and cache the exchange rate to USD for this currency.
        """
        if self._usd_rate is None:
            self._usd_rate = self._fetch_rate(self.currency)
        return self._usd_rate

Python

    @classmethod
    def _fetch_rate(cls, currency: str) -> Decimal:
        # Simulated external lookup with small latency and stable rates.
        cls._fetch_calls += 1
        time.sleep(0.005)
        table = {
            "USD": Decimal("1.00"),
            "EUR": Decimal("1.08"),
            "GBP": Decimal("1.27"),
            "JPY": Decimal("0.0067"),
        }
        try:
            return table[currency]
        except KeyError as e:
            raise ValueError(f"Unsupported currency: {currency}") from e

Python

    def __getattr__(self, name: str) -> int:
        """
        Provide a dynamic 'cents' attribute (computed on access).
        Only called if normal attribute lookup fails.
        """
        if name == "cents":
            return int((self.amount * Decimal("100")).to_integral_value())
        raise AttributeError(name)

Python

    @property
    def in_usd(self) -> "Money":
        usd_amount = (self.amount * self.usd_rate).quantize(
            Decimal("0.01"), rounding=ROUND_HALF_EVEN
        )
        return Money(usd_amount, "USD")

Python

if __name__ == "__main__":
    m = Money("10.00", "eur")

    # Lazy usd_rate is fetched once; subsequent use is cached.
    print(str(m.in_usd))  # triggers fetch
    print(str(m.in_usd))  # uses cached rate
    print(Money._fetch_calls)  # should be 1

    # Dynamic attribute via __getattr__
    print(dir(m))  # Show available attributes and methods
    print(m.cents)

text

10.80 USD
10.80 USD
1
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattr__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_amount', '_currency', '_fetch_calls', '_fetch_rate', '_usd_rate', 'amount', 'currency', 'in_usd', 'usd_rate']
1000

Introduction

Understanding Lazy Loading and Attribute Access

Join the 1M+ learners on CodeSignal

Building the Enhanced Money Class

Exposing Read-Only Attributes

The Lazy Property Pattern

Implementing Cached Exchange Rates

Dynamic Attributes with getattr

Convenient Currency Conversion

Demonstrating the Complete System

Observing the System in Action

Conclusion and Next Steps

Attribute Access Laziness

Introduction

Understanding Lazy Loading and Attribute Access

Join the 1M+ learners on CodeSignal

Building the Enhanced Money Class

Exposing Read-Only Attributes

The Lazy Property Pattern

Implementing Cached Exchange Rates

Dynamic Attributes with __getattr__

Convenient Currency Conversion

Demonstrating the Complete System

Observing the System in Action

Conclusion and Next Steps

Dynamic Attributes with getattr