返回专栏
专栏 ·

3.4 作用域与闭包(Closure):LEGB 查找规则、nonlocal 关键字与闭包状态保持

作者: 九路 共 12 章 · 48 小节

3.4 作用域与闭包(Closure):LEGB 查找规则、nonlocal 关键字与闭包状态保持

欢迎来到 HelloWorld 技术社区(www.helloworld.net) 《Python 现代开发实战》第 3 章的收官之作!

上一节我们解锁了 Python 函数的参数与拆包魔法。但要想真正把函数玩出花——甚至在后面第 7 章手写出优雅的装饰器(Decorator)和框架级中间件——你必须先攻克函数式编程最核心的底层机制:作用域(Scope)与闭包(Closure)。

在日常编码中,你一定遇到过这些令人抓狂的瞬间:

  • 明明在函数外面定义了 count = 0,函数里写了一句 count += 1,程序却直接甩给你一个 UnboundLocalError: cannot access local variable 'count';
  • 在 for 循环里批量注册了 5 个异步任务回调函数,结果运行起来发现5 个回调打印出的参数居然一模一样,全变成了最后一个循环的值!

今天这一节,我们直接掀开 Python 命名空间的底层寻址逻辑,用 LEGB 规则和闭包内存模型彻底终结这两类高频 Bug。

一、 LEGB 查找规则:Python 找变量的“四级导航”

在 Python 中,变量不是凭空存在的,它们各自居住在不同的命名空间(Namespace)里。当你在代码里引用一个变量名 x 时,Python 解释器会严格按照 L -> E -> G -> B 的顺序由内向外逐层寻找,一旦找到就立即停止;如果四层全找遍还没踪影,才会抛出 NameError。

Plaintext

  +-------------------------------------------------------------------+
  |  B - Built-in (内置作用域: len, print, int, Exception 等)          |
  |  +-------------------------------------------------------------+  |
  |  |  G - Global (模块全局作用域: 当前 .py 文件顶层定义的变量)     |  |
  |  |  +-------------------------------------------------------+  |  |
  |  |  |  E - Enclosing (闭包嵌套作用域: 外层函数定义的变量)     |  |  |
  |  |  |  +-------------------------------------------------+  |  |  |
  |  |  |  |  L - Local (局部作用域: 当前函数内部定义的变量)   |  |  |  |
  |  |  |  +-------------------------------------------------+  |  |  |
  |  |  +-------------------------------------------------------+  |  |
  |  +-------------------------------------------------------------+  |
  +-------------------------------------------------------------------+

经典翻车现场:UnboundLocalError 是怎么触发的?

看下面这段只有 6 行的代码,很多有两年经验的开发者第一眼也会判断失误:

Python

total_requests = 100  # G: 全局变量

def record_request() -> None:
    print("当前累计请求:", total_requests)  # ❌ 报错!在这里就会直接崩溃
    total_requests += 1                     # 罪魁祸首在这一行

# 运行报错: UnboundLocalError: cannot access local variable 'total_requests' where it is not associated with a value

底层原理解析: Python 编译器在编译函数字节码阶段(而非运行时),会扫描整个函数体。只要它发现函数内部出现了对 total_requests 的赋值操作(+= 本质就是 total_requests = total_requests + 1),编译器就会把 total_requests 强行标记为局部作用域(L)变量!

因此,当代码执行到第一行 print 时,Python 根本不会去外面的全局作用域(G)找,而是直接去局部作用域(L)里找——此时赋值语句还没执行到,局部变量还是空的,于是直接触发 UnboundLocalError。

二、 global 与 nonlocal:跨层修改变量的正确姿势

既然在局部作用域默认只能“读取”外层变量、不能直接“重新绑定”外层变量,当确实需要修改外层状态时,就必须显式声明作用域穿透关键字:

  • global var:声明当前函数里的 var 直接指向模块全局作用域(G);
  • nonlocal var:声明当前内层函数里的 var 指向最近一层外层函数作用域(E)(专用于闭包)。

