Functions and Modular Design函数与模块化设计

Repeated-code version (bad).重复代码版（不好）。

-- Place 1
SET area1 TO 5 * 3

-- Place 2
SET area2 TO 8 * 4

-- Place 3
SET area3 TO 12 * 7

Three places repeat the same logic (width × height). If the formula needs to change, you must edit three places.三处代码重复相同逻辑（宽 × 高）。如需改为"宽 × 高 × 比例因子"，必须修改三处。

Function version (good).函数版（好）。

FUNCTION rectangle_area(width, height):
    RETURN width * height

SET area1 TO rectangle_area(5, 3)
SET area2 TO rectangle_area(8, 4)
SET area3 TO rectangle_area(12, 7)

Python rendering.Python 实现。

def rectangle_area(width, height):
    return width * height

area1 = rectangle_area(5, 3)   # 15
area2 = rectangle_area(8, 4)   # 32
area3 = rectangle_area(12, 7)  # 84

The logic lives in one place. The callers are readable (“rectangle area of 5 by 3”) without needing to see the multiplication. Ontario ICS3U B2.3: "apply the principle of modularity to design reusable code."逻辑只存在于一处。调用方具有可读性（"5 乘 3 的矩形面积"），无需看到乘法运算。安大略 ICS3U B2.3："应用模块化原则设计可复用代码。"

Pseudocode definition and calls.伪代码定义与调用。

FUNCTION greet(name):
    OUTPUT "Hello, " + name + "!"
END FUNCTION

CALL greet("Alice")
CALL greet("Bob")

伪代码说明：FUNCTION 定义函数，OUTPUT 输出，CALL 调用，name 为形参（parameter，形参）。Pseudocode: FUNCTION defines, OUTPUT prints, CALL invokes, name is the parameter.

Python rendering.Python 实现。

def greet(name):
    print("Hello, " + name + "!")

greet("Alice")   # Output: Hello, Alice!
greet("Bob")     # Output: Hello, Bob!

The def line defines the function; neither print runs until a call occurs. Each call creates a fresh execution of the function body, with the given argument bound to the parameter name.def 行定义函数；在调用发生之前，两次打印都不会运行。每次调用都会重新执行函数体，将给定的实参绑定到形参 name。

Pseudocode.伪代码。

FUNCTION power(base, exponent):
    SET result TO 1
    FOR i FROM 1 TO exponent:
        SET result TO result * base
    RETURN result
END FUNCTION

OUTPUT power(2, 3)   -- 8
OUTPUT power(3, 4)   -- 81
OUTPUT power(5, 2)   -- 25

说明：base 和 exponent 是形参（parameter，形参）；2, 3 / 3, 4 / 5, 2 是实参（argument，实参）。RETURN 将结果传回调用处。Note: base and exponent are parameters; 2, 3 / 3, 4 / 5, 2 are arguments. RETURN sends the result back to the caller.

Python rendering.Python 实现。

def power(base, exponent):
    result = 1
    for i in range(exponent):
        result = result * base
    return result

print(power(2, 3))   # 8
print(power(3, 4))   # 81
print(power(5, 2))   # 25

Each call creates fresh copies of base and exponent with the given argument values. Changing result inside the function does not affect any variable outside — that is one-way parameter passing in action.每次调用都会创建 base 和 exponent 的新副本，并绑定给定的实参值。在函数内更改 result 不会影响函数外的任何变量——这就是单向参数传递的实际效果。

Pseudocode with early returns.带提前返回的伪代码。

FUNCTION grade(score):
    IF score >= 90 THEN RETURN "A"
    IF score >= 80 THEN RETURN "B"
    IF score >= 70 THEN RETURN "C"
    IF score >= 60 THEN RETURN "D"
    RETURN "F"
END FUNCTION

OUTPUT grade(95)   -- "A"
OUTPUT grade(82)   -- "B"
OUTPUT grade(55)   -- "F"

说明：每个 RETURN 立即退出函数并将字符串返回给调用方。对于分数 82：第一个 IF（≥90）为假跳过；第二个 IF（≥80）为真，立即返回 "B"，其余 IF 语句均不执行。这是返回值（return value，返回值）的典型用法。For score 82: first IF (≥90) is false, skip; second IF (≥80) is true, immediately return "B". The remaining IF statements never execute. This is the return value in action.

Python rendering.Python 实现。

def grade(score):
    if score >= 90: return "A"
    if score >= 80: return "B"
    if score >= 70: return "C"
    if score >= 60: return "D"
    return "F"

print(grade(95))   # A
print(grade(82))   # B
print(grade(55))   # F

