一、定义

闭包（Closure） 指的是一个函数对象，即使其外部作用域的变量已经不存在了，仍然能访问这些变量。简单来说，闭包是由函数及其相关的环境变量组成的实体。

def outer():x = 10def inner():print(x)return innerf = outer()
f()  # 输出10

对于这个示例，我们可以将inner函数称为闭包，它满足了嵌套函数，它满足了使用外部函数outer的参数x，外部函数的返回值满足了是inner函数本身

二、闭包

（1）闭包的形成条件

闭包必须是一个嵌套函数，并且内部函数引用了外的变量，外部函数的返回值是该内部函数，对于这个引用外部函数变量的内部函数称为闭包。

• 必须有嵌套函数（函数内部定义函数）
• 内部函数引用了外部函数的变量
• 外部函数返回内部函数对象

示例1：没有嵌套函数，只有单层函数

def func():x = 10print(x)func()

示例2：嵌套函数存在，但内部函数没有引用外部变量

def outer():x = 10def inner():print("Hello")return innerf = outer()
f()

示例3：嵌套函数引用了外部变量，但外部函数没有返回该内部函数

def outer():x = 10def inner():print(x)inner()  # 调用内部函数，但没有返回它outer()

（2）闭包的使用场景

1）数据隐藏和封装：闭包可以把一些变量藏在函数里面，不让外面直接访问，这样就不会乱用或误改，避免弄乱全局变量，让代码更安全。

2）装饰器实现：装饰器本质上依赖闭包机制

3）函数工厂：闭包可以帮你根据不同需求，快速生成带有特定设置或环境的函数，就像工厂按订单生产不同产品一样。

def make_multiplier(factor):# 这是一个函数工厂，传入一个倍数 factordef multiplier(number):# multiplier 是闭包，记住了外面的 factorreturn number * factorreturn multiplier# 生成一个把数字乘以3的函数
times3 = make_multiplier(3)
print(times3(5))  # 输出 15# 生成一个把数字乘以10的函数
times10 = make_multiplier(10)
print(times10(5))  # 输出 50

（3）闭包的作用与优势

1）减少全局变量使用，提升代码安全性

闭包让变量“藏”在函数里，避免把变量放到全局，减少冲突和错误，让代码更可靠。

2）保持函数运行环境，方便管理状态

闭包可以记住外部变量的值，即使外部函数已经结束，内部函数还能继续用这些数据，方便管理和维护程序状态。

三、Python中的可变类型与不可变类型

3.1 变量类型

（1）不可变类型

包括：int、float、str、tuple、frozenset等，对象一旦创建，值不能被改变，任何修改都会生成新对象。

（2）可变类型

包括：list、dict、set、自定义类对象等，对象创建后，内容可以被修改，地址不变。

3.2 两者区别与内存表现

1）不可变类型变量修改时，实际是创建了新的对象，变量指向新地址

a = 10
print(id(a))  # 假设输出：140703079708016a = a + 1
print(id(a))  # 输出：140703079708048 （地址发生变化）

说明：变量 a 原来指向值为10的对象，修改后指向了新创建的值为11的对象，地址发生变化。

2）可变类型变量修改时，变量指向的对象地址不变，内容发生变化

lst = [1, 2, 3]
print(id(lst))  # 假设输出：140703080123456lst.append(4)
print(id(lst))  # 输出：140703080123456 （地址未变）
print(lst)      # 输出：[1, 2, 3, 4]

说明：变量 lst 指向的列表对象地址没有变，但列表内部内容发生了变化。

3）通过id()函数可以观察变量地址变化。id() 返回对象的内存地址标识，可以用来判断变量是否指向同一个对象。

3.3 赋值和修改对变量的影响

1）对不可变类型变量赋值，变量绑定新对象，不影响原对象

2）对可变类型变量修改，直接改变对象内容，所有引用该对象的变量都能感知变化

四、闭包中变量的可变性影响

4.1 闭包对不可变类型变量的访问与限制

闭包内部访问外部不可变变量时，如果尝试修改，会报错（UnboundLocalError），因为修改会被当作局部变量赋值，导致访问冲突。

def outer():x = 10  # 外部不可变变量def inner():x += 5  # 尝试修改外部变量，报错！print(x)inner()outer()

解释：

在 inner 函数里，写了 x += 5，这相当于想给 x 重新赋值。Python 看到这个，就把 x 当成是 inner 里的“新变量”，而不是外面那个已经有值的 x。但是这个“新变量”还没被定义，结果你又想用它来计算，就出错了。

简单说，就是闭包里面如果你想修改外面那个数字，Python 会误以为你是在用一个自己新建但还没给值的变量，所以会报错。要想修改外面的变量，需要告诉 Python “嘿，我用的是外面的那个变量”，这时候就得用 nonlocal。

4.2 使用 nonlocal 关键字修改不可变变量

nonlocal 的作用就是告诉 Python：“我想用的是外面函数里的那个变量，不是新建一个新的。”

所以在 inner 里写了 nonlocal x，Python 就知道你要改的是外面 outer 函数里的 x，然后你给它加 5，修改成功了。这样，inner 里和外面打印的 x 都变成了 15，因为它们指的是同一个变量。

def outer():x = 10def inner():nonlocal xx += 5print(x)inner()print(x)outer()
"""
输出：
15
15
"""

4.3 闭包中对可变类型变量的修改与访问

对可变类型变量，闭包内部可以直接修改其内容，无需nonlocal。当然建议使用nonlocal关键字声明。

def outer():lst = [1, 2, 3]def inner():lst.append(4)print(lst)inner()print(lst)outer()
"""
输出
[1, 2, 3, 4]
[1, 2, 3, 4]"""

为什么修改lst不需要使用nonlocal关键字呢。由于lst是一个列表他是一个可变类型，内层函数在对lst进行添加操作时，并没有改变lst本身，它所指向的内存空间也没有发生改变。如果内层函数代码为del lst 想要删除这个列表，也就是对外层函数的lst做了修改操作，此时就会发生报错UnboundLocalError，如果加上关键字nonlocal进行声明，就可以对它进行删除。

4.4 常见误区

1）不是所有闭包里的变量修改都要用 nonlocal

def outer():lst = [1, 2, 3]  # 可变类型变量def inner():lst.append(4)  # 直接修改列表内容，无需nonlocalprint(lst)inner()print(lst)outer()

2）别把“换变量”和“改内容”搞混了

def outer():x = 10  # 不可变类型lst = [1, 2, 3]  # 可变类型def inner():# x += 1  # 重新绑定，会报错，需要nonlocal# 改成下面这样才合法：nonlocal xx += 1# 对列表内容修改，不是重新绑定lst.append(4)print(x, lst)inner()print(x, lst)outer()

3）别忽略了可变对象改了内容，闭包里的变量也跟着变

def outer():d = {'count': 0}  # 可变字典def inner():d['count'] += 1  # 修改字典内容print(d['count'])return innerf = outer()
f()  # 输出1
f()  # 输出2