第七单元：函数参数

7.1.1 无参函数的局限（The Limits of Parameter-less Functions）

7.1.1.1 函数也想"听指挥" Functions want instructions too

上一单元你学会了定义函数，把"找敌人并攻击"打包成 findAndAttackEnemy()。但这种函数有个小遗憾：它每次只能自己在内部重新找敌人，外面没办法告诉它"这次请打这个敌人"。如果你已经在外面找好了一个特定目标，想交给函数去处理，无参函数就接不住了。

这正是本单元要解决的问题。关卡"边地之叉"开门见山："函数通常需要参数。参数让函数具有更多灵活性，且不妨碍函数优化和简化代码的作用。"

7.1.2 参数带来灵活性（Parameters Bring Flexibility）

7.1.2.1 同一个函数，处理不同的对象 One function, different targets

参数（Parameter）就像函数的"输入口"——调用时把信息从这个口子递进去，函数就能针对你递进来的不同对象做同样的事。比如一个 checkAndAttack(target) 函数，这次递给它顶部的敌人就打顶部，下次递给它底部的敌人就打底部。一份代码，应付千变万化的目标。

7.1.3 你早就在传参数（You've Been Passing Arguments）

7.1.3.1 say、attack 都吃参数 say and attack already take arguments

其实参数你早就用过了。"交给劈斩"关卡点破了真相："在使用 hero.say('Hello!') 时，你将字符串 'Hello!' 作为参数传给了函数 say。" 同样，hero.attack(enemy) 里的 enemy、hero.moveXY(35, 34) 里的 35 和 34，都是参数。本单元的新本领是：给你自己定义的函数也加上参数。

7.2.1 两个核心概念（Two Key Concepts）

7.2.1.1 形参和实参的分工 The roles of parameters and arguments

图1：实参在调用时传入，形参在函数内部接住——同一份信息的两个名字

关卡把两个关键词讲得很清楚：

用关卡原话总结："实参（实际参数）是函数调用时 () 内包含的信息。形参（形式参数）则是传入函数的信息在函数内所使用的变量。"

7.2.2 形参就是变量（A Parameter is Just a Variable）

7.2.2.1 别被"形参"吓到 Don't be scared by the word

"形参"听起来高深，其实关卡反复安慰你："形式参数 'target' 只是一个变量！" 它和你之前用过的 enemy、distance 这些变量没有任何区别——可以在函数体里随意使用。唯一特别的是：它的值不是你赋的，而是调用时自动从外面"灌"进来的。

7.2.3 实参传给形参（Arguments Fill Parameters）

7.2.3.1 一一对应的"对接" A one-to-one match

关卡强调："被调用时的实际参数，在函数定义时同形式参数对应。" 也就是说，调用括号里写什么，函数定义括号里的形参就接住什么——它们按位置一一对接。

7.3.1 定义带参函数（Defining with Parameters）

7.3.1.1 在括号里写下形参名 Write the parameter name in the parentheses

定义带参数的函数，只需在 def 的圆括号里写上形参的名字。然后在函数体里，就能像用普通变量一样使用它：

# 这个函数有一个形式参数 target
def checkAndAttack(target):
    if target:                 # 把 target 当变量用
        hero.attack(target)
    hero.moveXY(43, 34)    # 还可加与形参无关的指令

7.3.2 调用时传实参（Passing Arguments）

7.3.2.1 把准备好的信息递进去 Hand in the prepared information

调用时，把你准备好的具体值（实参）写进括号。典型流程是：先在外面找好目标存进变量，再把这个变量当实参传给函数。

hero.moveXY(58, 52)
topEnemy = hero.findNearestEnemy()   # 先找好目标
checkAndAttack(topEnemy)          # 把 topEnemy 作为实参传入

7.3.3 同一对象，两个名字（Same Object, Two Names）

7.3.3.1 外面叫 enemy，里面叫 target enemy outside, target inside

这是最值得品味的一点。"交给劈斩"关卡讲得极妙："enemy 是函数外敌人的名称，而 target 是函数内敌人的名称。这两个变量都指向同一个食人魔！"

def cleaveWhenClose(target):      # 函数内：这个敌人叫 target
    if hero.distanceTo(target) < 5:
        hero.attack(target)

enemy = hero.findNearestEnemy()  # 函数外：同一个敌人叫 enemy
cleaveWhenClose(enemy)          # enemy 被传进去，变成 target

7.4.1 形参当变量用（Use the Parameter as a Variable）

7.4.1.1 想怎么用就怎么用 Use it however you like

关卡反复提醒："target 可以像其他变量一样使用！" 你可以拿它去判断（if target:）、去攻击（hero.attack(target)）、去测距离（hero.distanceTo(target)），甚至读取它的位置（target.pos.x）。它就是个普通变量，只不过值来自外部。

7.4.2 加入额外指令（Adding Extra Instructions）

7.4.2.1 函数里不止能用形参 A function can do more than use its parameter

"捉迷藏"关卡指出："你可以在函数内将形参作为变量使用。当然，你也可以添加与形参无关的额外指令。" 比如下面这个函数，先用形参 item 去捡东西，再做一件和 item 无关的事——回到营地中央躲起来：

def checkTakeHide(item):
    if item:
        hero.moveXY(item.pos.x, item.pos.y)  # 用形参：去捡发光石
        hero.moveXY(40, 34)               # 额外指令：躲到营地中央