The caller uses the return value directly in print(). Alternatively: letter = grade(82) stores "B" in the variable letter.调用方在 print() 中直接使用返回值。或者：letter = grade(82) 将 "B" 存入变量 letter。

Pseudocode.伪代码。

SET total TO 100        -- global variable (全局变量)

FUNCTION add_five():
    SET total TO total + 5  -- local? or global?
    RETURN total
END FUNCTION

OUTPUT total            -- Line A
OUTPUT add_five()       -- Line B
OUTPUT total            -- Line C

Python rendering (Python requires the global keyword to modify a global).Python 实现（Python 需要 global 关键字才能修改全局变量）。

total = 100            # global variable (全局变量)

def add_five():
    global total       # must declare to modify the global
    total = total + 5
    return total

print(total)           # Line A: 100
print(add_five())      # Line B: 105 (modifies the global)
print(total)           # Line C: 105 (global was changed!)

Without global total inside the function, Python would create a new local variable called total, and the global would remain 100. This is exactly why unintended global modification is a common bug: the behaviour depends on one keyword. Prefer passing total as a parameter and returning the result instead.如果函数内没有 global total，Python 会创建一个名为 total 的新局部变量，全局变量仍为 100。这正是无意的全局变量修改成为常见错误的原因：行为取决于一个关键字。建议改为将 total 作为形参传入，并返回结果。

Decomposition into four functions.分解为四个函数。

FUNCTION get_scores():
    SET scores TO empty list
    FOR i FROM 1 TO 5:
        INPUT score
        APPEND score TO scores
    RETURN scores
END FUNCTION

FUNCTION compute_average(scores):
    SET total TO 0
    FOR EACH s IN scores: SET total TO total + s
    RETURN total / 5
END FUNCTION

FUNCTION letter_grade(average):
    IF average >= 90 THEN RETURN "A"
    IF average >= 80 THEN RETURN "B"
    IF average >= 70 THEN RETURN "C"
    IF average >= 60 THEN RETURN "D"
    RETURN "F"
END FUNCTION

FUNCTION display_report(avg, grade):
    OUTPUT "Average: " + avg
    OUTPUT "Grade:   " + grade
END FUNCTION

-- Main program
SET scores TO get_scores()
SET avg TO compute_average(scores)
SET grade TO letter_grade(avg)
display_report(avg, grade)

说明：主程序（main program）只有四行，清晰如故事情节。每个函数（函数，function）只做一件事；可以单独测试每个函数。数据通过形参（parameter，形参）和返回值（return value，返回值）流动，无需全局变量（global variable，全局变量）。The main program is four lines — readable as a story. Each function does one thing; each can be tested in isolation. Data flows via parameters and return values, with no global variables needed.

Python rendering.Python 实现。

def get_scores():
    scores = []
    for i in range(5):
        scores.append(float(input("Score: ")))
    return scores

def compute_average(scores):
    return sum(scores) / len(scores)

def letter_grade(average):
    if average >= 90: return "A"
    if average >= 80: return "B"
    if average >= 70: return "C"
    if average >= 60: return "D"
    return "F"

def display_report(avg, grade):
    print(f"Average: {avg:.1f}")
    print(f"Grade:   {grade}")

scores = get_scores()
avg = compute_average(scores)
grade = letter_grade(avg)
display_report(avg, grade)

Pseudocode (using library notation).伪代码（使用库表示法）。

-- (a) hypotenuse
SET hyp TO math.sqrt(3*3 + 4*4)
OUTPUT hyp   -- 5.0

-- (b) dice roll
SET roll TO random.randint(1, 6)
OUTPUT roll  -- a random integer between 1 and 6 inclusive

说明：math.sqrt() 和 random.randint() 是库（library，库）中的内置函数（built-in function，内置函数）。调用方只需知道接口（名称、参数、返回值），不需要知道内部实现——这就是抽象（abstraction，抽象）的体现。Callers only need the interface (name, parameters, return value), not the implementation — this is abstraction in action.

Python rendering.Python 实现。

import math
import random

# (a) hypotenuse  斜边
hyp = math.sqrt(3**2 + 4**2)
print(f"Hypotenuse: {hyp}")  # 5.0

# (b) dice roll  骰子
roll = random.randint(1, 6)
print(f"Rolled: {roll}")

The import statement loads the module; after that, every function in the module is callable using module.function() syntax. BC CP11 says "pre-built libraries and their documentation" — you should know how to read the Python docs to find the signature of any built-in.import 语句加载模块；之后，模块中的所有函数都可以用 module.function() 语法调用。BC CP11 要求"预建库及其文档"——你应该知道如何阅读 Python 文档来查找任何内置函数的签名。