第 9 章　函数：封装与调用

9.1为什么需要函数：把重复代码打包

上一章的循环解决「同一段代码连续重复」，但还有一种重复：同一段逻辑，散落在程序的不同地方。

比如「计算长方形面积」这个逻辑，你可能在程序里三个地方都要用。没有函数，你只能把 长 × 宽 抄三遍：

area1 = 10 * 5
# ... 隔了很多行 ...
area2 = 8 * 3
# ... 又隔了很多行 ...
area3 = 12 * 6

问题很明显：

• 难维护：如果公式改成「长 × 宽 ÷ 2」（三角形），你得改三处，漏一处就出错。
• 难读：满屏都是 10 * 5，看不出「这是在算面积」。

函数（function）就是解决这个的：把一段代码打包，起个名字，之后用名字就能调用它。

深入一步：函数的「接口契约」

把函数看成黑盒，使用它只需要一份契约：给它什么（参数）、还你什么（返回值）。契约之外的一切——内部变量叫什么、先算哪一步——都是黑盒的私事，使用者不必知道，作者可以随时重构。这份契约思维是工程协作的地基：航电软件按模块分工，每个团队只维护自己模块的「契约」，别人的黑盒拿来就用。与之配套的是一条经济学：一次修改，处处生效——面积公式若要改进（比如加入单位换算），只需要改函数体一处，几十个调用点自动全部升级。规模越大，函数的价值越大。

def rect_area(w, h):
    return w * h

print(rect_area(10, 5))
print(rect_area(8, 3))
print(rect_area(12, 6))

辨析：函数与循环，一对互补的「反重复」工具

第 8 章说循环消灭「时间的重复」（同一件事做 100 遍），函数消灭「空间的重复」（同一段逻辑写在 100 处）。判断口诀再进一层：「数据在变、逻辑不变」找循环；「位置在变、逻辑不变」找函数。工程上两者常常联手——循环体里调函数，一边重复处理每个数据，一边把每步的逻辑封装成黑盒，这正是真实数据处理代码的标准骨架。

再进半步：函数命名的三条行业惯例

函数做的是「动作」，所以名字习惯用动词开头：calculate_area、check_oil、print_report——读调用处就像读一句祈使句。其二，见名知义压倒一切：fuel_needed 好过 f，check_oil 好过 check——长一点不怕，含混才致命；唯一例外是数学味极浓的场景（sqr、fact），惯例单刀直入。其三，前缀表达意图：is_/has_ 开头多返回布尔（is_ready），check_ 开头多用于「检查并给出结论」，update_ 开头明示「会就地修改」——读名字就能预判函数的脾气。命名是写给未来读者的第一行注释，值得多想十秒钟。

9.2def：定义一个函数

在 Python 里，用 def（define 的缩写，意为「定义」）来定义一个函数：

def 函数名(参数):
    函数体   # 缩进

看一个具体例子：

def say_hello():
    print("你好！")

say_hello()   # 调用函数，输出：你好！
say_hello()   # 再调用一次，又输出一次

这里有个关键点：def 定义函数时，函数体并不会执行，只是「登记」了一个函数。只有当后面用 say_hello() 调用它时，函数体才真正运行。

把这点类比成生活：def 相当于「写了一张菜谱」；调用 才是「照着菜谱做一次菜」。写菜谱时不炒菜，照着做才炒。

深入一步：def 只造不跑，调用才跑

一个常见误解是「def 里的代码马上执行」。机器实测给出反证：

def check():
    print("函数体执行了")

print("定义完成")
check()

输出顺序是「定义完成」在前、「函数体执行了」在后——执行到 def 那行时，Python 只做一件事：把函数体打包成一个函数对象，并把名字 check 绑到它上面；函数体一个字都没跑。只有调用 check() 那一刻，函数体才被「激活」。这解释了很多初学者困惑的现象：语法错误（比如函数体里少个冒号）在 def 行执行时就暴露——打包时要先通过语法检查；而 NameError（函数体里用了不存在的名字）要到调用时才炸——运行到那行才知道名字不存在。定义期管「语法」，调用期管「语义」，两个阶段各管一段。

def say_hello():
    print("你好！")

say_hello()
alias = say_hello
alias()
print(say_hello)

辨析：为什么惯例是「定义在上、调用在下」