Python

def create_step_counter(initial: int = 0):
    count = initial  # E: 位于外层函数的 Enclosing 作用域

    def increment(step: int = 1) -> int:
        nonlocal count  # 声明穿透到外层函数的 count 变量
        count += step
        return count

    return increment


counter = create_step_counter(10)
print(counter())   # 11
print(counter(5))  # 16

架构师忠告(极力避免使用 global): 在工程实践中,global 变量是并发安全与单元测试的头号公敌——任何函数都能随时篡改全局状态,会导致多线程数据竞争,也让测试用例之间互相污染。如果你需要维护状态,要么用下面要讲的闭包(nonlocal)做实例级隔离,要么直接封装成类(Class)。

三、 闭包(Closure)的本质:自带“随身背包”的函数

什么是闭包?剥开学术包装,它只有两个构成条件:

  1. 一个内层函数引用了外层函数(Enclosing)中的变量;
  2. 外层函数把这个内层函数作为返回值抛了出来。

按理说,当外层函数 create_step_counter() 执行完毕后,它的局部栈帧应该被销毁,count 变量也应该烟消云散才对。但因为内层函数还在引用它,Python 会把 count 打包进一个特殊的 Cell 对象里,塞进内层函数的 __closure__ 属性中随身携带!

你可以把闭包理解为:一个只带一个核心方法的轻量级对象(函数 + 私有记忆背包)。

生产实战:用闭包打造轻量级接口耗时统计与慢查询告警器

在微服务监控中,我们经常需要记录某个核心接口最近几次的响应延迟,一旦发现连续超出阈值就触发告警,而不想为此专门写一个笨重的类:

Python

import time
from collections.abc import Callable


def create_latency_monitor(api_name: str, threshold_ms: float = 200.0) -> Callable[[float], str]:
    """创建一个带状态记忆的接口延迟监控闭包"""
    history: list[float] = []  # 私有状态保存在闭包背包中,外部无法直接篡改

    def record(latency_ms: float) -> str:
        # 注意:这里调用的是 list 的原地修改方法 .append(),未重新绑定变量名,无需 nonlocal
        history.append(latency_ms)
        avg_ms = sum(history) / len(history)
        status = "⚠️ 慢接口告警" if latency_ms > threshold_ms else "✅ 正常"
        return (
            f"[{api_name}] 本次: {latency_ms:.1f}ms ({status}) | "
            f"历史平均: {avg_ms:.1f}ms (样本数: {len(history)})"
        )

    return record


# 为两个不同接口创建完全独立的监控实例,状态互不干扰
auth_monitor = create_latency_monitor("/api/v1/login", threshold_ms=150.0)
post_monitor = create_latency_monitor("/api/v1/posts", threshold_ms=300.0)

print(auth_monitor(120.5))
print(auth_monitor(210.0))  # 触发告警
print(post_monitor(180.0))  # 独立计数,样本数为 1

四、 面试与生产双杀陷阱:闭包的“延迟绑定(Late Binding)”

这是整个 Python 生态中最著名、坑过无数高级工程师的经典陷阱!

假设我们需要在循环中批量生成 3 个乘法器函数 [f0, f1, f2],期望调用 f0(10) 返回 0,f1(10) 返回 10,f2(10) 返回 20:

Python

# ❌ 经典踩坑代码:循环内创建闭包
multipliers = []
for i in range(3):
    multipliers.append(lambda x: x * i)

# 😱 灾难结果:全部输出 20!(i 全都变成了循环结束时的最终值 2)
print([fn(10) for fn in multipliers])  # [20, 20, 20]

为什么会这样? 因为闭包捕获的是变量 i 本身的引用(门牌号),而不是创建函数那一刻 i 的具体数值(快照)!当循环跑完时,i 已经变成了 2;直到后面真正调用 fn(10) 时,三个函数才顺着门牌号去外面找 i,结果大家看到的都是 2。

两种工业级标准解法

