Python 的闭包到底"包"住了什么？拆开 cell 对象看一眼

结论先行：闭包不是"把变量复制进来"，而是把一个叫 cell 的盒子跟函数绑在了一起。这个盒子里的内容在函数创建之后还能变——Python 著名的"循环里全是 2"的坑、闭包让大对象多活十年、以及闭包比可调用类还费内存，三个看似无关的现象，全是同一个 cell 对象在背后起作用。这篇用 6 组实验把它拆开。

def outer(x):
    def inner(y):
        return x + y
    return inner

f = outer(10)
f.__closure__        # (<cell at 0x...: int object at 0x...>,)
f.__closure__[0].cell_contents   # 10
f.__code__.co_freevars           # ('x',)


对照实验：如果内层函数压根没用外层变量，

def outer2(x):
    def inner2(y):
        return y + 1     # 没用 x
    return inner2
outer2(10).__closure__   # None


判断一个函数是不是闭包，标准就一条：

 不是看它嵌了几层，也不看它写在哪个函数里面。

def make():
    i = 0
    def inc():
        nonlocal i
        i += 1
        return i
    return inc

c = make()
c()   # 1
c()   # 2


cell 里装的是引用，外层变量活着，cell 就能改；外层函数早返回了，cell 就是那个变量唯一的家。

 存在的原因：它改的不是外层函数栈上的某个格子（那个格子早没了），而是 cell 盒子里的内容。

3. 经典坑：循环里的闭包为什么全是 2

funcs = []
for i in range(3):
    funcs.append(lambda: i)

[fn() for fn in funcs]    # [2, 2, 2]


不是 bug，是 cell 机制的直接后果：

循环的三轮里，三个 lambda 共享同一个 cell

fns = make_three()      # 循环里定义三个引用 i 的函数
fns[0].__closure__[0] is fns[1].__closure__[0]   # True
fns[0].__closure__[0].cell_contents              # 2


 返回 True——三个闭包攥着同一个盒子，循环结束 

 定格在 2，于是所有闭包一起返回 2。

三种修法，本质都是绕开共享 cell：

def keeper():
    big = [0] * 100000      # 一个 800KB 的大对象
    def show():
        return len(big)
    return show

h = keeper()
h()                        # 100000 —— big 还活着


 却死不了：cell 引用着它，函数对象引用着 cell，

一条引用链把本该释放的内存吊了十年。

反过来用，这就是有意的缓存手段；无意中触发，就是内存泄漏的标准姿势——回调函数、事件监听里尤其常见。

5. 反常识：闭包比可调用类更费内存

直觉上闭包"轻"，实测恰恰相反。各创建 10000 个：

，外加一个 cell；而 10000 个类实例共享同一个 

结论：只要数据和行为要打包，类反而更省。闭包的省心在于写起来短，不在于跑起来轻。

6. 字节码层面：三个指令说完全部

，闭包机制在字节码里一眼可见：

MAKE_CELL        0 (x)          # 外层：把 x 装进 cell
LOAD_CONST       <code inner>
SET_FUNCTION_ATTRIBUTE 8 (closure)   # 把 cell 绑到函数上


COPY_FREE_VARS   1             # 复制 cell 引用进局部作用域
LOAD_DEREF       1 (x)         # 读 x = 走 cell，不是走局部变量表


 的区别，就是闭包和普通局部变量的区别：

 所以闭包调用有微小的额外开销，日常代码完全可以忽略，但热路径上值得知道。

Python 的闭包到底“包”住了什么？拆开 cell 对象看一眼

闭包不是把变量复制进来，而是把一个叫 cell 的盒子跟函数绑在一起；循环里全是 2、闭包让大对象延寿、闭包比可调用类还费内存，三个现象全是同一个 cell 对象在起作用。

编程语言

闭包核心机制是cell对象引用外层变量，非拷贝，导致循环闭包共享cell产生"全是2"现象。闭包会延长变量生命周期，比类实例更费内存。判断标准看`__closure__`是否None，字节码用LOAD_DEREF访问cell。

Windows

Python

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

Python 的闭包到底“包”住了什么？拆开 cell 对象看一眼

Python 的闭包到底“包”住了什么？拆开 cell 对象看一眼

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