Exercises — Default parameters, keyword arguments

Rule 1 says: non-default parameters must come before default ones (defaults drift right).

• (i) ✅ legal — x (no default) before y=1 (default).
• (ii) ❌ SyntaxError — x=1 (default) sits before y (no default). Order is backwards.
• (iii) ✅ legal — one non-default, then two defaults, all in the right order.
• (iv) ✅ legal — all parameters have defaults, so there is no "non-default after default" problem.

• greet("Ravi") → greeting is omitted, so its default "Hello" is used → Hello, Ravi.
• greet("Ravi", "Namaste") → the second value fills greeting by position → Namaste, Ravi.
• greet("Ravi", greeting="Hi") → the keyword names the slot directly → Hi, Ravi.

You want exp to keep its default 2, but you must set mod. Positionally you'd have to write power(5, 2, 7) — which forces you to type 2. The keyword lets you jump over exp:

power(5, mod=7)

Computation: exp stays 2, so r = 5 ** 2 = 25; then 25 % 7 = 4. Result = 4. This is the whole reason keyword arguments exist: reach a later knob while leaving earlier ones untouched.

The error: SyntaxError: positional argument follows keyword argument. Once you write x=1 (a keyword), the bare 5 after it has no known slot — Rule 2 says all positional arguments must come before any keyword argument. The fix: put positionals first.

box(5, x=1)      # width=5 (positional), x=1 (keyword)

Here width gets 5, height/y keep... wait — height has no default, so this would still fail with a missing-argument error. Correct, complete call:

box(5, 3, x=1)   # width=5, height=3, x=1, y keeps default 0

The positional "Asha" already fills name. Then name="Asha" tries to fill the same slot again. Result: TypeError: f() got multiple values for argument 'name'. The values being equal does not save you — Python complains about the slot being assigned twice, not about the values disagreeing.

Output:

[1]
[1, 2]
[1, 2, 3]

Mechanism: the default value [] is created once, when the def line runs — not on each call. So every call that omits bag reuses the same list object, and .append keeps growing it. The picture: one shared bucket, not a fresh bucket per call. See the figure.

def add(item, bag=None):
    if bag is None:
        bag = []          # fresh list on THIS call
    bag.append(item)
    return bag

Now add(1) → [1], add(2) → [2], add(3) → [3]. Each call that omits bag builds its own new list inside the body, so there is nothing shared. See how the buckets separate in the figure:

is None asks: "was the caller silent?" — did nothing get passed? == [] asks: "is whatever they passed empty?" — a very different question. If a caller legitimately passes their own empty list they intend you to fill, == [] would wrongly throw it away and substitute a new one. is None respects the caller's list. So: is None distinguishes absence from an empty-but-real value.

def log(msg, level="INFO", timestamp=None):
    head = f"[{level}] {msg}"
    return head if timestamp is None else f"{timestamp} {head}"

• log("hello") → "[INFO] hello" (both defaults used — the tiny 80% case).
• log("bad", level="ERROR") → "[ERROR] bad" (keyword skips nothing here but names the knob clearly).
• log("hi", timestamp="2024") → "2024 [INFO] hi" (jump over level using a keyword — same trick as L2.1). Note timestamp=None is the safe sentinel default; level="INFO" is a safe immutable string default.

def record(name, entries=None):
    entries = [] if entries is None else entries
    entries.append(name)
    return entries

• record("a") → ["a"]
• record("b") → ["b"] (independent — no shared bucket)
• record("c", ["x"]) → ["x", "c"] (a caller's own list is respected and extended). This is the DRY, safe pattern: one line of guard, then normal logic. It respects the DRY principle - Don't Repeat Yourself by keeping the fresh-list logic in exactly one place.

Step by step:

• build(1): b=10 (default), c omitted → new list [], append 1+10=11 → x = [11].
• build(2, 20): b=20 positionally, c omitted → new list, append 2+20=22 → y = [22].
• build(3, c=x): b=10 (default), c is the same object x. Append 3+10=13 into x → the list becomes [11, 13]. So z is x. Output:

[11, 13]      # x, mutated by the last call
[22]          # y, independent
[11, 13]      # z is the same object as x

Key insight: no default was misused (we used the None sentinel correctly). The sharing here is deliberate — the caller passed x in on purpose, so z is x. This connects to Mutable vs immutable objects: passing a mutable object means the callee can change it.

Diagnosis: prefix=[] is a mutable default created once at def time. If render does prefix.extend(items) and a caller omits prefix, every such call mutates the same shared list — that is the "remembers old items" symptom. Rewrite:

def render(items, sep=", ", prefix=None):
    prefix = [] if prefix is None else prefix
    out = list(prefix)          # copy so we never mutate the caller's list either
    out.extend(items)
    return sep.join(out)

• render(["a", "b"]) → "a, b" (fresh, no memory).
• render(["c"], sep=" | ") → "c" (single item, keyword sep used).
• render(["z"], prefix=["p"]) → "p, z" (caller's prefix respected, and copied so their list stays untouched). Using list(prefix) is the extra-safe touch: even when a real list is passed, we don't surprise the caller by mutating their object.

Evaluating once is cheaper and predictable: the default expression runs a single time, so a default like heavy_computation() isn't re-run on every call. The trade-off is the mutable-default trap — a shared object survives between calls. Python chose speed/predictability and asks you to use the None sentinel for the mutable case. So: one evaluation buys performance; you pay with the discipline of None defaults.