Python

# ✅ 解法 1(最地道):利用函数默认参数在“定义瞬间”求值的特性,把当前值锁定在局部作用域
multipliers_fixed = [lambda x, factor=i: x * factor for i in range(3)]
print("默认参数锁定结果:", [fn(10) for fn in multipliers_fixed])  # [0, 10, 20]

# ✅ 解法 2(最推荐大型项目使用):使用标准库 functools.partial 偏函数显式绑定参数
from functools import partial

def multiply(x: int, factor: int) -> int:
    return x * factor

multipliers_partial = [partial(multiply, factor=i) for i in range(3)]
print("partial 绑定结果: ", [fn(10) for fn in multipliers_partial])  # [0, 10, 20]

🏆 第三章结业综合实战:带次数熔断的通用 API 调用代理

恭喜你通关了《Python 现代开发实战》第 3 章全部内容!现在,我们把本章学到的海象运算符 + match-case + *args/**kwargs 拆包 + 闭包状态保持熔于一炉,打造一个生产级的通用防刷熔断器 create_circuit_breaker。

业务需求: 编写一个闭包工厂函数 create_circuit_breaker(func, max_failures=3):

  1. 接收任意目标业务函数 func 和最大允许连续失败次数 max_failures;
  2. 返回一个包装后的调用函数,支持透传任意 *args 和 **kwargs;
  3. 当连续失败次数达到 max_failures 时,熔断器自动跳闸(不再真正执行 func,直接返回熔断提示);一旦中间有一次调用成功,连续失败计数器立即清零。

Python

from collections.abc import Callable
from typing import Any


def create_circuit_breaker(
    func: Callable[..., Any], /, *, max_failures: int = 3
) -> Callable[..., Any]:
    """为任意函数包裹连续失败熔断保护的闭包工厂"""
    consecutive_failures = 0

    def wrapper(*args: Any, **kwargs: Any) -> Any:
        nonlocal consecutive_failures
        if consecutive_failures >= max_failures:
            return f"🚨 [熔断拦截] {func.__name__} 连续失败已达 {max_failures} 次,拒绝放行"

        try:
            result = func(*args, **kwargs)
        except Exception as exc:
            consecutive_failures += 1
            return f"⚠️ [调用异常 #{consecutive_failures}] {exc}"
        else:
            consecutive_failures = 0  # 调用成功,重置失败计数
            return result

    return wrapper


if __name__ == "__main__":
    def unstable_payment_api(order_id: str, amount: float) -> str:
        if amount <= 0:
            raise ValueError("支付金额必须大于 0")
        return f"订单 {order_id} 支付成功: ¥{amount}"

    safe_pay = create_circuit_breaker(unstable_payment_api, max_failures=2)
    print(safe_pay("ORD-01", -10))   # 失败 #1
    print(safe_pay("ORD-02", -5))    # 失败 #2
    print(safe_pay("ORD-03", 99.0))  # 已被熔断器直接拦截!

💬 HelloWorld 社区结业打卡

第三章结业打卡任务: 在日常业务中,我们经常需要一个“去重记忆函数”——即记录哪些 event_id 已经被处理过,如果遇到重复的 event_id 就直接跳过,只对首次出现的新事件放行。

请你结合第 2 章的 set 和本节的闭包状态保持,编写一个 create_deduplicator() -> Callable[[str], bool] 闭包函数:

  • 首次传入某个 event_id 时,将其记录并返回 True(允许处理);
  • 再次传入相同的 event_id 时,返回 False(判定为重复事件,拦截)。

带 #Python专栏打卡 标签,在评论区晒出你的实现代码与测试输出!

运营彩蛋:完成第 3 章全部 4 节打卡的同学,系统将自动点亮 「Python 函数式思维领航员」 社区勋章!下一章(第 4 章),我们将进入第一阶段的最后一章——文件操作、异常处理与模块化开发,教你用现代 pathlib 和防御性异常体系写出坚如磐石的工程模块!