函数与lambda：代码复用之基

可视化演示

展示fib(5)递归调用的展开过程，从根节点逐层展开至基准情况，再逐层返回计算结果。

函数基本概念

在厨房里，最让主厨安心的不是某个拿手菜，而是那本随时翻开的食谱卡。今天客人点番茄炒蛋，你翻出卡片照做；明天客人又点，你不需要重新发明创造。食谱把“怎么做”固化下来，这就是最初级的代码复用——一次书写，无数次执行。

Python 中的 def 关键字就是写食谱卡的动作。def 后面跟函数名、圆括号里的参数列表，以及冒号后缩进的代码块。这段代码不会在定义时立即执行，而是像食谱卡一样被小心存放，直到你用 函数名() 的形式去“点菜”——这叫函数的调用（call）。

函数还能附带 docstring，即写在函数体第一行的字符串，相当于食谱卡背面的提示笔记，说明这道菜适合什么场合。Python 内置的 help() 和 IDE 的智能提示都会读取它。此外函数在 Python 中是一等对象（first-class object），意味着函数可以像普通变量一样被赋值、被当作参数传递、被放进列表——这为后面的闭包、装饰器打下了地基。

有了食谱卡，重复劳动戛然而止。同样，在代码世界里，凡是出现三次以上的逻辑，你都会下意识地想：要不要把它单独写成函数？这是从“脚本小子”走向“代码主厨”的第一道门槛。

参数传递机制

客人点菜时，讲究的会说“两个番茄，三个鸡蛋”，这是按顺序报的；急性子的会喊“鸡蛋三个！番茄两个！”虽然顺序乱了，但菜名和数量都清晰，主厨也能听懂。前者好比位置参数（positional argument），后者好比关键字参数（keyword argument）。

位置参数按顺序依次匹配形参，少传或多传都会报错；关键字参数用 形参名=值 的方式传参，可以无视顺序，代码的可读性也更强。两种方式还可以混用，但必须把位置参数放在关键字参数前面，这也是 Python 的硬性语法。

默认参数（default argument）让形参在调用方缺省时自动获得预设值，就像食谱上写的“糖两勺，如果客人没交代就默认”。而 *args 和 kwargs 是两颗彩蛋：*args 把多出来的位置参数打包成一个元组，kwargs 把多出来的关键字参数打包成一个字典——相当于万能食材袋，无论食客怎么加料都能接住。

参数的灵活设计，决定了你写的函数像不像一间好餐厅：既给了常客固定的招牌菜（位置参数），也照顾了挑食客人的个性化需求（关键字与默认值），还接纳了突发的大规模宴席（*args 与 kwargs）。

返回值与解包

一道菜做完，主厨要把成品端到客人面前。函数也一样，return 语句负责把计算结果“端出”函数，交到调用者手里。如果函数没有 return，Python 会在函数结束时默认返回 None，就像上了一盘空气。

return 还意味着流程终止，就像端菜之后不会再回锅翻炒——return 之后的代码不会执行。这一点常被用来做早退（early return）判断：先处理异常和边界条件，让主逻辑留在函数最后。

Python 允许一次 return 返回多个值，比如 return x, y，实际上返回的是一个元组 (x, y)。配合序列解包（unpacking），调用方可以一句 a, b = f() 把结果拆开。这种“多菜同盘”的技法在返回坐标、状态码+消息等场景中非常常用。

恰当的返回值设计，是好函数与坏函数的分水岭。就像好餐厅的菜品稳定且分量清晰，你的函数应该每次都给出可预期的结果，并且调用方一眼就知道拿到的盘子里是什么。

作用域LEGB

一间大厨房分几个区域：炉灶旁触手可及的调料架、水槽边的备用柜、储藏室的大米袋，还有整栋楼公用的基础调料区。厨师在不同的位置，能直接够到的东西不一样——这就是“作用域”的直观感受。

Python 对名称的查找遵循 LEGB 规则：Local（局部）→ Enclosing（嵌套外层）→ Global（全局）→ Builtin（内置）。也就是说，函数内部先找局部变量，找不到再去外层嵌套的函数里找，再找不到去模块全局找，最后去 Python 内置的名称（如 len、print）里找。

如果要在函数内部修改一个全局变量，需要声明 global；要修改嵌套外层函数的变量，则需要 nonlocal。否则，Python 会把赋值语句左侧的变量一律视为局部变量，初学很容易踩 UnboundLocalError 的坑。这就像厨房里：你想挪动储藏室里的大米，得先跟管理员打声招呼（global），否则你只是在工作台旁新放了一袋米。

理解 LEGB，就像主厨记住厨房地图：既不会把手伸进别人的锅里（局部变量隔离），也知道上哪儿找公共资源（内置函数）、何时该申请权限（global/nonlocal）。干净的作用域管理，让代码天然低耦合。

闭包机制

一位主厨离开这家餐厅之后，随身带了一个便当盒，盒里装着他最爱的几味秘制调料。此后无论他去哪家餐厅做菜，打开便当盒就能还原那独特的味道——这个便当盒，就是闭包（closure）。

在 Python 中，当一个内层函数引用了外层函数的局部变量，并且外层函数把这个内层函数作为返回值返回时，内层函数连同它所引用的变量环境，就构成了闭包。外层函数的局部变量此时以“自由变量”的身份被内层函数记住，即使外层函数已经执行完毕，这些变量的值也不会消失。