既然 Python 从上往下执行，函数定义必须先于第一次调用，于是文件自然长成「上半部分一堆 def、下半部分主流程」的形状——这不是审美，是执行顺序的必然。看一份新代码时也照这个路线读：先跳到文件底部看主流程（它像目录，列出程序要做哪几件事），再回头逐个读函数定义——主流程告诉你「做什么」，函数定义告诉你「怎么做」。

再进半步：函数是值，值能去的地方函数都能去

例题 2 的 alias 证明了一件比表面更深的事：函数是「一等公民」——它像数字、字符串一样是个值。值能做的事，函数都能做：存进变量（alias = say_hello）、放进列表、当参数传给另一个函数……最后这一项是函数式编程的大门：让「操作本身」成为被传递的数据——「排序时用哪个规则比较」「遍历时对每项做什么」，都可以把函数递进去。第 12 章讲排序时会真正用到它；现在先把「函数是值」这颗种子埋下，见到 key=len 这类写法时它自会发芽。

9.3参数：给函数「喂」数据

上面的 say_hello() 太死板了——它每次都说同一句话。真正有用的函数，应该能接收不同的数据，做出不同的结果。这个「接收数据」的通道，就是 参数（parameter）。

def greet(name):
    print("你好，" + name)

greet("小明")   # 输出：你好，小明
greet("小红")   # 输出：你好，小红

拆解一下：

• def greet(name)：定义时，name 是参数，是一个「占位符」，表示「将来会有一个值从这里传进来」。
• greet("小明")：调用时，"小明" 是实参（实际参数），它被「塞进」占位符 name。
• 函数体里的 name，此时就等于 "小明"。

一个函数可以有多个参数，用逗号隔开：

def add(a, b):
    print(a + b)

add(3, 5)   # 输出：8

深入一步：三种传参写法，一张嘴说清

def fuel_needed(distance, per_km=3):
    return distance * per_km

print(fuel_needed(1000))
print(fuel_needed(1000, 4))
print(fuel_needed(distance=800))
print(fuel_needed(per_km=5, distance=200))

深入一步：传的是「对象的引用」

「Python 到底是值传递还是引用传递」是经典争论，精确答案是：传对象引用（pass by object reference）。效果用一句口诀记住：函数里「原位修改」对象，外部看得见；「重新绑定」名字，只改了函数自己的局部。列表的 append 属于前者——在原对象上动手；x = 99 属于后者——让局部名字 x 指向新对象，外面的名字不受影响。

def add_item(items):
    items.append("坚果")

def set_new(x):
    x = 99

snacks = ["能量棒"]
add_item(snacks)
print("调用后：", snacks)

n = 5
set_new(n)
print("调用后：", n)

再进半步：形参、实参，一对常被混叫的名字

把术语钉牢：形参（parameter）是函数定义里那些占位的名字——def fuel_needed(distance, per_km=3) 里的 distance、per_km，它们像表格里的空栏；实参（argument）是调用时真正递过去的值——fuel_needed(1000) 里的 1000。「对号入座」说的就是实参填进形参的过程：位置参数按栏位顺序填，关键字参数直接报栏位名填。日常对话里「传个参数」两边都指，但读技术文档时分清这对词，很多句子会立刻通顺：「默认值绑定在形参上」「实参按位置求值」——说的都是同一套机制的两侧。

9.4返回值：函数「吐」结果

参数是「喂进去」的数据，返回值（return value）则是函数「吐出来」的结果。用 return 关键字：

def add(a, b):
    return a + b      # 把结果「吐」出去

result = add(3, 5)    # result 拿到 8
print(result)         # 输出：8

这里 return a + b 做了两件事：

1. 算出 a + b 的值（8）。
2. 把这个值「送回」给调用者，并且函数到此结束。

于是 add(3, 5) 整个表达式就「变成了」8，就像它是个值一样。这就是函数调用能出现在 result = add(3, 5) 右边的原因。

深入一步：return 的三重身份

return 一词身兼三职：结束——执行到它，函数立刻收工，后面的语句一句不跑；交回——把右边的值送还给调用处；占位成值——「函数调用」这个表达式本身就是一个值，可以进运算、可以进 print、可以再当参数传。第三条常被初学者忽略：area = rect_area(10, 5) * 2 里，调用直接参与了乘法——函数调用就是值，与写 50 无异。

不写 return，函数返回什么？

机器实测：

def greet(name):
    print("你好，", name)

result = greet("小明")
print(result)

