环境：名字到底在哪里被找到

0. 本讲导读

上一讲把函数抬成了「值」：函数可以当参数传进去，可以当返回值传出来，可以绑定到名字上。这一下子打开了表达能力，但也打开了一个新麻烦——写在一个地方的代码，可能在完全不同的地方被执行。

make_adder(2) 返回的那个 adder 函数，它的函数体里写着 n + k。这个函数被返回到全局，被赋值给 a，然后在全局被调用。可这时候 make_adder 早就执行完了，n 这个名字在全局根本不存在。那 a(1) 为什么还能算出 3？n 是从哪儿翻出来的？

再看一个更刺眼的：

j = 3
def h(i):
    j = 4
    return lambda z: j * i(z)
h(lambda z: j + z)(j)

这段代码里出现了四个 j。它们指的是同一个东西吗？哪个是 3，哪个是 4？光靠「从上往下读一遍」根本回答不了。你需要一套不依赖直觉、纯机械执行的记账方法——这就是环境图（environment diagram）。

环境图不是「教学辅助工具」，也不是「初学者的拐杖」。它就是 Python 解释器实际在做的事，只不过画在纸上。61A 从这一讲起，一直到期末考、到 Scheme 解释器项目，都在反复用它。本讲不引入任何新语法——def、lambda、return 你都见过了；本讲要做的是把它们的执行规则钉死，钉到你能在纸上一步不错地模拟出来。

之所以这一讲安排在这里，是因为下一讲就是递归。递归的本质是「同一个函数的多个调用同时活着，各自有各自的一套局部名字」——如果你脑子里没有「一次调用 = 一个新帧」这幅图，递归看起来就会像变魔术。

1. 为什么必须画图：三个只靠读代码答不出的问题

先说服自己「有必要」，再学规则，学起来会快很多。下面三段代码，每一段都短到可以一眼看完，但每一段的答案都不是「一眼」能得到的。

问题一：函数执行完了，它的局部名字还活着吗

def make_adder(n):
    def adder(k):
        return n + k
    return adder

a = make_adder(2)
b = make_adder(3)

make_adder(2) 这个调用已经结束了。按「函数调用结束，局部变量销毁」的朴素说法，n 应该没了。可是 a(1) 确实返回 3，b(1) 确实返回 4——不但 n 还在，而且两次调用留下的 n 互不干扰，一个是 2 一个是 3。

这说明「帧」不是一个简单的栈上临时空间。只要还有函数对象把某个帧记成自己的 parent，那个帧就得留着。环境图能把这件事画出来：a 和 b 各自指着一个 adder 函数对象，两个对象的 parent 指向两个不同的 make_adder 帧。

问题二：同名的名字，到底是哪一个

j = 3
def h(i):
    j = 4
    return lambda z: j * i(z)
h(lambda z: j + z)(j)

这里 j 出现了四次：全局的 j = 3、h 里的 j = 4、返回的那个 lambda 体里的 j、以及作为实参传进去的 lambda z: j + z 体里的 j。最后那两个 j 长得一模一样，但它们查到的值不同——一个是 4，一个是 3。原因完全取决于这两个 lambda 是在哪一帧里被定义的。

没有环境图，这题只能靠猜。有了环境图，它是一道纯机械题（答案是 24，第 8 节会一步不落地画完）。

问题三：错误到底发生在哪一行

x = 10

def bar():
    print(x)

def foo():
    print(x)
    x += 1

bar() 正常打印 10。foo() 呢？大多数人的第一反应是「print(x) 打印 10，然后 x += 1 那行报错，因为不能改外层变量」。

错。报错发生在 print(x) 那一行，也就是「看起来完全没问题」的那一行。这不是 Python 在耍你，而是名字作用域的规则比你想的要早生效。第 3 节专门拆这个。

2. 规则 1 与 2：帧、绑定，以及「向上查找」

三个词：environment、frame、binding

先把词认清楚，后面才不会含混。

