Passing State Between Functions

When several functions need to work with the same evolving state, where should that state actually live? This session is about ownership, not just passing values around.

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 — State Ownership Between Functions

Shared state is visible everywhere it is referenced

This session applies Session 05's reference lesson directly to whole objects passed between functions — a natural consequence of everything already learned, formalized as a design principle.

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

def search(explorer, term):
    return [c for c in explorer.countries if term.lower() in c.name.lower()]

def add_sample_data(explorer):
    explorer.countries.append(Country(name="Kenya", region="Africa", population=54000000))

explorer = CountryExplorer(countries=[])
add_sample_data(explorer)
print(search(explorer, "ken"))  # finds Kenya — both functions see the SAME explorer

Mutation vs reassignment — a subtle but important distinction

Mutating an object through a function parameter is visible to the caller. Reassigning what the local parameter name points to is NOT — the caller's original reference is untouched.

def mutate_countries(explorer):
    explorer.countries.append(Country(name="Ghana", region="Africa", population=31000000))
    # visible to the caller — same object, contents changed

def reassign_explorer(explorer):
    explorer = CountryExplorer(countries=[])
    # NOT visible to the caller — this only rebinds the LOCAL name "explorer"
    # to a brand new object; the caller's original variable is untouched

original = CountryExplorer(countries=[])
mutate_countries(original)
print(len(original.countries))    # 1

reassign_explorer(original)
print(len(original.countries))    # still 1 — the reassignment inside the function had no effect here

Deciding who owns state

Local, private data that only one function cares about should be owned locally. Data that multiple functions need to coordinate around should be passed in explicitly, so everyone works from the same source of truth.

# Risky — two functions each keep their OWN separate list, meant to represent the same thing
loaded_a = []
loaded_b = []

def load_into_a():
    loaded_a.append("Kenya")

def report_from_b():
    print(loaded_b)  # never sees "Kenya" — these are two DIFFERENT lists!

# Better — one owner, shared and passed explicitly
class Loader:
    def __init__(self):
        self.loaded = []

    def load(self, name):
        self.loaded.append(name)

    def report(self):
        print(self.loaded)  # always sees everything loaded through THIS instance

Bundling scattered local state into a small owning class

When a menu (Session 22) accumulates several loose local variables that all need to travel together between functions, wrapping them in a small class — exactly like Session 12's original motivation — gives them a clear, shared owner.

4. Lab

What you will build

A file called state_passing_lab.py.

Step-by-step instructions

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

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

def search(explorer, term):
    return [c for c in explorer.countries if term.lower() in c.name.lower()]

def add_sample_data(explorer):
    explorer.countries.append(Country(name="Kenya", region="Africa", population=54000000))

explorer = CountryExplorer(countries=[])
add_sample_data(explorer)
print(search(explorer, "ken"))

def mutate_countries(exp):
    exp.countries.append(Country(name="Ghana", region="Africa", population=31000000))

def reassign_explorer(exp):
    exp = CountryExplorer(countries=[])  # only rebinds the local name

mutate_countries(explorer)
print("After mutate:", len(explorer.countries))     # 2

reassign_explorer(explorer)
print("After reassign attempt:", len(explorer.countries))  # still 2

class MenuState:
    def __init__(self, explorer):
        self.explorer = explorer
        self.last_search_term = None
        self.action_count = 0

    def run_search(self, term):
        self.last_search_term = term
        self.action_count += 1
        return search(self.explorer, term)

def report(state):
    print("Last search:", state.last_search_term)
    print("Actions taken:", state.action_count)

state = MenuState(explorer)
state.run_search("gh")
report(state)  # sees the search performed by run_search, because it's the SAME state object

5. Expected Files Changed

6. Commit Checkpoint

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

git add state_passing_lab.py docs/sessions/session-25/index.html
git commit -m "session-25: pass shared state explicitly between functions via one owning object"

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