《闭包到底闭的是什么？从 LEGB 到作用域链的全景深度解析》-育师

《闭包到底闭的是什么？从 LEGB 到作用域链的全景深度解析》

一、开篇：为什么闭包与 LEGB 值得专门写一篇文章？

如果你已经写过一段时间 Python，你一定遇到过这样的现象：

函数里再定义函数
内层函数能访问外层函数的变量
外层函数执行完毕后，变量却“神奇地”没有消失
装饰器为什么能“记住”原函数
lambda 为什么能捕获外部变量
为什么循环里的闭包总是“坑”人

这些现象背后，都指向一个核心概念：

闭包（Closure）与 Python 的作用域规则（LEGB）。

闭包是 Python 函数式编程的灵魂，也是装饰器、回调、工厂函数、事件系统等高级技巧的基础。而 LEGB 则是理解 Python 变量查找机制的根本。

然而，很多开发者对闭包的理解停留在“函数里套函数”，对 LEGB 的理解停留在“Local、Enclosing、Global、Built-in”四个词。
但真正的关键是：

闭包到底闭住了什么？
闭包为什么能记住外部变量？
LEGB 规则能不能手撕？能不能用代码证明？
闭包与作用域链在实际项目中如何发挥威力？

这篇文章，我将用最清晰的方式，把这些问题全部讲透。

二、Python 的发展与作用域设计哲学

Python 自诞生以来就强调：

简洁优雅
可读性优先
多范式支持（面向对象 + 函数式）
灵活的作用域模型

Python 的作用域设计深受 Scheme、JavaScript 等语言影响，但又保持了自己的风格：

变量查找遵循 LEGB
函数是“一等公民”
闭包是语言核心特性
作用域链是动态构建的
变量捕获是“引用捕获”，而不是“值捕获”

理解这些特性，将极大提升你写 Python 的能力。

三、基础部分：闭包是什么？闭包到底闭住了什么？

✅ 1. 闭包的定义（通俗版）

闭包 =函数 + 环境变量

更准确地说：

闭包是一个函数，它记住了定义它时所在作用域中的变量，即使这个作用域已经结束。

✅ 2. 一个最经典的闭包例子

defouter():x=10definner():print(x)returninner f=outer()f()# 输出 10

outer 已经执行完毕，按理说 x 应该消失，但 inner 仍然能访问它。

为什么？

因为：

✅ inner 函数携带了一个cell，里面保存了对 x 的引用
✅ outer 的局部变量被“闭”在 inner 的作用域链中
✅ 这就是闭包

我们可以验证：

print(f.__closure__)print(f.__closure__[0].cell_contents)

输出：

(<cell at 0x...: int object at ...>,) 10

这就是闭包的本质。

四、闭包到底闭住了什么？（深入剖析）

闭包闭住的不是“值”，而是“变量的引用”。

来看一个经典坑：

funcs=[]foriinrange(3):funcs.append(lambda:i)forfinfuncs:print(f())

输出：

2 2 2

为什么不是 0、1、2？

因为：

lambda 捕获的是变量 i 的引用
循环结束时 i = 2
所有 lambda 都指向同一个 i

如果你想捕获“值”，必须这样写：

funcs=[]foriinrange(3):funcs.append(lambdai=i:i)forfinfuncs:print(f())

输出：

0 1 2

✅ 这是闭包最重要的真相：
闭包捕获的是变量，而不是变量当时的值。

五、LEGB 规则：Python 变量查找的终极法则

LEGB 是 Python 查找变量的顺序：

字母	含义	说明
L	Local	当前函数内部的变量
E	Enclosing	外层函数的变量（闭包）
G	Global	当前模块的全局变量
B	Built-in	Python 内置变量，如 len、range

查找顺序：

Local → Enclosing → Global → Built-in

✅ 手撕 LEGB：用代码证明每一层

1. Local 层

x="global"deffunc():x="local"print(x)func()# local

2. Enclosing 层

defouter():x="enclosing"definner():print(x)inner()outer()# enclosing

3. Global 层

x="global"deffunc():print(x)func()# global

4. Built-in 层

deffunc():print(len([1,2,3]))func()# 3

六、LEGB 的“反例”：什么时候查找会失败？

✅ 1. 变量赋值会屏蔽外层作用域

x=10deffunc():print(x)# UnboundLocalErrorx=20func()

为什么报错？

因为：

Python 看到 x = 20
认为 x 是 Local
但 print(x) 在赋值前执行
Local x 未定义 → 报错

解决：

deffunc():globalxprint(x)x=20

或者：

defouter():x=10definner():nonlocalxprint(x)x=20inner()

七、闭包 + LEGB：装饰器为什么能工作？

装饰器本质上就是闭包。

deftimer(func):defwrapper(*args,**kwargs):print("before")returnfunc(*args,**kwargs)returnwrapper@timerdefhello():print("hello")hello()

wrapper 能访问 func，因为：

func 是 Enclosing 作用域的变量
wrapper 是闭包
func 被闭包“闭住”了

我们可以验证：

print(hello.__closure__)print(hello.__closure__[0].cell_contents)

八、闭包在实际项目中的高级应用

✅ 1. 工厂函数（Factory）

defmake_multiplier(n):definner(x):returnx*nreturninner double=make_multiplier(2)print(double(10))# 20

✅ 2. 缓存（Memoization）

defmemo(func):cache={}defwrapper(n):ifnnotincache:cache[n]=func(n)returncache[n]returnwrapper@memodeffib(n):ifn<2:returnnreturnfib(n-1)+fib(n-2)

✅ 3. 动态路由（Flask 原理）

routes={}defroute(path):defdecorator(func):routes[path]=funcreturnfuncreturndecorator@route("/hello")defhello():return"Hello"

闭包让路由系统变得优雅。

九、最佳实践：如何正确使用闭包？

✅ 1. 闭包适合：

工厂函数
装饰器
回调
状态保持
数据封装

✅ 2. 闭包不适合：

复杂业务逻辑
多层嵌套
大量状态管理（用类更好）

✅ 3. 避免闭包捕获循环变量的坑

使用默认参数：

lambdai=i:i

✅ 4. 使用 nonlocal 管理闭包状态

defcounter():n=0definc():nonlocaln n+=1returnnreturninc

十、前沿视角：闭包与作用域在 Python 未来的趋势

随着 Python 3.11+ 的性能提升与解释器优化，闭包与作用域链的执行效率也在不断提高。

未来趋势包括：

更快的字节码执行
更智能的作用域优化
更强的类型系统（PEP 695）
更丰富的函数式特性
更高效的闭包捕获机制

闭包将继续在框架设计、AI 工具链、数据处理等领域发挥关键作用。

十一、总结：闭包与 LEGB 是理解 Python 的核心钥匙

我们回到最初的问题：

✅ 闭包到底闭住了什么？

闭住的是变量的引用，而不是值。
闭包通过 cell 保存外部变量。

✅ LEGB 能手撕吗？

当然能：

Local
Enclosing
Global
Built-in

每一层都可以用代码验证。

✅ 为什么要理解闭包与 LEGB？

因为它们是：

装饰器的基础
回调的基础
工厂函数的基础
作用域链的基础
Python 函数式编程的核心

理解它们，你会写出更优雅、更高效、更 Pythonic 的代码。

十二、互动时间

我很想听听你的经验：

你在项目中遇到过闭包相关的坑吗？
你是否写过让自己惊叹的装饰器？
你对 LEGB 有没有更深刻的理解？

欢迎在评论区分享你的故事，我们一起交流、一起成长。

《闭包到底闭的是什么？从 LEGB 到作用域链的全景深度解析》