「环境」这个词最容易被误用。它不是某一个帧，而是「当前帧 + 它的 parent + parent 的 parent + …… + 全局帧」这一整条链。同一个程序在不同时刻、不同帧里执行，环境是不同的。你听到「在某某环境下求值这个表达式」，意思就是「按这条链的顺序去查名字」。

还有一条容易忽略的规定：全局帧没有 parent。它是查找链的终点，也是「再找不到就只能报错」的那道墙。所有 Python 程序都从全局帧起步。

规则 2：parent 是「定义处」，不是「调用处」

把规则 2 拆成四句可执行的话：

第 2 步值得单独强调，因为它是唯一容易记反的地方。新帧的 parent 不是「谁调用了我」，而是「我在哪里出生」。 前者叫动态作用域（dynamic scoping），后者叫词法作用域（lexical scoping）——Python、Scheme 以及你能想到的绝大多数现代语言用的都是后者。

用一段代码把这个区别顶出来：

x = 'global'

def show():
    return x            # 这个 x 查哪儿？

def caller():
    x = 'local'
    return show()       # 在 caller 帧里调用 show

caller() 返回 'global'，不是 'local'。

Global frame
    x       ──→ 'global'
    show    ──→ func show()   [parent=Global]
    caller  ──→ func caller() [parent=Global]

f1: caller  [parent=Global]
    x       ──→ 'local'          # 只有 f1 自己看得见
    返回值   ──→ 'global'

f2: show    [parent=Global]      # ← parent 是 Global，不是 f1
    (无形参)
    返回值   ──→ 'global'

把 f2 的 parent 画成 f1，你就会答成 'local'——这是初学阶段最高频的错误之一。防错的办法很笨但很有效：写 parent 时，不要看「我现在在哪一帧」，去看「这个函数对象是在哪一帧里被 def 出来的」。

为什么查找是「向上」而不是「向下」

顺带解释一个常被忽略的不对称性：内层能看见外层，外层看不见内层。caller 帧里定义的 x，全局看不见；但全局的 x，任何帧都可能看见。

这个设计是有道理的。函数是一个「封装」：它承诺不把自己的中间变量泄漏出去，否则你每写一个函数都得担心它的局部名字会不会撞坏别人。反过来，内层能看见外层，是为了让函数能用到它写作时周围的东西（全局的其他函数、常量、以及闭包捕获的值）。信息单向流动，从外往内。

3. UnboundLocalError：一次赋值决定整个函数体

回到第 1 节的第三个问题。这是这一讲唯一一个「规则之外的补充规则」，但它出现频率极高，必须单独说清。

x = 10

def bar():
    print(x)

def foo():
    print(x)
    x += 1

先跑 bar()：

>>> bar()
10

符合预期：bar 的帧里没有 x，向上查到全局的 10。

再跑 foo()：

>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
    print(x)
UnboundLocalError: local variable 'x' referenced before assignment

报错行是 print(x)，也就是 foo 体内的第一行。它跟 bar 里那行一模一样，bar 跑得好好的，foo 却炸了。唯一的区别是 foo 在后面多了一句 x += 1。

注意这里的因果链，别记反了：

Global frame
    x    ──→ 10
    bar  ──→ func bar()  [parent=Global]
    foo  ──→ func foo()  [parent=Global]

f1: foo  [parent=Global]
    x    ──→ ???        # 被判定为局部名字，但还没有值
                        # 读它 → UnboundLocalError（不会去 Global 拿 10）

「不会向上查找」是关键。普通情况下查不到就往上走，但一旦某个名字被判定为局部，向上查找这条路就被切断了——要么局部有值，要么报错，没有第三种可能。

>>> def g():
...     print(x)
...     if False:
...         x = 1
...
>>> g()
UnboundLocalError: local variable 'x' referenced before assignment

那怎么才能在函数里真的修改外层变量？Python 提供了 global 和 nonlocal 两个声明。61A 在这一讲不用它们（nonlocal 要到讲可变数据、账户余额那一讲才登场），现阶段你应该做的是换一种写法绕开：需要外层的值就当参数传进来，需要把结果送出去就 return。