输出两行：「你好， 小明」和「None」。greet 只打印、没 return——Python 规定这种函数返回 None（表示「没有值」的特殊值，第 5 章见过）。print 与 return 是两条完全不同的通道：print 是「说给人听」（往屏幕输出），return 是「递给程序」（把值交回调用处）。只打印不 return 的函数，调用处永远拿到 None——「程序里看起来有结果，代码里拿不到结果」的经典 bug 就是这么来的。

def grade(score):
    if score >= 90:
        return "优秀"
    if score >= 60:
        return "可以进入下一阶段训练"
    return "不及格，需补训"

print(grade(72))
print(grade(95))
print(grade(58))

辨析：返回值驱动决策，打印只是汇报

判断一个函数该 return 还是 print，问一句：「调用它的代码，要用这个结果做后续计算吗？」要用——必须 return；只是给人看的汇报——print。二者兼得的真实场景是「print 用于日志留痕，return 用于程序流转」：函数把结果 return 出去参与决策，顺带 print 一行记录在案。初学阶段最常见的坏味道，是把所有函数都写成「只 print 不 return」——程序每一步的产出都只存在于屏幕上，代码之间无法协作。函数之间递的是 return，不是屏幕。

再进半步：例题 5 的风格，学名叫「早退」

例题 5 那种「一串 if + return 置于函数开头」的写法，业界有个正式名字：早退模式（guard clause，卫语句）。它的对手是「大泥球嵌套」——把主逻辑整个裹进 if/else 的层层缩进里，读到第五层缩进时人已经晕了。早退把「不满足就先走人」的条件提到最前面，一次 return 一层筛，剩下的主干逻辑零嵌套、顶格写——函数读起来像安检口：不合格的旅客在门口就被请走，走到里面的都是「确定要处理」的情况。需要层层过滤的业务（参数校验、状态检查）优先用早退重写，可读性立竿见影。

9.5作用域：变量住在哪一层

函数会带来一个微妙的问题：函数里定义的变量，函数外能用吗？反过来呢？这就涉及 作用域（scope）——变量「可见、可用」的范围。

def my_func():
    x = 10          # x 定义在函数内部
    print(x)        # 函数内能用，输出 10

my_func()
print(x)            # 报错！函数外访问不到 x

原因在于：函数内部定义的变量，是「局部变量」，只在函数内有效。函数执行完，这些变量就「消失」了（它们的内存被回收）。函数就像一个小房间，房间里的东西，外面看不见。

反过来，函数可以读到外面（全局）的变量，但要修改它们需要特别声明。为了简单，先记住这条核心规则：

深入一步：LEGB——名字查找的四级路线

函数是独立房间，但房间不隔音：函数里用到的名字，Python 按固定的四级路线查找，一级找不到再下一级，找到即停：

四个字母由内向外排成 L→E→G→B，就是名字查找的路线图。反过来读更实用：内层看不见外层的「改」，但看得见外层的「读」——这正是「函数像独立小房间」的精确含义：墙是半透明的，光能进来，手伸不出去。

x = "全局"
def outer():
    x = "外层函数的"
    def inner():
        print(x)
    inner()
outer()

msg = "全局"
def shadow():
    msg = "局部"
    print("函数内读到：", msg)
shadow()
print("函数外读到：", msg)

global 与一个著名陷阱：UnboundLocalError

函数内确实需要修改全局变量时，得先声明 global count——机器实测：count 初值 0，函数里 global 后自增，调用两次，外部打印 count = 2，修改真实生效。但更大的价值在反例：

def broken():
    y = y + 1   # UnboundLocalError！

机器实测报错 UnboundLocalError: cannot access local variable 'y' where it is not associated with a value。原因很微妙：函数体里只要出现对 y 的赋值，y 就被判定为局部变量——于是右边那个 y 在「局部 y 还没被赋值」时就被读取，炸了。哪怕外面明明有个全局 y，也帮不上忙。这个陷阱专挑「函数里给全局变量做自增」的写法——解法有二：小的共享计数用 return 接力（局部算好、外部接收），确需直接改再上 global。global 是重量级工具，能不用就不用：它把函数的「独立性」凿了个洞，用过 global 的函数从此和全局名字锁死，搬到别的程序就散架。

再进半步：B 层也会被遮蔽——别给变量起名叫 print

