選修單元 C：子程式（ECCH4）

定義

• 模組性（modularity）：把程式分成多個「功能明確、彼此相對獨立」的部分，方便理解、測試與維護。
• 拆解：把大問題分成多個小問題；每個小問題都可以由一個子程式處理。
• 子程式（sub-program）：可被調用的程式片段；通常會接收參數、執行工作，並（可選）回傳結果。

原理／運作

• 把子程式想像成「黑盒」：外界只需要知道輸入（參數）與輸出（回傳值），不用關心內部細節。
• 理想情況下，一個子程式只做一件清楚的事（例如：計算平均、檢查是否合格、格式化輸出）。
• 主流程（main flow）負責串連步驟；子程式負責處理細節，令程式結構更清晰。

例子

要輸入三科分數並輸出平均分，你可以先拆成兩個子程式：

• sum3(m1, m2, m3)：回傳總分
• avg3(total)：回傳平均

def sum3(m1, m2, m3):
    return m1 + m2 + m3

def avg3(total):
    return total / 3

t = sum3(72, 64, 80)
a = avg3(t)
print("平均分：", a)

比較

常見錯誤

• 拆得太碎：每幾行就一個子程式，反而令程式跳來跳去，難以追蹤。
• 拆得不清：子程式名字含糊（例如 do()、process()），或同一子程式做太多事。
• 介面設計混亂：參數太多、回傳值不清楚，最後變成「調用者也要知道內部細節」。

技巧：先用一句話描述子程式「做甚麼」，再寫函數名。若一句話說不清，通常表示它做太多事。

定義

• 定義（define）：在程式中寫出子程式內容，告訴電腦「這個名字代表甚麼動作」。
• 調用（call）：在需要使用功能的位置，使用子程式名稱（及括號）執行該子程式。
• 回傳：子程式把計算結果交回調用位置，讓主流程繼續使用。

原理／運作

• Python 讀到 def 時，只是「記住」子程式內容；真正執行要等到調用。
• 調用時，程式流程會跳到子程式內執行；完成後回到調用位置的下一行。
• 若子程式有回傳值，調用表達式會被替換成回傳值（例如 ans = square(7)）。

例子

def hello():
    print("Hello, ICT!")

hello()
hello()

同一段輸出只需寫一次，將來要改訊息，也只需改 hello() 的內容。

比較

• 直接寫：快，但容易重複；程式一長就難維護。
• 封裝：初期要多想名字與介面，但可重用、可測試、可讀性高。

常見錯誤

• 忘記括號：hello 與 hello() 的意思不同；後者才是調用。
• 縮排錯誤：子程式內容必須在 def 後縮排。
• 命名不清：do()、work() 等名稱難以反映用途。

定義

• 參數（parameter）：子程式接收輸入資料的「入口」；在定義中出現。
• 變元（argument）：調用子程式時，實際傳入的資料（可以是常數、變量、算式）。
• 形式參數（formal parameter）：定義子程式時的參數名稱（例如 def f(x): 的 x）。
• 實際變元（actual argument）：調用子程式時提供的值／變量（例如 f(10) 的 10）。

原理／運作

• 最常見情況：位置對應——第一個實際變元對應第一個形式參數，如此類推。
• 調用時，Python 會把實際變元的值交給形式參數，子程式內就可以用形式參數名字使用這些資料。
• 完成後若有回傳值，調用表達式會得到結果。

例子

def area_circle(r):
    pi = 3.14159
    return pi * r * r

radius = 3
print(area_circle(radius))

r 是形式參數；radius（其值為 3）是實際變元。 子程式內部不用知道外面變量叫甚麼，只要使用 r。

比較

• 參數太少：子程式需要依賴全程變量或內部輸入，重用性下降。
• 參數太多：調用時容易傳錯次序，閱讀困難。
• 改良方法：把相關資料組合成資料結構（例如陣列、字典），用一個參數傳入。

常見錯誤

• 把參數次序傳錯：diff(a, b) 與 diff(b, a) 可能得到完全不同結果。
• 以為形式參數名稱要與外面變量同名：其實不用；對應關係主要由「位置」決定。
• 子程式內改動參數就等於改動外面變量：對於不可變資料（例如整數、字串）不一定成立；要分清資料類型與改動方式。

延伸

• 按值調用（call by value）：子程式收到值的副本，內部改動唔影響外面。
• 按址調用（call by reference/address）：子程式收到同一份資料的位址／參照，內部改動會反映到外面。
• Python：形式參數會指向同一個物件（pass-by-object-reference）。不可變類型（int/float/str）重新賦值只影響局部；可變類型（list/dict）做 in-place 修改會影響外面。

def f(x):
    x = x + 1

a = 5
f(a)
print(a)  # 5

def g(L):
    L.append(1)

nums = []
g(nums)
print(nums)  # [1]

定義

• 回傳值：子程式把結果交回調用位置，調用者可把它儲存、再運算或再判斷。
• 輸出：把文字顯示到畫面；輸出本身通常不會把值交回程式。
• 副作用：子程式除了回傳值以外，還改變外界狀態（例如改全程變量、寫檔、輸出）。

原理／運作

