Computed Properties

This is the Layer 3 gate. Some values should never be stored as their own piece of state — they should be computed fresh, every time, from state that already exists.

1. Learning Objective

2. Pre-Coding Quiz

Answer these before reading the concept explanation or writing any code. It is fine to get these wrong — that is the point. You need 4/5 to proceed to the lab.

3. The Concept — Computed Properties

The redundant-state problem

Storing a value that can always be recalculated from other state creates a duplication risk: the two copies can drift out of sync the moment one is updated without the other.

class CountryExplorer:
    def __init__(self, countries):
        self.countries = countries
        self.country_count = len(countries)  # RISKY — a separate, stored copy

    def add_country(self, country):
        self.countries.append(country)
        # Forgot to update self.country_count here!
        # Now it silently disagrees with the real length.

explorer = CountryExplorer(countries=[])
explorer.add_country(Country(name="Kenya", region="Africa", population=54000000))
print(explorer.country_count)      # 0 — WRONG, still the stale initial value
print(len(explorer.countries))     # 1 — the actual truth

The fix — compute it, don't store it

A method that recalculates the value from the real source of truth every time it is called has nothing to forget to update — it is always correct by construction.

class CountryExplorer:
    def __init__(self, countries):
        self.countries = countries  # the ONLY source of truth

    def country_count(self):
        return len(self.countries)  # always recalculated fresh, cannot drift

    def add_country(self, country):
        self.countries.append(country)

explorer = CountryExplorer(countries=[])
explorer.add_country(Country(name="Kenya", region="Africa", population=54000000))
print(explorer.country_count())  # 1 — always correct, nothing to forget

@property — attribute-style access for a computed value

When a computed value conceptually feels like a property of the object rather than an action, @property lets callers read it without parentheses, exactly like a stored attribute — while still guaranteeing it is always freshly derived.

class CountryExplorer:
    def __init__(self, countries):
        self.countries = countries

    @property
    def country_count(self):
        return len(self.countries)

    @property
    def total_population(self):
        return sum(c.population for c in self.countries)

explorer = CountryExplorer(countries=[
    Country(name="Kenya", region="Africa", population=54000000),
    Country(name="Peru", region="Americas", population=33000000),
])
print(explorer.country_count)      # 2 — no parentheses, reads like an attribute
print(explorer.total_population)   # 87000000 — freshly computed every access

When NOT to use a computed property

A value that is genuinely independent — not derivable from other state — belongs as real, stored state. population itself cannot be computed from anything else; it IS the source of truth, changed only through the controlled methods from Session 21.

4. Lab

What you will build

A file called computed_lab.py.

Step-by-step instructions

# computed_lab.py
class Country:
    def __init__(self, name, region, population):
        self.name = name
        self.region = region
        self.population = population


class RiskyExplorer:
    def __init__(self, countries):
        self.countries = countries
        self.country_count = len(countries)   # stored, can drift
        self.total_population = sum(c.population for c in countries)  # stored, can drift

    def add_country(self, country):
        self.countries.append(country)
        # deliberately NOT updating country_count or total_population

risky = RiskyExplorer(countries=[Country(name="Kenya", region="Africa", population=54000000)])
risky.add_country(Country(name="Peru", region="Americas", population=33000000))
print("Stored count (WRONG):", risky.country_count)          # still 1
print("Real count:", len(risky.countries))                    # 2
print("Stored population (WRONG):", risky.total_population)   # still 54000000

class CountryExplorer:
    def __init__(self, countries):
        self.countries = countries

    def add_country(self, country):
        self.countries.append(country)

    @property
    def country_count(self):
        return len(self.countries)

    @property
    def total_population(self):
        return sum(c.population for c in self.countries)

explorer = CountryExplorer(countries=[Country(name="Kenya", region="Africa", population=54000000)])
explorer.add_country(Country(name="Peru", region="Americas", population=33000000))
print("Computed count:", explorer.country_count)          # 2 — correct
print("Computed population:", explorer.total_population)  # 87000000 — correct

5. Expected Files Changed

6. Commit Checkpoint

Once the lab is complete and you can explain every line, make this exact commit:

git add computed_lab.py docs/sessions/session-26/index.html
git commit -m "session-26: replace stored derived state with @property computed values"

7. Code Review Checklist

Go through your code line by line and check each item:

8. Post-Coding Quiz

Same 5 questions. Take it again now that you have written and run the code. You need 4/5 to mark this session complete.

9. Reflection Questions

Think through these after the post-quiz. No right answer — they are for discussion.

10. What Breaks If This Knowledge Is Missing?

11. What We Learned