4. 规则 3：定义函数时，究竟发生了什么

先立一个原则：定义 ≠ 执行。执行一条 def 语句，函数体一行都不会跑。

这不是细节，是环境图最常见的画错点。看到 def f(x): return 1/0，很多人会紧张——除以零！但只要没人调用 f，这段代码永远不会出错。函数体在定义时是一段被封存的代码，只在调用时才解封执行。

def 语句的两件事

写进环境图时，函数对象记成 func 名字(形参) [parent=某帧]。方括号里的 parent 是整张图的骨架，漏写 parent 的环境图等于没画。

def make_adder(n):
    def adder(k):
        return n + k
    return adder

这段代码在全局帧执行时，只发生一件事：全局帧多了一条绑定 make_adder → func make_adder(n) [parent=Global]。里面那个 def adder 此刻完全没有执行——它是 make_adder 函数体的一部分，只有在 make_adder 被调用时才会执行。

Global frame
    make_adder ──→ func make_adder(n) [parent=Global]

# 没有 adder。adder 这个名字此刻在任何地方都不存在。

lambda：一模一样，只是没名字

lambda 表达式被求值时做的事，和 def 语句做的第 1 步完全相同：造一个函数对象，parent 指向当前帧。区别只有两点：

因为 lambda 没有内在名字（intrinsic name），61A 的约定是用希腊字母 λ 加上它在源码里的行号来指代它，比如 λ3 表示「第 3 行那个 lambda」。

看一个「同一行 lambda 造出两个不同对象」的例子：

def make(n):
    return lambda k: n + k     # 第 2 行

p = make(1)
q = make(2)

Global frame
    make ──→ func make(n) [parent=Global]
    p    ──→ func λ2(k)   [parent=f1]
    q    ──→ func λ2(k)   [parent=f2]

f1: make [parent=Global]
    n      ──→ 1
    返回值  ──→ func λ2(k) [parent=f1]

f2: make [parent=Global]
    n      ──→ 2
    返回值  ──→ func λ2(k) [parent=f2]

p 和 q 是两个不同的函数对象，虽然它们的代码来自同一行。p(10) 得 11，q(10) 得 12——差别全在 parent 指向的帧里那个 n。函数对象 = 代码 + parent；代码相同而 parent 不同，就是不同的函数。

lambda 和 def 可以互相改写

下面两段代码在环境图上产生的结构完全等价：

(lambda x, y: lambda z: x * y + z)(1, 2)(3)

def outer(x, y):
    def inner(z):
        return x * y + z
    return inner

outer(1, 2)(3)

两者都得到 1 * 2 + 3 = 5。差别只有：lambda 版里的函数对象在图上叫 λ1 和内层的 λ，def 版里叫 func outer(x, y) 和 func inner(z)；而且 lambda 版的外层函数从未被绑定到任何名字上——它被造出来、被立即调用、然后就没人指着它了。

>>> f = lambda z: return z
  File "<stdin>", line 1
    f = lambda z: return z
                  ^^^^^^
SyntaxError: invalid syntax

5. 规则 4：调用函数时，究竟发生了什么

三步流程

第 2 步的「从左到右」不是废话。f2(print('a'), 10 % 3) 这样的表达式里，print('a') 有副作用（往屏幕打字），什么时候打、打在哪一行输出之前，完全由求值顺序决定。第 9 节会用这道题验证。

新建一帧只有一个原因

帧的编号约定：全局帧不编号，就叫 Global frame；其余按创建的先后顺序编号 f1、f2、f3……编号不复用，就算 f1 已经返回退出了，下一帧也叫 f2。帧的标题写「f编号: 函数的内在名字 [parent=…]」。

「每个函数都会返回点什么」

没有 return 的函数返回 None，这一点在 WWPD 题里几乎每次都要考。三种容易混淆的情况：