• 例：ans = square(7)，執行完 square 後，調用位置得到回傳值並存入 ans。
• 若子程式只 print 而不 return，調用位置通常得不到可用的數值（會是 None）。

例子

若要把平均分同時用於「輸出」與「判斷等級」，回傳值特別重要：

def avg3(m1, m2, m3):
    return (m1 + m2 + m3) / 3

a = avg3(72, 64, 80)
print("平均：", a)

if a >= 60:
    print("合格")

比較

常見錯誤

• 把「計算」寫成 print：結果無法在主流程再使用。
• 忘記把數值轉成字串："答案：" + ans 會出錯（需 str(ans)）。
• 在 return 後仍寫有用程式：return 之後的語句不會執行。

定義

• 局部變量：在子程式內建立的變量，通常只在該子程式執行期間存在。
• 全程變量：在子程式外建立的變量，理論上可被多處程式讀取。
• 遮蔽：若子程式內使用與全程變量同名的局部變量，局部變量會暫時遮住外面的同名變量。

原理／運作

• 在子程式內讀取全程變量一般沒有問題。
• 若要在子程式內改寫全程變量的值，Python 需要使用 global 聲明，否則會被當作建立新的局部變量。

count = 0

def add_one():
    global count
    count = count + 1

add_one()
print(count)  # 1

例子

把資料當作參數傳入，再回傳新值，資料流會更清晰：

def add_to_total(total, x):
    return total + x

total = 0
total = add_to_total(total, 5)
total = add_to_total(total, 7)
print(total)

比較

• 用參數／回傳值：資料流清晰，子程式較易獨立測試。
• 用全程變量：調用時看不出依賴，容易在多處被改寫，錯誤較難追查。

常見錯誤

• 以為子程式內同名變量一定是全程變量：其實多數情況是局部變量。
• 濫用全程變量作暫存：令子程式互相干擾，行為不穩定。
• 把「修改可變資料結構內容」與「改寫變量指向」混淆：兩者影響範圍不同。

定義

• 測試：用不同輸入驗證程式行為是否符合預期。
• 除錯（debug）：找出造成錯誤的原因並修正。
• 追蹤表：在空運行時記錄每一步變量值，以分析邏輯。

原理／運作

1. 先為子程式準備簡單測試資料（例如固定參數），確認回傳值正確。
2. 再加入邊界情況（例如 0、負數、空字串、空陣列）。
3. 最後才把子程式接回主流程，測整體輸入與輸出。

由小到大的方法，可以把錯誤定位在某一個子程式，而不是在整段程式亂猜。

例子

def sum_to_n(n):
    s = 0
    for i in range(1, n + 1):
        s = s + i
    return s

空運行 n = 4 時：

比較

• 只測整體：一出錯就要在整段程式找原因，範圍大、效率低。
• 先測子程式：逐個模組驗證，較快鎖定出錯位置。

常見錯誤

• 只測一個例子：程式在其他輸入下可能失敗。
• 測試沒有預期答案：不知對錯，也無法有效除錯。
• 加入大量輸出而不整理：輸出過多反而看不出關鍵。

定義

• 重構：不改變程式外在行為的前提下，改善程式內部結構。
• 抽象：抓住共同特徵，把細節隱藏在子程式內，讓外部只看到「做甚麼」。
• 參數化：把差異變成參數，避免為每個小變化都複製一份程式。

原理／運作

1. 找出重複片段（邏輯相同或非常相似）。
2. 把共通部分抽成子程式。
3. 把不同之處變成參數（例如不同訊息、不同次數、不同折扣率）。
4. 替換原本重複片段為子程式調用。

例子

# 重構前（重複）
print("Hello, Amy")
print("Hello, Ben")
print("Hello, Chris")

# 重構後（抽象 + 參數化）
def hello(name):
    print("Hello, " + name)

hello("Amy")
hello("Ben")
hello("Chris")

比較

• 未重構：同一改動要改多處；容易漏改，造成不一致。
• 重構後：改動集中在子程式；所有調用位置自動受惠。

常見錯誤

• 把不相干的事硬塞成同一子程式，導致參數越來越多、越來越難用。
• 重構後不再測試：改壞了輸出格式而不自知。
• 只重構表面：例如只改名但不改善結構，問題仍在。

定義

• 遞歸：子程式以更小的同類問題調用自己，直到達到終止條件。
• 終止條件：不用再分解、可直接給答案的最小情況。
• 遞歸關係：把大問題轉成小問題的規則。

原理／運作

• 每一次調用都會把目前狀態放入堆疊，等待子程式完成後再返回。
• 最深層先完成（符合先進後出），然後逐層返回並組合答案。

理解方式：先找終止條件，再看遞歸如何把問題縮小，最後看返回時如何合併結果。

例子

def fact(n):
    if n == 0:
        return 1
    return n * fact(n - 1)

print(fact(5))  # 120

比較

• 遞歸：寫法貼近數學定義，對樹狀問題（例如遍歷）較自然。
• 迭代（iteration）：通常較省堆疊空間，亦較易避免深度過大。

常見錯誤

• 缺少終止條件或終止條件寫錯。
• 遞歸沒有縮小問題（例如 fact(n) 又調用 fact(n)）。
• 忽略輸入限制：過大的 n 可能造成遞歸深度過深。