Python Functions and Scope Explained (2026)

Quick Answer: Python Functions and Scope

The Cart That Wouldn't Reset

A function adds an item to a shopping cart, defaulting to a fresh empty cart when none is provided:

def add_item(item, cart=[]):
    cart.append(item)
    return cart

print(add_item("shirt"))   # ['shirt']
print(add_item("shoes"))   # ['shirt', 'shoes'] — expected ['shoes']!

The second call looks like it should start fresh, since no cart was passed and the default is an empty list. It doesn't. Python evaluates default argument values exactly once — when the function is defined, not each time it's called — so cart=[] creates a single list object that every call sharing the default reuses and mutates. Three calls without an explicit cart don't produce three separate one-item lists; they produce one growing list, shared silently across unrelated calls.

Anatomy of a Function

A function bundles a block of logic behind a name, optionally taking input and optionally handing back a result.

def calculate_total(price, quantity, tax_rate=0.08):
    subtotal = price * quantity
    return subtotal * (1 + tax_rate)

total = calculate_total(19.99, 3)
print(total)

price and quantity are required — call the function without them and Python raises a TypeError. tax_rate has a default, making it optional; callers can override it or leave it as-is. The return statement is what hands a value back to whatever called the function — without one, the call site gets None.

The Mutable Default Argument: The Actual Fix

The standard, idiomatic fix: default to None, then create a genuinely new mutable object inside the function body only when needed.

def add_item(item, cart=None):
    if cart is None:
        cart = []   # a brand-new list, created fresh on every call
    cart.append(item)
    return cart

print(add_item("shirt"))   # ['shirt']
print(add_item("shoes"))   # ['shoes'] — correct, independent result

*args and **kwargs: Flexible Arguments

Sometimes a function genuinely doesn't know in advance how many arguments it'll receive — *args and **kwargs handle exactly that.

def summarize(*args, **kwargs):
    print("positional:", args)   # a tuple of unnamed arguments
    print("keyword:", kwargs)     # a dict of named arguments

summarize(1, 2, 3, name="Maria", active=True)
# positional: (1, 2, 3)
# keyword: {'name': 'Maria', 'active': True}

*args collects any extra positional arguments into a tuple; **kwargs collects extra named arguments into a dictionary. Both are common in general-purpose utility functions and wrapper functions that need to pass arguments through to something else without knowing their exact shape ahead of time.

Local vs Global Scope

A variable's scope determines where it's visible — and a function can read outer variables freely, but reassigning one takes explicit syntax.

counter = 0   # global scope

def increment_broken():
    counter = counter + 1   # UnboundLocalError — Python sees this as a new local variable

def increment_fixed():
    global counter
    counter = counter + 1   # explicitly modifies the global variable

Any name assigned to inside a function is treated as local to that function by default — even if a global variable with the same name already exists. Without the global keyword, increment_broken() doesn't modify the outer counter; it tries to create and use a local one before it's assigned, which raises an error. Relying on global heavily is generally a sign a function should take a parameter and return a value instead — but the keyword exists for the cases where it's genuinely needed.

return vs print: A Common Confusion

print() displays a value in the console. return hands a value back to whatever called the function, so it can actually be used in the rest of the program.

def double_broken(n):
    print(n * 2)   # only displays it — doesn't hand it back

def double_fixed(n):
    return n * 2   # hands the value back to the caller

result = double_broken(5)  # prints 10, but result is None
result = double_fixed(5)   # result is 10, usable in the rest of the program

double_broken looks like it works, because 10 does print — but result is None, since the function never actually returned anything. This is one of the quieter beginner bugs: the output looks right in isolation, and the failure only shows up later, when something tries to use result and gets None instead.

Mistakes That Give Away a Beginner

• Using a list or dict as a default argument. The exact trap from this article's opening — default to None instead.
• Confusing print() with return, then being surprised a variable holds None after calling a function that only printed its result.
• Assigning to a global variable inside a function without the global keyword, and hitting an UnboundLocalError.
• Overusing global state instead of passing values in as parameters and getting results back via return.
• Reaching for *args/**kwargs when a function's arguments are actually known and fixed, adding unnecessary flexibility and losing clarity.

Practice: Fix These Three Yourself

Frequently Asked Questions

Conclusion: Fundamentals Tier Complete

Functions package logic for reuse, and scope determines what that logic can see and change — the one rule worth carrying forward from this article is to never default a mutable argument to a shared list or dict. Default to None, create fresh inside the function body, keep global state to a minimum, and always return the value you actually intend the caller to use.

That closes out the fundamentals tier: variables and types, lists/tuples/dicts, control flow, and now functions and scope. The next article starts the intermediate tier with NumPy — the foundation everything in Pandas is built on.