最后一行的 x + y 值得多说一句。作为一条语句单独出现的表达式，它确实被求值了——如果里面有函数调用，那些调用真的会发生、副作用真的会产生——但求出来的值随即被丢弃，因为没人接收它。第 9 节 Q3 里的 f1 结尾正是这么写的，这是一个经典的「以为写了 return 其实没写」的陷阱。

>>> def f(x):
...     return 'never used'
...
>>> f(1 / 0)
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

6. 完整走一遍：嵌套 lambda

规则齐了，现在拿上一讲那个嵌套 lambda 一步不落地走完。这是本讲第一个「必须动笔」的例子。

(lambda x, y: lambda z: x * y + z)(1, 2)(3)

先看清结构。整个表达式是两次调用：

• 外层调用：算子是 (lambda x, y: lambda z: x * y + z)，算子数是 1, 2。
• 再对它的结果调用一次：算子是上一步的返回值，算子数是 3。

写成 ((lambda x, y: ...)(1, 2))(3) 更清楚。Python 里 f(a)(b) 永远是「先算 f(a)，再把结果当函数调用，传 b」。

为了标行号，把它按行摊开（假设这是文件的第 1 行）：

1  (lambda x, y: lambda z: x * y + z)(1, 2)(3)

两个 lambda 都在第 1 行，为了区分，把外层记作 λ1a、内层记作 λ1b（考试里通常两个 lambda 不会挤在同一行，直接用行号就够）。

（上表 Global frame 里那行 λ1a 只是为了让你看到这个对象存在；实际画图时它是一个飘在旁边、没有名字指着的函数对象。）

关键的一步是第 6 步：f2 的 parent 是 f1。f1 已经返回、已经「用完」了，但它不能被丢掉，因为 λ1b 还记着它。这正是第 1 节问题一的答案——只要还有函数对象把某帧当 parent，那一帧就必须活着。这个「函数 + 它出生时所在的那个环境」的组合，就叫闭包（closure）。

改写成 def 版对照

1  def outer(x, y):
2      def inner(z):
3          return x * y + z
4      return inner
5
6  outer(1, 2)(3)

Global frame
    outer  ──→ func outer(x, y) [parent=Global]

f1: outer  [parent=Global]
    x       ──→ 1
    y       ──→ 2
    inner   ──→ func inner(z) [parent=f1]   # def inner 在 f1 里执行，故 parent=f1
    返回值   ──→ func inner(z) [parent=f1]

f2: inner  [parent=f1]
    z       ──→ 3
    返回值   ──→ 5      # x 从 f1 拿 1，y 从 f1 拿 2，z 本帧 3

唯一的结构性差别：def 版里 f1 多了一条绑定 inner → func inner(z)（因为 def 会在当前帧绑定名字），lambda 版没有。返回值、parent 链、最终结果全都一样。

7. Q1 Make Adder：闭包，和四条 WWPD 约定

课上的第一道练习。代码你已经在上一讲见过，但这次要用环境图把它算准，还要按 WWPD 的书写规范作答。

def make_adder(n):
    def adder(k):
        return n + k
    return adder

>>> a = make_adder(2)
>>> a
____________
>>> a()
____________
>>> b = make_adder(3)
>>> a(1)
____________
>>> b(1)
____________

先说 WWPD 的四条书写约定

逐行算

>>> a 求值成一个函数对象 → 答案 Function。

>>> a()：a 确实是函数，但它的形参表是 (k)，需要恰好一个实参，你给了零个 → 答案 Error。真实报错是：

>>> a()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: make_adder.<locals>.adder() missing 1 required positional argument: 'k'

这个 TypeError 发生在施加阶段之前——实参和形参对不上，函数体一行都没进。

>>> b = make_adder(3)：新建 f2，n → 3，造出另一个 func adder(k)，parent = f2。b 指向它。显示 Nothing。

>>> a(1)：新建 f3，parent = f1（a 指的那个对象记着 f1），绑定 k → 1。求值 n + k：n 在 f3 没有 → f1 → 2；k = 1。返回 3。

