Functions — Defining, Parameters, Return Values

def greet(name):
    print(f"Hello, {name}!")

greet("Maria")
greet("Jordan")

# Hello, Maria!
# Hello, Jordan!

def greet(name):        # "name" is a PARAMETER — part of the function's definition
    print(f"Hello, {name}!")

greet("Maria")           # "Maria" is an ARGUMENT — the actual value supplied at call time

def describe_pet(name, species, age):
    print(f"{name} is a {age}-year-old {species}")

describe_pet("Rex", "dog", 3)                             # positional — order matters
describe_pet(name="Rex", species="dog", age=3)             # keyword — order doesn't matter
describe_pet(age=3, name="Rex", species="dog")             # same result, reordered

describe_pet("Rex", age=3, species="dog")                  # mixing is fine —
# but positional arguments must always come before keyword arguments in the same call

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Maria")                    # Hello, Maria!            — uses the default
greet("Jordan", "Hi")              # Hi, Jordan!               — overrides the default
greet("Priya", greeting="Welcome") # Welcome, Priya!           — same, by keyword

def add_item(item, cart=[]):     # DANGER — a mutable default value
    cart.append(item)
    return cart

print(add_item("apple"))          # ['apple']
print(add_item("banana"))         # ['apple', 'banana']  — wait, what?
print(add_item("cherry"))         # ['apple', 'banana', 'cherry']  — it keeps growing!

# Every call that didn't pass its own "cart" is silently sharing
# the SAME list object, created exactly once, back when the function was defined.

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("apple"))    # ['apple']
print(add_item("banana"))   # ['banana']  — correct, independent lists

def total(*args):
    print(args)         # a tuple of everything passed in
    return sum(args)

total(1, 2, 3)         # (1, 2, 3)  -> 6
total(10, 20)           # (10, 20)   -> 30
total()                  # ()          -> 0

def build_profile(**kwargs):
    print(kwargs)        # a dict of every keyword argument passed in
    return kwargs

build_profile(name="Maria", age=28, city="Austin")
# {'name': 'Maria', 'age': 28, 'city': 'Austin'}

def log_event(event_name, *details, level="INFO", **metadata):
    print(f"[{level}] {event_name}")
    print("Details:", details)
    print("Metadata:", metadata)

log_event("user_login", "192.168.1.1", "mobile", level="WARNING", user_id=42, retries=2)
# [WARNING] user_login
# Details: ('192.168.1.1', 'mobile')
# Metadata: {'user_id': 42, 'retries': 2}

def add_print(a, b):
    print(a + b)      # only displays the result — does NOT hand it back

def add_return(a, b):
    return a + b       # hands the result back to the caller

result1 = add_print(2, 3)    # prints "5", but result1 is None — nothing was returned
result2 = add_return(2, 3)    # prints nothing, but result2 is 5

print(result1)   # None
print(result2)   # 5

def log_message(msg):
    print(f"LOG: {msg}")
    # no return statement at all

result = log_message("Server started")
print(result)   # None — the function's job was printing, not producing a value

def get_min_max(numbers):
    return min(numbers), max(numbers)   # this is actually returning ONE tuple: (min, max)

lowest, highest = get_min_max([4, 8, 15, 16, 23, 42])
print(lowest)    # 4
print(highest)   # 42

# You can also just capture the whole tuple directly:
result = get_min_max([4, 8, 15, 16, 23, 42])
print(result)     # (4, 42)

def check_age(age):
    if age < 0:
        return "Invalid age"
    if age < 18:
        return "Minor"
    return "Adult"
    print("This line never runs")   # unreachable — return already exited the function

print(check_age(25))   # Adult

def calculate_discount(price, percent):
    """
    Calculate the price after applying a percentage discount.

    Args:
        price: The original price, as a float.
        percent: The discount percentage (0-100).

    Returns:
        The discounted price, as a float.
    """
    return price * (1 - percent / 100)

help(calculate_discount)   # prints the docstring above, formatted, to the terminal
print(calculate_discount.__doc__)   # accesses the raw docstring directly

def calculate_total():
    subtotal = 100     # local to calculate_total — exists only during this call
    tax = subtotal * 0.08
    return subtotal + tax

result = calculate_total()
print(result)      # 108.0
print(subtotal)     # NameError: name 'subtotal' is not defined
                      # "subtotal" never existed outside calculate_total in the first place

discount_rate = 0.10    # global

def apply_discount(price):
    return price * (1 - discount_rate)   # reading the global — this just works

print(apply_discount(100))   # 90.0

counter = 0

def increment():
    counter += 1     # UnboundLocalError!
    return counter

# Python sees "counter = ..." anywhere inside the function and treats "counter"
# as a NEW local variable for the ENTIRE function body — even on lines before
# the assignment. Since counter += 1 needs to read counter before writing it,
# and Python has already decided counter is local (and therefore not yet
# assigned at that point), this fails.

counter = 0

def increment():
    global counter    # tells Python: "counter" here refers to the global, not a new local
    counter += 1
    return counter

print(increment())   # 1
print(increment())   # 2
print(counter)         # 2 — the global itself was actually modified

A customer support ticket comes in at an Austin concert-ticketing startup: a customer says their checkout shows promo codes they never entered, applied to an order that should have had none. Within an hour, three more nearly identical tickets arrive. The order totals are wrong, and the discrepancy is growing — this looks, at first glance, like it might be a security issue.

What the engineer finds

The checkout function that assembles a customer's applied promo codes has exactly the shape shown in Part 02 above — a mutable default argument.

def build_checkout(customer_id, promo_codes=[]):
    promo_codes.append("WELCOME10")   # auto-applies a standing welcome discount
    return {"customer_id": customer_id, "codes": promo_codes}

Every call that does not explicitly pass its own promo_codes list shares the exact same list object — created once, when the server process started and the function was defined, not once per request. Each checkout appends "WELCOME10" to that shared list and never clears it, so the list grows across every request the server handles, and every customer after the first one sees an ever-growing list of codes that were never theirs.

The fix, and why it mattered more than usual

def build_checkout(customer_id, promo_codes=None):
    if promo_codes is None:
        promo_codes = []
    promo_codes.append("WELCOME10")
    return {"customer_id": customer_id, "codes": promo_codes}

This bug is genuinely dangerous in a way many bugs are not, precisely because of where it hid: a long-running server process calls the same function thousands of times without ever restarting, so the shared mutable default keeps accumulating state across completely unrelated customers' requests for as long as the process stays up. A quick local test — calling the function once or twice and restarting the script each time — would never have surfaced it, which is exactly why this class of bug tends to reach production before anyone notices.