Functions, Scope & the Call Stack

Think of a function as a sealed machine in your factory. Raw materials go in (parameters), it does internal work in private, and it drops a finished product out of the chute (return).

When you call a function, Python places a new tray (called a stack frame) on top of the Call Stack. When the function returns, its tray is popped off and recycled. Step through the simulation below:

When Python encounters a variable name like x, where does it look? It checks four nested rooms in strict order: Local ➔ Enclosing ➔ Global ➔ Built-in.

# Searching for "x" inside checkout():
# 1. Found right here in Local scope! Won't look any further.
def checkout():
    x = 100   # 📍 Local to checkout
    return x

x = 5
def test():
    x = 10
test()
print(x)

Python gives you unmatched flexibility when passing values into functions. Switch modes below to see how arguments bind:

Trap 1 — The Mutable Default Argument Bug. Never write def fn(cart=[]):. Default arguments are evaluated only ONCE when Python loads the file. Everyone shares the same list!

# ❌ THE TRAP: cart=[] evaluates ONCE when def is loaded!
def add_to_cart(item, cart=[]):
    cart.append(item)
    return cart

Trap 2 — Forgetting return. If you write print(result) instead of return result, your function hands back None to the caller.

Trap 3 — UnboundLocalError. If you try to read a global variable and then assign to it lower in the same function, Python marks it local for the entire function:

# ❌ UnboundLocalError: local variable 'count' referenced before assignment
count = 0
def bump():
    print(count)  # Python thinks count is local because of the line below!
    count = 1

Trap 4 — Infinite recursion (Stack Overflow). A function that calls itself without an exit condition pushes frames until Python halts with RecursionError: maximum recursion depth exceeded.

In production apps, long spaghetti scripts are broken down into small, single-responsibility functions. See how this modular checkout pipeline computes discounts and taxes cleanly:

def apply_discount(amount, code="NONE"):
    rates = {"SUMMER10": 0.10, "VIP20": 0.20}
    return amount * (1 - rates.get(code, 0.0))

def calculate_tax(amount, rate=0.18):
    return amount * rate

def build_order_receipt(subtotal, code="NONE"):
    discounted = apply_discount(subtotal, code)
    tax = calculate_tax(discounted)
    return {
        "subtotal": subtotal,
        "tax": round(tax, 2),
        "total": round(discounted + tax, 2),
    }

Test clean helper functions and data converters right in your browser with the Python Playground.

Answer all 5 architecture scenarios correctly to complete Chapter 5 and unlock your mastery badge!

tax_rate = 0.08
def total_with_tax(price):
    return price + price * tax_rate

print(total_with_tax(25))

1tax_rate = 0.08
2def total_with_tax(price):
3    return price + price * tax_rate
4 
5print(total_with_tax(25))

Run the code to see its output.

Try the full parameter-packing and pure function script in the Python Playground (code prefilled).

• Call Stack: Functions push frames when called and pop frames when returning (LIFO).
• LEGB Rule: Variable lookup travels Local ➔ Enclosing ➔ Global ➔ Built-in.
• Default parameters: Always use param=None for lists or dicts to avoid shared state.
• *args packs extra positional items into a tuple; **kwargs packs extra named items into a dict.
• Aim for Pure Functions: take inputs, return outputs, avoid mutating outside state.