Return Values, Scope, and Side Effects

By the end of this lesson you can say what a function gives back to its caller, name every value a function can see and change, and rewrite a printing function into a returning one so it becomes testable.

"It printed the right thing" and "it produced the right value" feel identical when you are watching a terminal, and they are completely different to everything downstream. A printed answer is gone. It cannot be stored, compared, re-formatted, written to a file, or checked by a test.

Almost every function in the capstone has to be tested, and Module 5 is where those tests get written. A function that prints instead of returning cannot be tested without awkward machinery, so this lesson is what makes the next one possible.

return value ends the function immediately and hands value back to the caller. A function with no return, or one that falls off the end, returns None. Any code after a return on the same path never runs.

print writes text to the screen and returns None. It is an output operation, not a way of producing an answer. result = print("hello") binds result to None, which is a real mistake people make once.

A function can return several values by returning a tuple, and the caller can unpack it in one line:

verdict, reason = judge(record)

Beyond two or three values, return a dictionary instead: names beat positions once a reader has to remember an order.

Scope decides which names are visible. Names created inside a function are local: they exist while the call runs and vanish when it returns. A function can read names defined at the top level of the file, which is how it sees constants. It cannot rebind them; an assignment inside a function creates a local name that shadows the outer one, and the outer value is untouched.

Reading a value in place is different from rebinding a name. A function that receives a list can call append on it and the caller sees the change, because both names refer to the same object. That is a side effect, and it is legal, useful, and the single most common source of surprise when reviewing someone else's function.

A pure function reads only its arguments and returns a value, changing nothing else. Pure functions are trivial to test: give inputs, compare the output. Prefer them for anything that computes a decision, and confine side effects, printing, writing files, mutating shared state, to a thin layer that a reader can see at a glance.

MINIMUM_VALUE = 100000


def score(record):
    """Return (points, notes). Pure: reads its argument and the module
    constant, changes nothing."""
    points = 0
    notes = "baseline"
    if record["estimated_value"] >= MINIMUM_VALUE:
        points += 2
        notes = "meets minimum"
    if record.get("set_aside") == "Total Small Business":
        points += 3
        notes = notes + "; category matches"
    return points, notes


def record_and_report(record, log):
    """Impure: appends to the caller's list, then returns nothing useful."""
    points, notes = score(record)
    log.append(record["notice_id"])
    print(f"{record['notice_id']}: {points} ({notes})")


entries = []
record_and_report(
    {"notice_id": "GSA-2026-0731", "estimated_value": 310000, "set_aside": "Total Small Business"},
    entries,
)
print(entries)
print(record_and_report({"notice_id": "A-2", "estimated_value": 10}, entries))

Two functions with deliberately different characters. score reads its argument and one module-level constant, and returns a pair. Nothing outside it changes, so a test can call it with a record and compare the result.

record_and_report does three things: computes, mutates the caller's list, and prints. It has no return, so it hands back None. Its usefulness lives entirely in its side effects, which is why the last print line looks so odd.

Predict all four lines of output.

GSA-2026-0731: 5 (meets minimum; category matches)
['GSA-2026-0731']
A-2: 0 (baseline)
None

Inside score, add the line MINIMUM_VALUE = 0 immediately before return points, notes. Predict what happens.

An assistant was asked for a function that returns the highest-value record in a batch. It produced this and said it returns the record for A-3.

def highest(batch):
    best = None
    for record in batch:
        if best is None or record["estimated_value"] > best["estimated_value"]:
            best = record
        return best


batch = [
    {"notice_id": "A-1", "estimated_value": 50000},
    {"notice_id": "A-2", "estimated_value": 90000},
    {"notice_id": "A-3", "estimated_value": 400000},
]

print(highest(batch)["notice_id"])

def highest(batch):
    best = None
    for record in batch:
        if best is None or record["estimated_value"] > best["estimated_value"]:
            best = record
    return best

The function below prints its answer. Change it to return the verdict and the reason, then print them at the call site in the exact shape the comment asks for.

Loading this exercise…

Optional: write a second function report(record) that calls your judge and prints the formatted line, so that judge stays pure and every side effect lives in report. Then write one sentence explaining which of the two you could test without capturing output. Separating a decision from its presentation is the structural move that Module 12's read-only interface depends on.

Sign in to track your progress on this exercise.

1. What does a function return when it has no return statement?
2. What is bound by result = print("hi")?
3. Can a function rebind a name defined at the top level of the file just by assigning to it?
4. Why is a pure function easier to test than one that prints?

Sign in to track your progress on this exercise.

return hands a value back and ends the call, print only writes to the screen, a missing return yields None, assigning to an outer name makes it local for the whole body, and pure functions are the ones you can test. Next: taking the shortlist script apart into named, contracted functions without changing a single behaviour.