如果要修改自由变量，需要在内层函数中使用 nonlocal 声明。闭包在需要携带状态又不想引入类的场景中特别有用，例如计数工厂、装饰器、回调函数。可以说闭包是把“数据 + 行为”打包的最小单位。

闭包是厨师最重要的私藏技艺，也是理解装饰器的必经台阶。当你写出一个“返回函数的函数”时，你已经站在 Python 高级特性的门口了。

lambda表达式

有时主厨并不会为一道简单小菜专门写一整页食谱，他会随手撕一张便签，写上“蒜末 + 生抽 + 香油 + 醋 = 凉拌汁”。这只在当下有用，但它足够快速、足够直接——这就是 lambda 表达式的气质。

lambda 的完整语法只有一行：lambda 参数: 表达式。它不需要 def、不需要函数名、不需要 return，表达式的值自动成为返回值。例如 lambda x: x * 2 等价于 def f(x): return x * 2。

但 lambda 有着严格的自我限制：体内只能写一个表达式，不能包含赋值语句、多行逻辑或文档字符串。这让 lambda 天然适合那些简单、临时、定义完马上用掉的场合。一旦逻辑变复杂，就说明该用 def 写一道正式食谱了。

用 lambda 就像用便签：写的时候痛快，但如果你发现这张便签开始承担复杂的流程，就该把它誊写为正式食谱。判断标准永远是“可读性优先”。

lambda高阶应用

便签食谱最常见的用法，是把它传递给其他工具。Python 的 sorted 函数接受一个名为 key 的形参，用来指定“按什么排序”——你给出一张便签，sorted 就会按便签上的规则把食材排好队。

例如 sorted(dishes, key=lambda d: d["time"])，会按每道菜的耗时从小到大排列。key 参数接收一个“把一个元素变成排序依据”的函数，lambda 在这里几乎是最自然的选择。类似的还有 map(lambda x: x * 2, data) 对每个元素做变换，filter(lambda x: x > 0, data) 筛选元素。

但这里有一个著名陷阱：在循环中创建 lambda 并立刻引用循环变量，会因为闭包捕获了变量本身（而非当时的取值）而导致所有 lambda 最终看到同一个值。比如 [lambda: i for i in range(3)] 这三个函数都返回 2。解决方法是给 lambda 绑定默认参数 lambda i=i: i，把当前值“快照”进便签。

lambda 是把双刃剑：用对了是高效调味，滥用则让代码变成无人能懂的乱码。高阶 Python 的成熟度不在于“用了多酷的语法”，而在于知道何时该用、何时该克制。

AI 应用场景

Python 演示

"""食谱厨房：函数与lambda实战演示"""  def make_dish(name, *ingredients, cooking_time=10, **options):    """把食材列表变成一道菜的字典。"""    if not ingredients:        raise ValueError(f"{name} 缺少食材，无法下锅")    dish = {"name": name, "ingredients": list(ingredients), "time": cooking_time}    dish.update(options)    return dish  def make_sauce(flavor):    """闭包：生成一个固定风味的调味函数。"""    def sauce():        return f"{flavor}味酱汁"    return sauce  def main():    # 1. 位置参数 + 默认参数 + 关键字参数    dish1 = make_dish("番茄炒蛋", "番茄", "鸡蛋", cooking_time=8, chef="小王")    print(dish1)     # 2. 可变参数把零散食材收进元组    dish2 = make_dish("大杂烩", "土豆", "牛肉", "胡萝卜", "洋葱", cooking_time=25)    print(dish2)     # 3. 闭包：走到哪里都带着秘制酱汁    secret = make_sauce("花椒")    print(secret())     # 4. lambda 作为排序规则    menu = [        {"name": "番茄炒蛋", "time": 8},        {"name": "红烧肉", "time": 40},        {"name": "拍黄瓜", "time": 3},    ]    quickest = sorted(menu, key=lambda d: d["time"])    print("最快上菜:", [d["name"] for d in quickest])     # 5. lambda 捕获陷阱与修复    funcs = [lambda i=i: i for i in range(3)]    print("快照修复:", [f() for f in funcs])  if __name__ == "__main__":    main()

1. def make_dish(name, *ingredients, cooking_time=10, **options):一行同时声明位置参数、可变参数、默认参数和关键字参数，覆盖全部传参方式。
2. if not ingredients:判断食材元组是否为空，缺少食材直接抛出异常，体现“早退”防御式编程。
3. dish.update(options)把 chef 等额外关键字参数合并进结果字典，**options 大显身手。
4. def make_sauce(flavor):外层函数，flavor 将成为闭包捕获的自由变量。
5. return sauce返回内层函数本身，让“便当盒”被带到函数外部。
6. secret = make_sauce("花椒")拿到一个自带花椒风味的函数，闭包状态随身携带。
7. quickest = sorted(menu, key=lambda d: d["time"])用 lambda 提取排序关键字，一行完成按耗时排序。
8. funcs = [lambda i=i: i for i in range(3)]绑定默认参数把循环变量“快照”，演示修复闭包捕获陷阱的标准写法。

常见误区

面试题