LEGB 的 B 层（内置名）看起来遥不可及，其实一伸手就能盖住它：只要在函数里（或更糟，在全局）写一句 print = 5，print 这个名字就在你那一层「落户」了——之后调用 print("你好")，机器实测报 TypeError: 'int' object is not callable：名字找到了，但找到的是 5，而整数不能被调用。这类「把内置名占为己用」是新手最容易踩的隐形坑——代码在改那行之前全都正常，改完之后所有用到该名字的地方集体罢工。自查办法很简单：给变量起名时心里过一遍「这是不是 Python 自带的名字」——print、len、sum、max、min、list、str、int……这份黑名单会随着学习自然长在直觉里。

9.6底层原理：调用栈

最后，我们追到底：当程序调用一个函数时，内存里到底发生了什么？答案是——一个叫 调用栈（call stack）的结构。

调用栈是内存里专门开辟的一块区域，用来管理「函数调用的来龙去脉」。它像一叠盘子：每调用一个函数，就往栈顶放一个「栈帧」（stack frame）；函数执行完，就把这个栈帧拿掉。

一个栈帧里存着什么？

• 参数：调用时传进来的值。
• 局部变量：函数里定义的变量。
• 返回地址：记住「函数执行完后，该回到哪里继续」。

看这个例子：

def add(a, b):
    return a + b

def main():
    result = add(3, 5)   # 调用 add
    print(result)

main()

深入一步：栈帧——调用栈上的「工作台」

每次函数被调用，调用栈上就摞起一块栈帧（stack frame）——函数专属的工作台，上面摆三样东西：参数的值（实参对号入座的落点）、局部变量（函数体里创建的名字）、返回地址（回哪儿继续执行的记号）。函数返回时，整块工作台连同行装一起被撤下——这就是「局部变量随函数结束而消失」的物理真相：不是清空，是整块工作台都拆了。后进先出的栈规则与「嵌套调用、逐层返回」天然绝配：最后被调用的函数一定最先返回——最上面的工作台先撤，撤一层，下面的正好接上。

def c():
    print("进入 c")

def b():
    print("进入 b")
    c()
    print("离开 b")

def a():
    print("进入 a")
    b()
    print("离开 a")

a()

递归入门：函数调用自己

函数能调用自己——这叫递归（recursion）。看似怪圈，放到调用栈上立刻讲得通：每递归一层，栈上多摞一块同名的帧，各帧的参数各不相同。经典例子是阶乘——数学定义本身就是递归的：fact(n) = n × fact(n-1)，且 fact(1) = 1：

def fact(n):
    if n == 1:
        return 1          # 出口：不再继续递归
    return n * fact(n - 1)

两行结构对应两个必备部件：出口（n == 1 时直接返回，不再往下钻）与递推（n 乘「下一层的结果」）。没有出口的递归会一层层无限制压栈——Python 默认把深度限制在约 1000 层，超限抛出 RecursionError（机器实测 sys.getrecursionlimit() 为 1000；fact(3000) 果然触发 RecursionError）。这个限制是栈保护的「安全带」——真实内存有限，不能让失控的递归把栈压爆。

辨析：递归 vs 循环——同一道题的两把刀

阶乘既可以用循环算（第 8 章累乘器），也可以用递归算（本章 fact）——结果相同，味道不同。循环是一根筋走到底、中途不停；递归是先拆到底、再逐层合并答案，天然适合「问题本身能切成同构小子问题」的形状：阶乘、文件夹里数文件（文件夹套文件夹）、表达式求值（括号套括号）。工程上的务实建议：能用循环就用循环——它没有栈深度的顾虑，也更好读；递归留给「结构天生递归」的问题，并永远先写出口。两把刀都挂腰上，按题选刀。

再进半步：深度上限是安全带，不是障碍物

Python 提供 sys.setrecursionlimit(n) 可以调高递归深度，但轻易别动：1000 层的上限是「安全带」——它在内存被压爆之前把程序拦下来，报一个还能看懂的 RecursionError，而不是让进程无声无息地崩掉。另一个必须知道的事实：有些语言对「递归调用恰好发生在函数最后一步」的情形会自动优化成循环（不压新帧，术语叫尾调用优化），Python 没有这个优化——同样的递归写法，在别的语言里能跑百万层，在 Python 里 1000 层就到顶。所以在 Python 里，「递归深度可能很大」的场合，一开始就该设计成循环——这不是退让，是对语言特性的尊重。