Python函数与作用域经典考题解析

Python 中与函数及作用域相关的考题，核心集中在四个关键机制：变量查找的 LEGB 规则与编译期作用域决策、函数定义期计算默认参数带来的可变对象共享、循环生成闭包时的延迟绑定，以及通过 global 与 nonlocal 精准跨层级修改变量。掌握这四类问题背后的执行模型，便能彻底避开代码中的静默异常与逻辑陷阱。

一、LEGB 规则与 UnboundLocalError 陷阱

在 Python 中查找变量名时，解释器遵循固定的 LEGB 顺序：首先检索当前函数局部作用域（Local），若未找到则向上检索闭包外层函数的局部作用域（Enclosing），接着是当前模块的全局作用域（Global），最后是内置命名空间（Built-in）。如果四个层次均未定义该符号，则触发 NameError。

然而面试中最常出现的不是普通的未定义报错，而是 UnboundLocalError。请观察以下典型代码：

x = 100

def test_scope():
    print("当前值:", x)
    x = 200

test_scope()

许多初学者直觉认为这会先打印全局变量 100，随后将局部变量 x 赋值为 200。但在实际运行时，解释器会在 print 语句处直接中断抛错：

UnboundLocalError: local variable 'x' referenced before assignment

产生该报错的原因在于 Python 的两阶段执行特征：在函数执行前，字节码编译器会先对整个函数体进行语法扫描。只要函数体内部的任何位置存在对变量 x 的赋值操作（包括 =、+=、for x in ... 等），编译器就会将 x 静态标记为局部变量。在随后的运行期间，函数内对 x 的所有访问都只在局部命名空间中查找，不会向上回退到全局作用域。当执行到 print(x) 时，局部变量尚未完成绑定，因而抛出 UnboundLocalError。

二、默认参数陷阱：可变对象作为默认值

在函数参数定义中，使用可变对象（如列表、字典、自定义类的可变实例）作为默认值，是工程与考卷中最经典的陷阱之一。考察代码通常如下所示：

def append_item(val, container=[]):
    container.append(val)
    return container

print(append_item("A"))
print(append_item("B"))
print(append_item("C"))

未深入理解机制的读者可能预期输出三次各自独立的单元素列表 ['A']、['B']、['C']。然而实际输出为：

['A']
['A', 'B']
['A', 'B', 'C']

该现象的核心原因在于：Python 中的默认参数表达式仅在执行 def 语句时计算一次。解释器在创建函数对象时，将计算得到的默认值存放在函数对象的 __defaults__ 元组属性中。每次调用 append_item 且未显式传入 container 实参时，形参 container 都会绑定到 __defaults__ 中所指向的同一个列表对象。因此，调用过程中的修改实际上都在持续改变同一个底层堆内存对象。

两种实现方式的关键对照

为了让差异更具工程可比性，我们将两种做法在一致的运行条件下进行对比：

标准修复代码如下：

def append_item(val, container=None):
    if container is None:
        container = []
    container.append(val)
    return container

三、闭包与延迟绑定（Late Binding）考题

闭包（Closure）指在一个内部函数中引用了外部作用域的变量，并且外部函数返回了该内部函数对象。在闭包相关的考题中，最经典的题目莫过于列表推导式生成函数列表：

funcs = [lambda x: i * x for i in range(4)]

results = [f(2) for f in funcs]
print(results)

直观阅读常让人误以为会输出 [0, 2, 4, 6]，但解释器实际输出的结果是：

[6, 6, 6, 6]

这一现象源自 Python 闭包的延迟绑定（Late Binding）机制：闭包内部记录的是外部自由变量（Free Variable）的名称引用，而不是创建闭包时该变量的当前数值快照。当列表推导式运行时，4 个 lambda 表达式相继被创建，但此时函数体内的表达式 i * x 并没有被执行。当整个循环结束时，变量 i 的最终取值为 3。随后的调用阶段 f(2) 执行时，所有 lambda 都去外部作用域查找 i，读到的均是最终值 3，因此计算结果全为 3 * 2 = 6。

解决延迟绑定的两种标准解法

1. 利用默认参数即时求值（最简洁）： 在 lambda 或内层函数定义时添加 i=i。等号右边的 i 在定义时立即求值，并作为默认实参存入该函数的局部默认参数中。

   funcs = [lambda x, i=i: i * x for i in range(4)]
   print([f(2) for f in funcs])  # 输出: [0, 2, 4, 6]

2. 使用偏函数 functools.partial（显式语义）： 通过偏函数显式冻结位置参数，意图更直观，避免在形参列表中暴露额外的占位符。

   from functools import partial
   
   def multiply(i, x):
       return i * x
   
   funcs = [partial(multiply, i) for i in range(4)]
   print([f(2) for f in funcs])  # 输出: [0, 2, 4, 6]

四、修改外部变量：global 与 nonlocal 的核心区别

当需要在内层函数中修改外部不可变对象（如整型、字符串、元组）的绑定时，必须通过显式声明改变变量的作用域归属。考题中经常考察 global 与 nonlocal 的使用场景边界与差异。

counter = 0

def outer():
    count = 10

    def inner():
        # 若要修改模块级 counter，必须使用 global
        global counter
        counter += 1

        # 若要修改 outer 里的 count，必须使用 nonlocal
        nonlocal count
        count += 5

    inner()
    print("outer count:", count)

outer()
print("global counter:", counter)

输出结果为：

outer count: 15
global counter: 1

五、核心考点总结与防错准则

分析 Python 函数与作用域考题时，关键在于将执行过程拆分为“定义期”与“运行期”两个视界。下图系统归纳了本文解析的四大核心考点、底层原因及对应的规避策略：