Function Arguments — Positional, Keyword, Default, and Variable Parameter Binding

1. Orientation & Where It Sits

[Basic Functions & Return] (Week 7) ──┐
                                     ├──► [Function Arguments & Scope] (Week 8) ──► [Decorators & Functional Python] (Week 11)
[Lists, Tuples & Dicts]   (Weeks 5-6) ┘                                         └──► [OPPE Coding & Python Mocks] (Exam Desk)

• Prerequisites:
  • Functions — Defining and Using — def statement, invocation, and return semantics.
  • Lists & Dictionaries — Sequences, key-value mappings, and mutability.
• Downstream Unlocks:
  • Recursion with Accumulators (798 - Recursion.md) — Passing default states across stack frames.
  • Higher-Order Functions & Decorators — Taking *args, **kwargs to wrap arbitrary callables.

2. Notation, Vocabulary & Etymology

3. Layered Conceptual Depth

Layer 1: The Intuition — The Custom Sandwich Order

1. Positional Parameters: The bread and the base protein must come first in exact sequence: order("sourdough", "tofu").
2. Default Parameters: Condiments come pre-selected unless you specify otherwise: sauce="mayo", toasted=True.
3. *args (Extra Toppings): You can request arbitrary loose toppings without defining individual slots: "olives", "pickles", "jalapenos" are bundled together into a basket.
4. **kwargs (Custom Prep Instructions): You can pass arbitrary name-value preferences: cut="diagonal", wrap="foil", salt="extra" are collected onto a labelled order slip.

Layer 2: The Invariant Ordering Grammar

Signature Definition Grammar

def func(pos_only, /, standard_pos_or_kw, default_pos_or_kw=val, *args, kw_only, kw_only_default=val, **kwargs):

[1. Positional-Only]   ──► [2. Pos-or-Keyword] ──► [3. Defaults] ──► [4. *args] ──► [5. Keyword-Only] ──► [6. **kwargs]
    (before '/')                                                                     (after '*')

Layer 3: Execution Mechanics — The Mutable Default Argument Trap

python
Run Inline
def append_element(val, target_list=[]):
    target_list.append(val)
    return target_list

print(append_element(1)) # Output: [1]
print(append_element(2)) # Output: [1, 2]  <-- NOT [2]!
print(append_element(3)) # Output: [1, 2, 3]

The Underlying Interpreter Architecture

1. Definition Time vs Call Time: Python executes def statements once when the module or script is loaded, NOT each time the function is called.
2. Object Creation: When the interpreter encounters target_list=[], it allocates a single list object in memory (e.g. at address 0x7f80) and binds it to the function's __defaults__ tuple.
3. Shared Persistence: Every subsequent call to append_element() that omits the second argument binds target_list to that exact same list in memory. Modifying target_list mutates the permanent default object stored on the function object itself!

Function Object `append_element`
  ├── __code__: <bytecode>
  └── __defaults__: ([ 1, 2, 3 ],)  <── Persistent list mutated across calls!

The Idiomatic Safe Pattern (Sentinel None)

python
Run Inline
def append_element_safe(val, target_list=None):
    if target_list is None:
        target_list = []  # Creates a fresh list on EACH call
    target_list.append(val)
    return target_list

4. Worked Anatomy: Complex Binding Trace

Function Definition

python
Run Inline
def calculate(base, multiplier=2, *deltas, scale=1, **flags):
    total = base * multiplier
    for d in deltas:
        total += d
    total *= scale
    if flags.get("round_result"):
        total = round(total)
    return total

Call Site

python
Run Inline
result = calculate(10, 3, 4, 6, scale=0.5, round_result=True)

Step-by-Step Binding Process

Computation

1. total = 10 * 3 = 30
2. Iterating deltas: total += 4 ($34$), total += 6 ($40$)
3. Scaling: total = 40 * 0.5 = 20.0
4. Flag check: flags.get("round_result") is True $\to$ round(20.0) = 20
5. Returns 20.

5. Non-Examples & The 3 Critical Failure Modes

                         ┌── 1. SyntaxError: Positional Argument Follows Keyword Argument
                         │
Signature Violations ────┼── 2. TypeError: Function Got Multiple Values for Argument
                         │
                         └── 3. TypeError: Missing Required Keyword-Only Argument

1. Positional After Keyword

python
Run Inline
def greet(first, last):
    return f"{first} {last}"

greet(first="Grace", "Hopper")
# SyntaxError: positional argument follows keyword argument

2. Multiple Values for the Same Argument

python
Run Inline
def process(x, y=10):
    return x + y

process(5, 20, x=50)
# TypeError: process() got multiple values for argument 'x'

3. Keyword-Only Argument Omission

python
Run Inline
def configure(*, timeout=30, retries):
    pass

configure(5)
# TypeError: configure() takes 0 positional arguments but 1 was given
configure(retries=3) # Correct!

6. Question-Pattern Anatomy (8 Exam Reflexes)

7. Interactive Attempt-First Checks

python
Run Inline
def collect(item, box=[]):
    box.append(item)
    return len(box)

a = collect("pencil")
b = collect("eraser")
c = collect("ruler", ["notebook"])
d = collect("pen")

print(f"{a}-{b}-{c}-{d}")

python
Run Inline
def score(mult, *vals, offset=10):
    return sum(vals) * mult + offset

data = [2, 3, 5]
ans = score(3, *data, 10, offset=5)
print(ans)

python
Run Inline
def register(id_num, name, role="Student", *courses, notify=True):
    pass

Blank-Page Active Recall Challenge

8. Next Action & Spacing Protocol

• Immediate Next Chapter: Week 8: Recursion in Python — Combine parameter passing with recursive call stacks.
• Active Drill Desk: Visit the Quiz 3 Checkpoint Desk to drill Python predict-the-output questions.
• Spaced Review Suggestion: Re-attempt the Mutable Default trace (Question 1) in 48 hours to confirm persistent memory reflexes.