>>> b(1)：新建 f4，parent = f2，k → 1。n 从 f2 拿 → 3。返回 4。

8. Q2 Too many letters!：同一个字母，三个不同的值

本讲难度最高的一道，也是最能检验你是不是真的在按规则走而不是在猜。

1  j = 3
2  def h(i):
3      j = 4
4      return lambda z: j * i(z)
5  h(lambda z: j + z)(j)

题目问：第 5 行这个表达式的值是多少？

先把结构看清

第 5 行是 (h(...))(j)——两次调用。外层调用的算子是 h(lambda z: j + z)，算子数是 j。按规则 4，算子先于算子数求值，所以先把 h(...) 整个算完，再去算最后那个 j。

代码里有两个 lambda：第 4 行的 lambda z: j * i(z)，记作 λ4；第 5 行的 lambda z: j + z，记作 λ5。它们的形参都叫 z，函数体里都有 j，但出生地不同——这就是全部的关窍。

Global frame
    j  ──→ 3
    h  ──→ func h(i) [parent=Global]
           func λ5(z) [parent=Global]   # 作为实参传进 h，全局没有名字指着它

f1: h   [parent=Global]
    i       ──→ func λ5(z) [parent=Global]
    j       ──→ 4                        # 只属于 f1，遮蔽不了全局的 j
    返回值   ──→ func λ4(z) [parent=f1]

f2: λ4  [parent=f1]                      # ← parent 是 f1
    z       ──→ 3                        # 实参是在 Global 求出的 j，即 3
    返回值   ──→ 24                       # j(=4，来自 f1) * i(3)(=6)

f3: λ5  [parent=Global]                  # ← parent 是 Global，不是 f2
    z       ──→ 3
    返回值   ──→ 6                        # j(=3，来自 Global) + z(=3)

答案：24。

三个 j 各查到什么

三处同名，两个不同的值，靠的全是「这个函数是在哪一帧里被造出来的」。λ5 写在第 5 行、在全局被求值，所以它的 j 永远是全局的 3——哪怕它被传进 h、在 f2 里被调用、身边全是 f1 的东西，也没用。

改写成 def 版验证

如果上面的推演还是绕，用课上给的建议把两个 lambda 都翻成 def：

j = 3

def h(i):
    j = 4
    def inner(z):
        return j * i(z)
    return inner

def arg(z):
    return j + z

h(arg)(j)

翻完之后一切都直白了：arg 是在全局 def 的，它的 j 当然是全局那个 3；inner 是在 h 体内 def 的，它的 j 当然是 h 里那个 4。lambda 版之所以难，纯粹是因为它把「def 在哪儿」这条信息藏进了一行密集的表达式里。

9. Q3 Statements Galore：显示什么 vs 返回什么

这道题不考闭包，考的是 WWPD 的另一半：分清「屏幕上出现了什么」和「表达式的值是什么」。

def f1(x, y):
    if x > (x + y):
        print(x)
        y = x
    if x > (x - y):
        print(y)
        x = y
    x + y

def f2(a, b):
    if a:
        return b and a
    else:
        return a or b

先看 f1 的两个「陷阱构件」：

• 它有两个独立的 if（不是 if/elif）。第一个 if 执行与否，都要继续考察第二个 if；而且第一个 if 里的 y = x 会改变第二个 if 的条件值。
• 最后一行是 x + y，不是 return x + y。这个表达式被求值，值被丢掉，函数隐式返回 None。

>>> z = f1(3, -5)

屏幕上依次出现：3、3。答案就是这两行，没有第三行。

>>> z

z 绑的是 None，交互式解释器不显示 None。答案：Nothing。

>>> f1(-4, 7)

屏幕上只有一行：7。不要再补一个 None——这正是很多人多写的那一行。

>>> f2(print('a'), 10 % 3)

这一问同时考三件事：算子数的求值顺序、print 的返回值、and/or 返回的到底是什么。

屏幕上依次出现：a、1。

四问汇总