7.4.3 一个函数，多次调用（Call It as Many Times as You Want）

7.4.3.1 复用，是参数的最大价值 Reuse is the greatest value

"捉迷藏"还强调："同一个函数可以调用任意多次。" 这正是参数威力的集中体现——定义一次 checkTakeHide(item)，在右上角、左上角、各个搜索点反复调用，每次传入当地搜到的发光石。一份逻辑，覆盖整张地图。

这一节聚焦每一关的策略、思路与算法设计，看懂"为什么这样传参"，你就能自己写出完整解法。

7.5.1 边地之叉（Backwoods Fork）

7.5.1.1 策略：一个函数守两个路口 Strategy: one function guards two forks

图2：边地之叉——同一个 checkAndAttack 函数，分别处理上、下两路敌人

这是你第一次定义带参数的函数。地图有上、下两个路口，难点在于意识到两处的逻辑完全一样，只是目标敌人不同——这正是参数的用武之地。算法思路是：把"如果目标存在就攻击，然后回防"封进 checkAndAttack(target)，主循环里走到上路口找好 topEnemy 传进去，再走到下路口找好 bottomEnemy 传进去。

7.5.2 盗墓者（Grave Robber）

7.5.2.1 策略：用 if/else 给参数"分流" Strategy: branch on the parameter with if/else

图3：盗墓者——有敌人就打敌人,没敌人就专心砸门

这一关把参数和 if/else 结合得很巧。任务是边防御食人魔、边开墓门。算法思路是写一个 checkToDefend(target):如果 target 存在就攻击它,否则(没敌人时)就去攻击 "Door"。换句话说,函数根据传入参数是否为空,自动在"打敌人"和"砸门"之间切换。

def checkToDefend(target):
    if target:
        hero.attack(target)     # 有敌人 → 打敌人
    else:
        hero.attack("Door")   # 没敌人 → 砸门(注意用字符串)

7.5.3 墓地阴魂（Tomb of the Forgotten）

7.5.3.1 策略：打完就撤，攻击与走位结合 Strategy: hit and retreat

图4：墓地阴魂——攻击一下立刻退回红色标记躲避骷髅怪

这一关的战术核心是"打了就跑":出口被堵,还有骷髅怪在游荡,不能恋战。算法思路是写一个 hitOrHide(target):如果 target 存在,就攻击它,然后立刻移动到红色安全标记。攻击和走位被绑成一个动作,确保英雄出手后马上脱离危险。

7.5.4 捉迷藏（Hide and Seek）

7.5.4.1 策略：收集型任务的参数化 Strategy: parameterize a collection task

图5：捉迷藏——每到一个 X 标记搜发光石,捡到就躲回中央

任务是收集 4 颗发光石,且每次捡到后都要躲回营地中央。算法思路是:定义 checkTakeHide(item)——若 item 存在,先移动到它的位置捡起,再回到中央 (40, 34) 躲藏。主循环里,英雄逐个走到各 X 标记,在每处 findNearestItem() 搜一颗石头,把结果作为实参传给同一个函数。

7.5.5 森林矿工（Woodland Cleaver Mine）

7.5.5.1 策略：用参数判断"该打还是该喊话" Strategy: attack or call workers

图6：森林矿工——安全时喊农民来挖矿,有敌人时先清剿

这一关要保护矿工。算法巧思在于:只在没有敌人时才呼叫农民,否则贸然喊话会暴露并引来攻击。思路是写 checkEnemyOrSafe(target):如果 target 存在就攻击,否则用 hero.say("All clear!") 喊农民开工。和"盗墓者"如出一辙——根据参数是否为空,在两种行为间分流。

7.5.6 交给劈斩（Leave It to Cleaver）

7.5.6.1 策略：参数 + 距离 + 技能三重判断 Strategy: parameter + distance + skill check

图7：交给劈斩——等敌人靠近,劈斩就绪时放大招,否则普攻

这一关把前几个单元的本领全串了起来。算法思路是写 cleaveWhenClose(target):先用 hero.distanceTo(target) 判断目标是否靠近(小于 5 米),近了再嵌套判断 isReady("cleave")——技能好了就 cleave,没好就普通 attack(target)。参数、距离比较、嵌套 if/else、技能冷却,四样齐上阵。

def cleaveWhenClose(target):
    if hero.distanceTo(target) < 5:   # 用形参测距
        if hero.isReady("cleave"):
            hero.cleave()
        else:
            hero.attack(target)        # 还是用形参攻击

7.5.7 林地陷阱（概念挑战 · Forest Trap）

7.5.7.1 策略：用距离过滤"该不该打" Strategy: filter targets by distance

这是概念挑战,要求自己定义一个带参数的函数。战术核心是:只打靠近的食人魔,放过远处的投矛手——因为去碰远处的投矛手会引来一大群敌人。算法思路与"交给劈斩"几乎一致:cleaveWhenClose(target) 用 distanceTo 把距离当成"过滤器",只有近到一定范围(如 5 米内)的目标才出手,并优先用 cleave 防止敌人聚团。

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

7.6.1.1 参数环节的典型问题 Typical issues with parameters

图8：忘记传实参、形参名写错,是参数环节最常见的失误