第二单元：参数传递 · 给函数递东西

上一单元你学会了用 def 把行为封装成函数，比如 commandSoldiers() 一次遍历所有士兵下令。但那样的函数有个局限：它内部"要处理谁"是写死的。本单元你将给函数装上一个"入口"——参数（parameter），让同一个函数每次可以处理不同的对象。这样你就能写一个 commandSoldier(soldier)，把任意一名士兵"递"给它去指挥。

2.1.1 从"固定"到"通用"（From Fixed to Flexible）

2.1.1.1 让一个函数服务无数对象 One function, many objects

没有参数的函数只能做一件固定的事；有了参数，同一个函数就能被"喂"进不同的数据，做同一类事情。关卡默认代码的注释点明了这个思想："这个函数有一个名为 soldier 的参数。参数就像变量一样。参数的值是在调用函数时确定的。"换句话说，commandSoldier 不再"内定"要指挥谁，而是等你调用时告诉它"这次指挥这一个"。

def commandSoldiers():
    for s in hero.findFriends():
        # 内部自己找对象
        pass

def commandSoldier(soldier):
    # soldier 由调用者传进来
    enemy = soldier.findNearestEnemy()
    # ...

2.1.2 形参与实参（Parameter vs. Argument）

2.1.2.1 一个是"占位名"，一个是"真东西" A placeholder name vs. a real value

有两个词要分清：定义时括号里写的那个名字叫形参（形式参数，只是个占位的名字，如 soldier）；调用时括号里真正传进去的值叫实参（实际参数，如 friend）。调用发生的一瞬间，实参的值会被"装进"形参这个名字里，函数体就拿着它开始工作。

2.2.1 括号里的形参（Declaring a Parameter）

2.2.1.1 在 def 的括号里写下名字 Put a name in the parentheses

上一单元函数的括号总是空的 ()def commandSoldier(soldier): 就声明了这个函数需要"一个东西"，并在函数内部用 soldier 这个名字来称呼它。这个名字是你自己起的，起得贴切能让代码更好读。

2.2.2 参数是局部变量（Parameters Are Local Variables）

2.2.2.1 在函数里，形参就像普通变量 Inside, it behaves like any variable

关卡说"参数就像变量一样"——这话很关键。一旦进入函数体，形参 soldier 就和你平时写的普通变量没有区别：你可以 soldier.findNearestEnemy()、可以 soldier.pos、可以拿它去 command。它是一个局部变量——只在这个函数内部有效，出了函数就"不存在"了。

def commandSoldier(soldier):
    # 在函数里，soldier 就是个普通变量，可自由使用
    enemy = soldier.findNearestEnemy()
    if enemy:
        hero.command(soldier, "attack", enemy)

2.2.3 实参传递机制（How Arguments Get Passed）

2.2.3.1 调用一瞬间完成"赋值" The value is bound at call time

参数传递的本质，就是在调用的那一刻把实参"赋值"给形参。关卡默认代码里有一句提示注释："将这位朋友赋值给 commandSoldier 函数中的 soldier 变量"——对应的调用是 commandSoldier(friend)。执行这行时，等价于在函数内部悄悄做了 soldier = friend，然后才开始跑函数体。

2.3.1 按 type 判断分流（Dispatch by Type）

2.3.1.1 遍历盟友，按兵种送进不同函数 Route each friend to the right function

本关的部队里既有士兵又有弓箭手，两者战术不同，需要分别指挥。做法是遍历所有盟友，用 friend.type 判断它是哪种兵，再把它"递"给对应的函数：士兵送进 commandSoldier(friend)，弓箭手送进 commandArcher(friend)。这就是"按类型分派"——同一个 friend，根据身份走向不同的处理函数。

for friend in hero.findFriends():
    if friend.type == "soldier":
        commandSoldier(friend)    # 把这名士兵递进去
    elif friend.type == "archer":
        commandArcher(friend)     # 把这名弓箭手递进去

2.3.2 士兵与弓箭手分工（Soldiers vs. Archers）

2.3.2.1 两种兵，两套战术 Two unit types, two tactics

为什么要拆成两个函数？因为士兵和弓箭手的最优打法不同。关卡规定得很清楚："弓箭手应该只攻击距离小于 25 米的敌人。士兵应该攻击任何敌人。"士兵是近战肉盾，见敌就冲；弓箭手是脆皮远程，必须克制——只打射程内的敌人，否则原地待命，绝不主动追出去。

这一节聚焦关卡的策略、思路与算法设计，只展示用于说明的关键片段，完整通关程序请你自己动手完成。

关卡 · 猎手和猎物

🦌 猎手和猎物 —— 士兵冲锋，弓箭手守猎物

图2：猎手和猎物——士兵前压清剿食人魔，弓箭手贴身守护驯鹿，只射入射程的敌人

策略：进攻与护卫分层

食人魔在猎捕你的驯鹿，你要反过来"猎猎手"。核心策略是分层布防：让士兵作为前排主动出击、把食人魔顶在外围；让弓箭手作为后排贴着驯鹿、当敌人闯进射程时才补刀。关卡简介一句话概括——"在召唤士兵进攻的同时，让弓箭手在士兵背后"。攻守分层，才能既清敌又不丢猎物。

思路拆解

算法结构是"若干带参数的函数 + 一个分派循环"。先补全两个无参函数 pickUpCoin（找最近金币就 move 过去）和 summonTroops（钱够就 summon("soldier")）。再写两个带参数的指挥函数：commandSoldier(soldier) 里 soldier.findNearestEnemy() 找到敌人就攻击；commandArcher(archer) 里 archer.findNearestEnemy() 后加一层距离判断 archer.distanceTo(enemy) < 25，够近才攻击、否则 command(archer, "move", archer.pos) 原地待命。最后在 while True 里遍历 findFriends()，按 friend.type 把每个单位分派给对应函数。

# 关键片段：弓箭手——够近才射，否则守在原地
def commandArcher(archer):
    enemy = archer.findNearestEnemy()
    if enemy and archer.distanceTo(enemy) < 25:
        hero.command(archer, "attack", enemy)
    else:
        hero.command(archer, "move", archer.pos)   # 待在原地

算法要点回顾

这一关把参数传递用得淋漓尽致：两个指挥函数各带一个形参，分派循环把不同兵种的单位当作实参传进去。妙在 commandSoldier 和 commandArcher 结构几乎一样（都是"找敌人→判断→下令"），只是判断条件不同——这说明参数化的函数让"同类行为、不同细节"的代码得以清晰地各自封装，主循环则只负责"谁该进哪个函数"。

弓箭手别乱跑：如果忘了写 else 分支里的 command(archer, "move", archer.pos)，弓箭手就会按默认行为主动追敌、脱离驯鹿，导致驯鹿被伏击。"没敌人/敌人太远时，明确命令弓箭手原地不动"是本关成败的关键。

distanceTo 与射程 25：archer.distanceTo(enemy) 算的是弓箭手到敌人的距离，而非英雄到敌人。因为判断"敌人是否进入这名弓箭手的射程"，必须站在弓箭手自己的位置上量。这也再次体现了参数的价值——函数内用 archer 这个形参，就能针对"当前这名弓箭手"精确计算。

2.5.1 新手最容易踩的坑（Pitfalls for Beginners）

2.5.1.1 参数传递的典型问题 Typical issues with parameters

图3：调用漏传参、形参实参混淆、弓箭手不写待命分支，是本单元最常见的失误