Python 中的闭包是一个核心但容易混淆的概念。其本质与变量的查找规则（LEGB）和函数的运行机制紧密相关。下面将针对您的四点疑问，进行分步拆解和通俗说明。 ### 1. 解释器定义变量时的查找原则：LEGB 您说的 **LEBG** 原则，通常更准确的表述是 **LEGB** 原则。它定义了 Python 解释器在寻找一个变量名（或函数名）时的**查找顺序** [ref_1]。 其查找顺序如下表所示： | 顺序 | 作用域 | 英文全称 | 解释 | | :--- | :--- | :--- | :--- | | **L** | **局部作用域** | Local | 当前函数内部定义的变量。 | | **E** | **闭包（嵌套）作用域** | Enclosing | 指外层嵌套函数（非全局）的作用域。这是闭包能访问外部变量的关键。 | | **G** | **全局作用域** | Global | 在模块（文件）顶层定义的变量。 | | **B** | **内建作用域** | Built-in | Python 内置的变量和函数，如 `len`， `print`， `list` 等 [ref_1]。 | **关键理解点**：解释器按照 **L -> E -> G -> B** 的顺序由内向外查找。如果局部作用域（L）找不到，就去外层嵌套函数（E）中找，还找不到就去全局（G）找，最后去内建（B）中找。这个过程是“运行时”确定的，即函数**被调用时**，才根据其当时所在的作用域链去寻找变量。 ```python # 示例代码：演示 LEGB 查找顺序 x = "global x" # G: 全局变量 def outer(): x = "enclosing x" # E: 闭包作用域变量（相对于 inner） def inner(): x = "local x" # L: 局部变量 print(f"局部查找： {x}") # 输出：局部查找： local x print(f"内置函数调用： {len([1,2,3])}") # B: 访问内建函数 len inner() print(f"外层函数查找： {x}") # 输出：外层函数查找： enclosing x outer() print(f"全局查找： {x}") # 输出：全局查找： global x ``` 在这个例子中，`inner` 函数内访问 `x` 时，按照 LEGB 原则，首先在自己的局部作用域（L）中找到了 `x="local x"`，因此不会向上查找 [ref_2][ref_6]。 ### 2. 闭包函数运行的顺序 闭包函数的运行，可以分解为两个阶段：**定义阶段** 和 **调用阶段**。理解这两个阶段的分离是解开困惑的关键。 1. **定义阶段（创建闭包）**：当代码执行到 `def` 语句时，Python 会创建一个**函数对象**。这个对象不仅包含函数的代码体，还会**记录下它被定义时所处的“环境”**，也就是它的“闭包作用域链”。这个过程是静态的、发生在代码从上到下执行的过程中 [ref_5]。 2. **调用阶段（执行闭包）**：当我们调用这个闭包函数时，解释器会： * a. 为此次调用创建一个新的**局部作用域（L）**。 * b. 在这个局部作用域中执行函数体代码。 * c. 当函数体代码需要访问一个变量时，解释器会遵循第一步中记录下来的 **LEGB 作用域链** 去查找变量。其中，“E”就是定义阶段记录下来的外层嵌套函数的局部作用域。 ```python def outer_func(data): # 1. 定义外层函数 # outer_func 的局部作用域包含 `data` 和内部定义的 `inner_func` def inner_func(): # 2. 定义阶段：inner_func 被创建，并“记住”了当前的作用域环境（包含`data`） # 3. inner_func 的函数体代码中引用了外层变量 `data` print(f"The data is: {data}") # 当被调用时，会去“记住的”作用域里找 `data` return inner_func # 4. 将 inner_func 函数对象作为返回值 # 执行 outer_func，传入参数 “Hello” closure = outer_func("Hello") # 此时，closure 就是 inner_func 函数对象，它“闭包”了 `data="Hello"` # 外层函数 outer_func 已经执行完毕，其局部作用域本应被销毁... # 调用闭包函数 closure() # 输出：The data is: Hello # 神奇之处：为什么这里还能打印出 “Hello”？ # 因为 inner_func 在定义时“记住”（引用了）外层作用域的 `data` 变量。 # 即使 outer_func 已结束，这个被引用的变量依然存活，并被 inner_func 持有。 ``` **运行顺序总结**：先执行 `outer_func(“Hello”)` 来**定义**和**返回** `inner_func`，在这个过程中 `data=“Hello”` 被 `inner_func` 记住。之后调用 `closure()` 时，解释器就会去它“记住”的环境里找到这个 `data` 来使用。 ### 3. 闭包的概念（通俗理解） 抛开专业术语，你可以这样理解闭包： > **闭包** = **函数** + **该函数被定义时所处的环境（特别是它能访问的自由变量）** * **函数**：一个内部定义的函数。 * **环境**：这个内部函数在“出生”（被定义）时，周围有哪些外部变量是可用的。 * **核心**：这个内部函数**有能力**在自己被调用时，去访问并使用那些“出生时”环境里的外部变量，**即使那个外部环境（外层函数）已经执行结束了**。 **一个生活中的比喻**： 想象你在国外留学，你的家人在国内给你寄了一个包裹（**外层函数**）。包裹里有一封信（**内部函数**）和一些家乡特产（**环境变量**，比如你最爱吃的零食品牌 `snack = “辣条”`）。即使寄包裹的家人已经完成邮寄任务回家了（**外层函数执行完毕**），你拿到包裹后，依然可以随时阅读那封信，并且信里可以提到“记得吃 `snack`”（**内部函数引用外部变量**）。这里的“信 + 被一起寄来的特产信息”就构成了一个**闭包**。信（内部函数）总能知道当时包裹里放了什么特产（定义时的环境）。 ### 4. 闭包的原理（非专业详解） 闭包的原理可以归结为 Python 对象的**引用机制**和**作用域链的固化**。 1. **函数也是对象**：在 Python 中，函数和整数、字符串一样，都是**对象**。当你定义一个函数时，就创建了一个函数对象。这个对象有一些属性，其中重要的一个是 `.__code__`，它存储了函数的执行代码；另一个是 `.__closure__`，它存储了**闭包信息**（如果没有引用外层变量，它就是 `None`）。 2. **变量引用而非拷贝**：当内部函数引用了外层变量（如 `data`），它并不是把这个变量的值复制一份，而是**保存了一个指向这个变量的引用（可以理解为一个永不失效的链接）**。只要内部函数对象（闭包）还存在，Python 的垃圾回收机制就会认为这个被引用的外部变量还有用，从而不会销毁它 [ref_4]。 3. **作用域链的“快照”**：在定义内部函数的那一刻，Python 会分析这个函数体内引用了哪些“非全局、非局部”的变量（即来自外层嵌套函数作用域的变量）。它会把这些变量和它们所在的“作用域层”打包，绑定到内部函数的 `__closure__` 属性上。这相当于在函数“出生”时，给它拍了一张当时外部环境的“快照”（实际上是引用链）。 4. **调用时的查找**：当闭包函数被调用时，它会在自己的局部作用域（L）中执行。如果遇到一个变量名在自己局部作用域找不到，它不会直接去当前的全局作用域找，而是会先去 `__closure__` 属性保存的“快照”（即 E 作用域）里找。这保证了它总能访问到定义时的那个“旧环境”。 ```python # 代码演示闭包的 __closure__ 属性 def outer(a, b): def inner(x): # 引用了外层函数的变量 a 和 b return a * x + b return inner line_func = outer(2, 1) # 创建了一个闭包， a=2, b=1 print(line_func.__closure__) # 输出：一个包含两个 cell 对象的元组，证明有闭包 print(line_func.__closure__[0].cell_contents) # 输出：2， 这就是被记住的变量 a 的值 print(line_func.__closure__[1].cell_contents) # 输出：1， 这就是被记住的变量 b 的值 result = line_func(5) # 计算 2 * 5 + 1 print(result) # 输出：11 ``` 在这段代码中，`inner` 函数成为了一个闭包，它的 `.__closure__` 属性保存了对外层变量 `a` 和 `b` 的引用。调用 `line_func(5)` 时，它使用闭包中保存的 `a=2` 和 `b=1` 进行计算 [ref_3][ref_5]。 **总结对比：普通函数 vs 闭包** | 特性 | 普通函数 | 闭包函数 | | :--- | :--- | :--- | | **定义** | 在模块全局或局部定义，不嵌套在其他函数内。 | **嵌套**在另一个函数内部定义。 | | **变量访问** | 只能访问自己的局部变量（L）和全局/内置变量（G/B）。 | 可以访问自己的局部变量（L）、**外层嵌套函数的变量（E）**、全局/内置变量（G/B）。 | | **环境依赖** | 不依赖定义时的特定外部环境（除了全局变量）。 | **依赖**定义时的外部环境（外层函数局部变量）。即使外层函数已消亡，依然可以访问当时的环境变量。 | | **核心价值** | 封装独立功能。 | **封装状态（数据）**。闭包函数就像一个携带了私有数据的“功能盒子”，这个数据对于外部是隐藏的，但可以被函数本身反复使用。这在创建工厂函数、装饰器、实现回调函数等场景中非常有用 [ref_4]。 | 理解闭包的关键在于认识到函数定义和执行的分离，以及 Python 通过作用域链和引用机制，让内部函数能够“穿越时间”访问定义时的环境。