外观
修改一个变量,另一个为什么也变了:对象、引用与可变性
摘要
复制配置后只改了副本,原配置却一起变化,问题通常藏在共享引用中。本文面向 Python 初学者,用对象关系图与可运行实验讲清赋值、参数传递、浅拷贝和深拷贝,建立分析数据串改的基础模型。
1. 场景:副本看起来独立,嵌套数据却串改
这是一个教学场景:日志处理任务有配置 {"tags": ["python"]}。你希望每个任务增加自己的标签,于是执行 task_config = config.copy(),随后向 task_config["tags"] 添加 "backend"。任务结束后,公共配置也多了标签。外层字典确实不是同一个对象,为什么修改仍会传播?原因是复制字典与复制字典所能到达的全部对象,是两个不同操作。
先在图上标出操作落在哪里:赋值改一条关联,原地操作改关联尽头的对象;变化沿仍然共享的路径传播。 名称绑定对象,容器位置又能引用其他对象。reference(引用)就是这条关联,多条路径指向同一对象称为 aliasing(别名或共享)。这个模型适合本篇内置容器;自定义类型的运算还需查看自己的协议。
保持开头的两个字典与同一标签列表不变,只把 task_config["tags"].append(...) 换成对该位置的重新赋值。先预测公共配置还会不会变,再追踪:append 走到两条路径共有的列表;赋值只改新字典的 tags 关联。外层身份不同在两种写法都成立,真正分叉在操作位置。
每个对象都有 identity(身份)、type(类型)和 value(值)。身份回答“是不是同一个对象”,类型决定支持什么操作,值描述对象当前状态。id() 返回对象身份的整数表示,在对象生存期内保持稳定;CPython 通常把它与内存地址关联,但“可以随意当指针使用”不是语言承诺。对象销毁后身份值可能被另一个对象复用,所以跨生命周期比较旧 id 不能证明它们曾是同一对象。这些定义见 Python 数据模型。
2. 赋值改变关联,方法可能改变对象
考虑 a = [],它创建一个新列表并把 a 绑定过去。再执行 b = a,并不会再创建列表,而是让 b 指向现有列表。a.append(1) 调用列表方法,原地增加元素,于是 b 也观察到 [1]。如果随后执行 a = [],这个新的空列表只有 a 指向,b 仍保留旧列表 [1]。从名称出发画箭头,比“赋值是复制值还是复制地址”更容易保持语义准确。
mutable(可变)对象允许状态在身份不变的情况下改变,列表、字典和集合属于常见例子。immutable(不可变)对象不能这样改变自己的相应值,整数、字符串、元组是常见例子。number += 1 对整数计算并重新绑定,不能把所有指向原整数的名称都加一。列表的 += 则通常原地扩展列表。相同运算符可以由不同类型定义不同操作,不要只凭标点判断是否共享修改。
这还解释了 items = items + [x] 与 items += [x] 的观察差异。对于列表,前者通常产生新列表再绑定,后者扩展原列表;如果调用方与函数内部共享原列表,只有后者会沿共享引用直接体现。这里限定内置列表的行为,自定义对象可以提供不同的运算实现,后续类协议会进一步说明。
is 比较对象身份,== 比较对象定义的相等性。两个独立列表可以内容相等但身份不同。列表比较还会逐项比较,因此嵌套值相等不代表结构中没有共享。None 判断使用 is None 很合适;业务字符串和数字通常用 ==。小整数缓存、字符串驻留等实现优化可能让相等值碰巧共享对象,但不能保证任意构造方式和任意版本都相同。数据模型明确说明不可变对象可以复用,代码应避免依赖这种身份偶然性。
3. 浅拷贝只复制这一层的引用集合
shallow copy(浅拷贝)创建新的外层容器,再把旧容器的元素引用放进新容器。原字典与浅拷贝字典的身份不同,但它们的 tags 位置指向同一个列表。替换浅拷贝中的 tags 会改变新字典的关联;调用该列表的 append 则改变共享的列表。这两种写法只差操作对象,却有不同传播路径。
图表将在阅读到此处时加载…
deep copy(深拷贝)递归处理对象图,尽可能复制内部对象。标准库 copy.deepcopy 使用记录已处理对象的 memo(备忘映射),避免循环引用导致无限递归,并尽量保留原图中的共享结构。比如原对象有两个字段指向同一子列表,深拷贝后的两个字段通常仍指向同一个新子列表,而不是产生两个互不相关的副本。“深拷贝”不是“每条路径都强行生成一份数据”。机制和限制见 copy 文档。
不是所有对象都适合复制。文件、套接字等外部资源包含操作系统状态,复制一个 Python 引用不能建立同样的独立资源。类也可以定义拷贝相关行为,因此必须理解对象自身语义。深拷贝大型图还要遍历和分配,并没有通用的零成本保证。若只有一小部分字段需要独立,显式重建这部分数据通常更容易说明所有权。
只读快照也不应仅靠“用了元组”判断。元组不能替换保存的元素引用,但元素若是列表,列表仍可修改。把外层容器变成不可变形式,未必冻结所有可到达状态。实际需要不可变配置时,应递归使用适合的数据结构,或者不向消费者暴露可变内部对象;这属于接口约束,而不是某个拷贝函数自动给出的保证。
4. 参数传递:调用建立新的名称绑定
函数调用时,实参表达式先得到对象,形参在函数执行环境中绑定到该对象。常称 call by object reference(通过对象引用传递),也可用“共享对象,局部名称独立”描述。说成“所有参数按引用传递,所以函数可以改调用者变量”容易误导;函数可以修改共享对象,但不能仅靠给自己的形参赋值,就改掉调用方的名称绑定。
例如函数内部 values = ["local"] 只让局部 values 指向新列表,调用方仍指向旧列表。函数内部 values.append("local") 操作原列表,调用方则能看到变化。官方教程解释实参引用在调用时进入局部环境,见 函数定义与参数。第五篇将进一步处理作用域、默认参数和闭包;这里先把共享与改绑的区别固定下来。
返回值同样不自动复制对象。如果函数返回自己的内部列表,调用方获得引用后也许可以破坏内部不变量。需要决定接口返回原对象、浅副本、深副本还是新的不可变数据表示。选择依据是读写权限和数据规模,不是“不放心就全部 deepcopy”。线上串改往往要查的是谁能到达并修改该对象,而不仅是哪个变量名出现在出错行。
5. 最小实验:别名、两种拷贝和二维列表
读代码前先区分四条路径:alias 与 original 指同一字典;shallow 指新字典,但 tags 仍落在原列表;deep 的 tags 落在复制列表。于是 shallow 的一次 append 会被前两者看见,deep 不会。随后二维列表重复引用和 deepcopy 的 memo 实验改变图形,却继续用“哪条边、哪个对象”解释,而不是为每个现象另背口诀。
完整程序在 03_references.py,无第三方依赖:
python
"""用嵌套容器验证别名、浅拷贝、深拷贝和参数绑定。"""
from copy import deepcopy
def rebind(values):
values = ["local"] # 只改变函数内部名称。
return values
def main():
original = {"tags": ["python"]}
alias = original
shallow = original.copy()
deep = deepcopy(original)
shallow["tags"].append("backend")
assert alias is original
assert shallow is not original
assert shallow["tags"] is original["tags"]
assert original["tags"] == ["python", "backend"]
assert deep["tags"] == ["python"]
values = ["caller"]
assert rebind(values) == ["local"]
assert values == ["caller"]
bad = [[]] * 2 # 两个位置引用同一个列表。
bad[0].append(1)
good = [[] for _ in range(2)]
good[0].append(1)
assert bad == [[1], [1]] and good == [[1], []]
# memo(已复制对象表)保留共享拓扑,也终止循环递归。
child = ["shared"]
graph = [child, child]
graph.append(graph)
cloned = deepcopy(graph)
assert cloned is not graph
assert cloned[0] is cloned[1] and cloned[0] is not child
assert cloned[2] is cloned
print("memo sharing/cycle:", cloned[0] is cloned[1], cloned[2] is cloned)
print("original:", original)
print("deep:", deep)
print("rows:", bad, good)
if __name__ == "__main__":
main()运行 python docs/python/examples/03_references.py。预期原配置显示 {'tags': ['python', 'backend']},深拷贝保持 {'tags': ['python']},最后一行显示 rows: [[1], [1]] [[1], []]。结果中的字典与列表表示由内置类型打印,断言同时检查身份和内容,避免只看输出推测结构。实验不打印固定的内存地址,因为地址值本身对结论没有意义。
二维列表反例尤其常见:[[]] * 2 重复的是同一个列表引用,不是把列表内部重新执行两次。正例 [[] for _ in range(2)] 每轮创建一个新列表。对不可变整数做重复通常不会有相同的串改风险,因为不能原地修改整数;但仍不应该将“某种元素看起来安全”推广到所有嵌套容器。
本例深拷贝发生在追加标签之前,因此保留追加前状态。如果把深拷贝放到追加后,副本当然会包含新标签;拷贝不会回滚已经发生的修改。这是审查实际代码时的重要时间边界。引用图解释的是关系,具体状态还取决于每个操作的顺序。
6. 线上数据串改怎样取证
先缩小数据所有权:对象在哪里创建,被交给了哪些函数,哪些路径允许写入。记录外层和关键子对象的身份比较,帮助验证共享关系;但不要把生产敏感数据完整打印出来。即使外层 is 为假,也继续查看发生修改的那一层。如果问题集中在 config["options"]["tags"],只比较 config 没有足够证据。
随后区分修改方式:是替换字典字段,还是修改字段指向的列表;是构建新对象返回,还是就地更新传入对象。找到最短修改路径后,用独立最小数据复现。修复时若数据应独立,优先在明确的所有权交接点复制需要独立的部分;若应共享,就在接口说明写入责任,并考虑并发同步。拷贝和锁处理的是不同问题,不能互相替代。
还有一个坑是忽略缓存和默认配置对对象生命周期的影响。某个列表虽然在一次请求内被发现,却可能来自模块全局缓存,被跨请求长期共享。修改后下个请求继承了状态,看起来像随机污染。第五篇的可变默认参数和第八篇的模块缓存会补齐这两类共享来源。排查时要问创建频率,不要根据变量在函数里出现就认为它每次调用都新建。
引用模型也与内存问题有关。删除一个名称只去掉一条引用关联,其他容器、闭包或缓存仍能保留对象;del 不能被解释成强制清空整个对象图。CPython 的引用计数与循环回收在第十八篇展开,本篇不以引用计数的具体数值判断共享。解释器优化、临时引用和某些特殊对象都可能影响计数观察,而 is 与有界行为实验已经足以验证当前关系。 可进一步阅读垃圾回收:比较可达性与释放模型而不移植回收机制。
7. 三种合理修复,分别适合什么所有权
第一种是显式复制需要独立的字段。若配置结构固定,只有标签需要修改,可以写 task_config = {**config, "tags": list(config["tags"])}。这是局部片段,含义是新建外层字典,并为标签新建列表;其他字段仍共享。若标签内部元素也可变,这一层列表复制仍未完全隔离。说明实际独立到哪一层,比简单声明“已复制”更准确。
第二种是让函数返回新结果,保留输入不变。例如计算标签时返回 [*tags, new_tag],调用方明确使用返回值。这样能减少就地修改的传播,但仍需注意原有标签元素的引用共享。对于只包含字符串的标签列表,这种共享通常符合需求,因为字符串不可变;如果标签变成复杂对象,接口约束需要重新评估。
第三种是明确允许共享,写入集中管理。有些缓存或注册表本来就需要所有调用看到更新,不应为消除所有共享而复制。此时应规定谁可修改、何时修改、是否在并发情况下加锁或使用消息传递。把共享隐藏起来才容易出问题,共享本身不是错误。拷贝、同步和只读接口分别改变结构、调度与访问权限,修复应针对真实需求。
观察一个简单循环图也能加深理解:loop = []; loop.append(loop) 让列表引用自己。深拷贝不会仅靠无限递归展开它,而是使用备忘映射识别已经复制的对象。拷贝结果的第一个元素可以仍指向拷贝结果本身,保留环结构。实际数据如果可能有环,序列化协议、调试打印和递归处理都要考虑它;不能把对象图始终想成没有共享的树。
快照的一致性还有时间条件。单线程中按顺序复制一个静止对象,容易理解;其他线程同时写入时,“开始复制”不一定等于获得某个瞬间的业务快照。需要在业务层保证读取期间状态稳定,或者使用明确的快照协议。深拷贝不是事务,也不自动协调外部系统中的状态。第十九篇会区分语言操作与业务原子性。
测试数据独立也容易踩坑。多个用例共用同一个嵌套字典,再在每个用例只做浅拷贝,会把一个用例的修改带给下一个,出现单独运行成功、一起运行失败的现象。修复应让测试夹具的创建范围与允许共享范围一致,或者重建真正被修改的子对象。通过改变用例顺序找线索可以帮助诊断,但最终仍要验证共享引用,不把顺序依赖当成偶然环境波动。
最后,不能只靠名称猜测所有权。copy_config 这个名字未说明浅拷贝还是深拷贝,readonly_config 也未保证内部对象无法修改。接口文档可以具体写“外层映射独立,标签列表独立,其余字段只读共享”,然后用最小实验检查约定。清楚的边界比一个听起来安全的名字更能降低后续维护风险。
8. 面试追问与工程取舍
浅拷贝到底浅在哪里? 它独立外层结构,内部引用仍指向原来的对象。拿“字典里的列表”画图,比背“浅拷贝复制地址”更准确,因为不可变子对象共享时可能完全符合需求。
深拷贝一定让所有对象互不共享吗? 不是。它处理循环、保留某些共享关系,并对部分对象采用不复制或自定义行为。需要真正的隔离语义时,必须理解对象类别和资源边界,而不是仅靠函数名。
为什么函数能改列表却不能改整数? 根本差异是修改共享对象与重新绑定局部名称。列表支持原地修改,整数加法产生结果后重绑;不是 Python 为两种参数选择了完全不同的传参制度。
共享子节点与循环:沿同一张图继续判断
将配置移入函数参数或实例属性,变的是关联存放位置,共享传播没有消失。第五篇会增加“关联何时建立”的时间维度,第九篇增加“属性从哪层读到”的查找维度。先保留本篇对象图,再加这一个维度,便能判断默认参数和类属性为何也会串改;深拷贝不应成为遇到共享就无条件使用的修补。
循环对象图有一个共享子列表,两条边都指向它,另有一条边指回根列表。deepcopy 维护 memo(已经复制对象的映射),第一次遇到对象就建立副本关联,之后遇到同一对象复用该副本。因而 cloned[0] is cloned[1] 和 cloned[2] is cloned 都成立;子列表则不再是原来的 child。它解决循环递归,也保留“两个入口共享同一实体”这个语义。深拷贝不是把所有共享关系拆散,见copy 官方说明。
如果业务想让每个请求的子列表完全独立,仅对整张图调用一次 deepcopy 未必符合契约。需要在请求边界单独构建数据,而不是把共享图复制后期待拓扑改变。反过来,一个订单对象在图内被多次引用,拆散它又可能让更新产生不一致。选择拷贝策略以前先写“函数可以修改什么、返回结果是否共享输入的嵌套对象、是否接受循环结构”的所有权约定。所有权在这里是接口承诺,不是 Python 编译器强制的规则。
独立练习:给 prepare_request(config) 写出借用、浅拷贝、独立构造三种契约;构造含共享子列表的输入,分别修改顶层和子层,再用 is 与内容断言验收,不准只打印地址。若输出必须无共享,则额外要求两个输出字段 is not,不能拿“调用了 deepcopy”代替证明。第五篇解释共享对象为何在函数创建时进入默认值;本篇负责对象关系,第五篇负责绑定时间。内存篇解释循环关系怎样影响回收。
一句话总结:沿名称和容器引用画出对象图,才能判断修改会传播到哪里。
- 赋值和参数传递建立绑定,原地修改与重新绑定的作用范围不同。
- 浅拷贝独立外层,嵌套对象仍可能共享;深拷贝也有结构与资源边界。
- 对身份用
is,对业务内容用==,不要依赖不可变对象缓存的偶然结果。
参考:对象数据模型、copy、函数参数。本例已在 Windows x64 的 CPython 3.14.0 和 3.13.7 验证通过,不涉及性能比较。
上一篇:基础语法与日志汇总。下一篇:容器选型与实现。延伸:引用计数 GC 与内存分配。