Functions, call frames and returned results

Give each function one clear job

• A function 函数 groups a named task. State its inputs, its returned result and any side effect 副作用, such as printing, before writing the body.
• A contract 契约 says what callers may supply and what the function promises. Here, amounts are whole pence and must be non-negative integers.

def add_fee(amount):
    """Return amount plus a fixed fee of 3 pence."""
    return amount + 3

Distinguish the input name from the input object

• In a definition, amount is a parameter 形参. In add_fee(8), the expression 8 supplies an argument 实参. Argument expressions are evaluated before the function body runs.
• The call binds the parameter name to the supplied object. It does not automatically copy that object or create a link between the caller's name and the parameter's name.

amount = 4
result = add_fee(amount * 2)
print(amount, result)

Keep a separate frame for each call

• A call frame 调用帧 records one active function call, including its parameters and local names. When one function calls another, the caller waits for the returned value.
• Read this program in execution order: module → twice → add_fee → twice → module. The arrows below are conceptual control flow, not a physical memory layout.

def twice(amount):
    subtotal = amount * 2
    return add_fee(subtotal)

amount = 4
result = twice(amount)
print(amount, result)

Return a result; print a message

• return ends the current call and gives an object back to the caller. A function that reaches its end without return gives None.
• print writes output. It also returns None, so printing a calculation inside a function does not make that calculation its returned result.

def show_fee(amount):
    print(amount + 3)

value = show_fee(8)
print(value)

Resolve names in the right scope

• A local variable 局部变量 belongs to a function call. Its scope 作用域 determines where a name can be resolved; another function does not receive access to the caller's local names automatically.
• Assigning a parameter a new integer changes its local binding. It does not reassign a same-named variable in the caller.

def increase(amount):
    amount = amount + 1
    return amount

amount = 4
new_amount = increase(amount)
print(amount, new_amount)

Decompose a calculation into testable pieces

• Decomposition 分解 separates a larger task into smaller jobs with clear contracts. For an order, calculate an item subtotal, add a fee, then display the final amount.
• Test calculations directly, including zero quantity and more than one item. State that inputs are non-negative integers; input validation can be a separate function.

def item_subtotal(unit_pence, quantity):
    return unit_pence * quantity

def order_total(unit_pence, quantity):
    return add_fee(item_subtotal(unit_pence, quantity))

Explain the whole call before trusting the answer

• Trace the argument expressions, parameter bindings, local calculations and returned values. Check the caller's state after the call and the output separately.
• Do not describe parameter passing as copying every object. A mutable collection can be changed through a parameter; object diagrams for mutation and aliasing follow in unit 1.5.

Language references: Python functions and name binding and scope.