Exercises — Functions — def, parameters, return, docstrings

• Keyword that starts the definition ::: def
• Parameter ::: x (the placeholder name in the def line)
• Docstring ::: """Return x multiplied by three.""" — the first string literal directly under def.

What we did: matched each word in the box-picture to its job. def opens the box, x is the top slot, the docstring is the sticker label on the side.

• 4 is an ::: argument — the real value that fills the slot named x.
• Value returned ::: 12, because 4 * 3 = 12.

Slot vs filling: x is the slot (parameter), 4 is what you pour into it (argument).

def rectangle_area(width, height):
    """Return the area of a rectangle: width times height."""
    return width * height

rectangle_area(3, 4) → ::: 12.

What / Why / What it looks like: we used return (not print) so the caller can do more math with the answer, e.g. total = rectangle_area(3, 4) + 5. In the box picture, 12 falls out the bottom — it does not merely appear on the screen.

def to_celsius(f):
    """Return the Celsius value for a Fahrenheit temperature f."""
    return (f - 32) * 5 / 9

• to_celsius(212) ::: 100.0 — boiling water.
• to_celsius(32) ::: 0.0 — freezing water.

Why / 9 and not // 9? We want the exact fractional result, so we use ordinary division / (which returns a float). Integer division // would throw away the fractional part and give wrong answers for temperatures that don't divide evenly.

It prints two lines:

a
None

::: a comes from the print("a") inside f. Then f has no return, so the call f() evaluates to None; x = None; print(x) shows None.

Why: printing and returning are separate channels. f uses the display channel (print) but leaves the return channel empty → None.

positive
still running
not positive

::: For g(5): 5 > 0 is true, so return "positive" fires and the function exits immediately — the print("still running") line is never reached. For g(-2): -2 > 0 is false, we skip the first return, run print("still running"), then return "not positive".

What it looks like in the box: return is a trapdoor. Once you fall through it, no code below on that path runs. The -2 path takes a different route through the box, hitting the print on the way.

• p ::: 9
• q ::: 81

Why: return a, a * a packs the two values into a tuple (9, 81). The line p, q = h(9) then unpacks that tuple — first slot to p, second to q. (See Lists and Tuples for packing/unpacking.)

def power(base, exp=2):
    """Return base raised to exp; squares by default."""
    return base ** exp

• power(5) ::: 25 — exp omitted, so the default 2 is used: $5^2$.
• power(2, 3) ::: 8 — 3 fills exp by position: $2^3$.
• power(exp=3, base=2) ::: 8 — keyword arguments match by name, so order doesn't matter: $2^3$.

Why defaults exist: they let one definition serve both "the common case" (squaring) and "the general case" without forcing the caller to always spell out exp.

def clamp(x, low=0, high=10):
    """Return x limited to the range [low, high]."""
    if x < low:
        return low
    if x > high:
        return high
    return x

• clamp(5) ::: 5 — already inside [0, 10].
• clamp(-3) ::: 0 — below low, snapped up to 0.
• clamp(99) ::: 10 — above high, snapped down to 10.
• clamp(5, low=6) ::: 6 — now 5 < 6, so it snaps up to the new low.

Why three returns and not elif? Each early return exits the moment it decides — see Control Flow — if statements. The final return x is only reached when neither bound was violated. We covered all three cases: below, above, and inside.

['apple']
['banana', 'apple']  # NOT what most people expect

Wait — read carefully. The output is:

['apple']
['apple', 'banana']

::: The default list [] is created once, at definition time, and is shared across every call that omits bag. The first call appends "apple" → ['apple']. The second call reuses the same list and appends "banana" → ['apple', 'banana'].

Why it surprises everyone: [] looks like it means "a fresh empty list each time," but it is evaluated once when def runs, not once per call. The box remembers the same list forever.

def add_item(item, bag=None):
    """Append item to bag; start a new list if none is given."""
    if bag is None:
        bag = []
    bag.append(item)
    return bag
 
print(add_item("apple"))    # ['apple']
print(add_item("banana"))   # ['banana']

• First call ::: ['apple']
• Second call ::: ['banana']

Why the None sentinel works: None is the safe "nothing was passed" flag. The line bag = [] now runs inside the function body, so a brand-new list is built on every call that needs it. Each call gets its own fresh list — no shared memory. (See Variables and Scope: bag is now a fresh local each time.)

def safe_divide(a, b):
    """Return a / b, or 'undefined' when b is zero."""
    if b == 0:
        return "undefined"
    return a / b

• safe_divide(10, 2) ::: 5.0
• safe_divide(7, 0) ::: "undefined" — we guard the zero case before dividing, so Python never raises ZeroDivisionError.
• safe_divide(0, 5) ::: 0.0 — a zero numerator is perfectly fine; $0/5=0$. Only a zero denominator is degenerate.

All cases covered: normal divisor, zero divisor (guarded), and zero dividend (allowed). The order matters — check b == 0 first, because touching a / b when b is 0 crashes before any later check can help.

These ten problems are one idea seen from five heights: a function is a labelled box with input slots and one output chute. L1 names the parts, L2 builds boxes, L3 traces what falls out, L4 wires defaults and branches into the box, L5 handles the boxes that secretly remember (mutable defaults) or break (divide by zero). Guard first, return once, and never confuse showing a number with handing one back.