10. Q4 Sheep Detectives：被名字骗了

1  winter_lamb = lambda george: 2 ** george
2  lily = lambda detective: lambda: detective
3  mopple = 3
4  def sebastian(f, g, h):
5      return f(g(h))
6  sebastian(lily, winter_lamb, mopple)()

先做三项体检

拿到这种题，先别急着算，花十秒钟看清三件事：

三个 lambda：第 1 行的记作 λ1（形参 george），第 2 行的外层记作 λ2a（形参 detective），第 2 行的内层记作 λ2b（无形参）。

Global frame
    winter_lamb ──→ func λ1(george)     [parent=Global]
    lily        ──→ func λ2a(detective) [parent=Global]
    mopple      ──→ 3
    sebastian   ──→ func sebastian(f, g, h) [parent=Global]

f1: sebastian  [parent=Global]
    f       ──→ func λ2a(detective) [parent=Global]
    g       ──→ func λ1(george)     [parent=Global]
    h       ──→ 3                    # 是个整数！不是函数
    返回值   ──→ func λ2b()          [parent=f3]

f2: λ1   [parent=Global]
    george  ──→ 3
    返回值   ──→ 8                    # 2 ** 3

f3: λ2a  [parent=Global]
    detective ──→ 8
    返回值     ──→ func λ2b() [parent=f3]   # 内层 lambda 此刻才诞生

f4: λ2b  [parent=f3]
    (无形参)
    返回值   ──→ 8                    # detective 从 f3 拿到 8

答案：8。如果去掉末尾那对括号，sebastian(lily, winter_lamb, mopple) 的答案就是 Function。

这题的三个设计意图

11. 画环境图的操作流程

把前面所有规则压成一套可以照着做的动作。考试时按这个顺序走，基本不会出错。

动手前

逐条语句处理

查名字时

五个高频错误自查

本讲小结

本讲四道题的答案速查

动手练习

五道题，都请先在纸上把环境图画完再展开答案。只在脑子里过一遍不算数——本讲的全部价值就在「能不能真的画对」。

练习 1：形参遮蔽

a = 1

def f(a):
    a = a + 1
    return a

在解释器里依次输入 f(a) 和 a，各显示什么？

Global frame
    a  ──→ 1            # 全程没变
    f  ──→ func f(a) [parent=Global]

f1: f  [parent=Global]
    a      ──→ 1  然后改成 2
    返回值  ──→ 2

练习 2：parent 到底是谁

def outer():
    x = 'outer'
    return inner

def inner():
    return x

x = 'global'

outer()() 的值是什么？如果把最后一行 x = 'global' 删掉呢？

练习 3：闭包捕获的是「帧」还是「值」

1  def make(x):
2      def helper(y):
3          return x * y
4      x = x + 1
5      return helper
6
7  m = make(3)

m(10) 是多少？是 30 还是 40？

Global frame
    make ──→ func make(x) [parent=Global]
    m    ──→ func helper(y) [parent=f1]

f1: make [parent=Global]
    x       ──→ 3，第 4 行后改成 4
    helper  ──→ func helper(y) [parent=f1]
    返回值   ──→ func helper(y) [parent=f1]

f2: helper [parent=f1]
    y       ──→ 10
    返回值   ──→ 40        # x 从 f1 现场读，读到的是 4

练习 4：为什么这个计数器坏了

count = 0

def tick():
    count = count + 1
    return count

tick() 会发生什么？为什么？不改变「用一个全局变量记数」的思路的前提下，最小的修法是什么？

>>> tick()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in tick
UnboundLocalError: local variable 'count' referenced before assignment

练习 5：数一数一共几个帧

1  def compose(f, g):
2      return lambda x: f(g(x))
3  add1 = lambda n: n + 1
4  dbl = lambda n: n * 2
5  h = compose(add1, dbl)
6  h(5)

（a）h(5) 的值是多少？（b）从第 5 行开始算，一共新建了几个帧？（c）第 2 行那个 lambda 的 parent 是哪一帧？