2.1 一切皆对象:变量赋值的本质(引用传递 vs 值传递)与可变/不可变类型剖析
本节目录
2.1 一切皆对象:变量赋值的本质(引用传递 vs 值传递)与可变/不可变类型剖析
欢迎来到 HelloWorld 技术社区(www.helloworld.net) 《Python 现代开发实战》第二章!
在第一章里,我们用 uv 和 Ruff 搭建了工业级的开发环境,并写下了规范的第一行代码。从今天开始,我们正式切入 Python 语言的腹地——内存模型与核心数据容器。
很多从 C、C++ 或 Java 转行过来的开发者,刚写 Python 时最容易陷入一个思维定式:把变量当成装数据的“盒子”。这种误解会直接导致你在业务代码里写出极其隐蔽的“数据串改 Bug”(比如改了用户 A 的权限列表,结果全站用户的默认权限全被改了)。
今天这一节,我们不背概念,直接透过内存地址(id())和底层指针模型,彻底看穿 Python 变量赋值的真相。
一、 颠覆认知:Python 的变量不是“盒子”,而是“便利贴”
在 C/Java 这类静态语言中,声明 int a = 10 意味着在内存中开辟了一块 4 字节的“盒子”,把 10 塞进去;执行 b = a 时,会再开辟一个新盒子,把 10 拷贝一份放进去。
但在 Python 中,一切皆对象(Everything is an Object),而变量仅仅是指向对象的引用(标签/便利贴)。
当你写下 a = [1, 2, 3] 时,Python 底层做了两件事:
- 在堆内存(Heap)中创建一个真实的列表对象
[1, 2, 3](包含类型信息、引用计数和实际数据); - 创建一张名叫
a的“便利贴”,把它贴在这个列表对象上。
如果你接着执行 b = a,Python 绝对不会复制一份新的列表,而只是撕下一张名叫 b 的新便利贴,贴在了同一个对象上。
Plaintext
变量名 (栈/命名空间) 真实对象 (堆内存)
+------------------+ +-------------------------+
| a | ---------> | list: [1, 2, 3] |
+------------------+ +---> | id: 0x104a8b200 |
| | refcount: 2 |
+------------------+ | +-------------------------+
| b | -----+
+------------------+
你可以用 Python 内置的 id() 函数(返回对象在内存中的唯一地址编号)和 is 运算符(判断两个变量是否贴在同一个对象上)亲眼验证这一点:
Python
a = [1, 2, 3]
b = a # 仅仅是新增了一个引用标签,没有发生内存拷贝
print(f"a 的内存地址: {hex(id(a))}")
print(f"b 的内存地址: {hex(id(b))}")
print("a 和 b 是否指向同一个对象:", a is b) # True
# 通过 b 修改列表内容,a 也会同步受影响!
b.append(4)
print("修改 b 之后,a 的值为:", a) # [1, 2, 3, 4]
二、 可变(Mutable)vs 不可变(Immutable)类型全景图
既然赋值只是“贴标签”,为什么下面这段代码里,修改 y 却没有影响 x 呢?
Python
x = 100
y = x
y = y + 1
print(x, y) # 输出: 100 101(x 居然没变!)
这里就引出了 Python 内存模型中最核心的分水岭——对象的可变性。所谓“可变”与“不可变”,指的是对象在内存创建之后,其内部存储的值是否允许被原地修改。
| 类型分类 | 包含的内置数据类型 | 原地修改行为(如 += 或方法调用) | 典型特性 |
| 不可变类型 (Immutable) | int, float, bool, str, tuple, bytes, frozenset |
无法原地修改。任何看似“修改”的操作,本质上都是在内存中创建一个新对象,然后把变量标签撕下来贴到新对象上。 | 线程安全、可哈希(能作为 dict 的键和 set 的元素)。 |
| 可变类型 (Mutable) | list, dict, set, bytearray, 自定义普通类实例 |
支持原地修改(In-place)。对象内存地址 id() 保持不变,内部数据直接被改写,所有指向它的变量都会看到变化。 |
节省频繁创建对象的开销,但在多处引用时需警惕副作用。 |
回看刚才的 y = y + 1:因为整数 100 是不可变对象,Python 无法把 100 改成 101,只能在内存中新建一个整数对象 101,然后把 y 的标签改贴到 101 上,而 x 依然稳稳地指着原来的 100。
三、 函数传参真相:既不是值传递,也不是传统引用传递
面试官最爱问的问题:“Python 函数参数到底是值传递(Pass by Value)还是引用传递(Pass by Reference)?”
最准确的官方术语叫做 对象引用传递(Call by Object Reference / Call by Sharing)——即把实参的“便利贴”复制一份贴到形参上,形参和实参在进入函数的一瞬间指向同一个对象。
这会导致两种截然不同的表现:
- 如果在函数内部对参数执行重新赋值(
param = ...):只是把形参自己的便利贴撕下来贴向别处,外部实参毫无感知; - 如果在函数内部对可变参数执行原地修改(
param.append(...)):直接改写了底层共享对象,外部实参会被直接篡改。
生产级高危“深坑”:可变默认参数陷阱
下面这段代码是 Python 初学者(甚至不少工作两年的工程师)在业务接口中最容易写出的经典 Bug:
Python
# ❌ 错误示范:使用可变对象 [] 作为函数默认参数
def add_user_role(user_id: int, role: str, roles: list[str] = []) -> list[str]:
roles.append(role)
return roles
# 业务调用:为用户 1001 分配权限
print("用户 1001 权限:", add_user_role(1001, "editor")) # ['editor']
# 业务调用:为新用户 1002 分配权限(未传 roles,期望获得干净的新列表)
print("用户 1002 权限:", add_user_role(1002, "viewer")) # 😱 灾难!输出 ['editor', 'viewer']
原因剖析:函数的默认参数是在函数定义(def 语句执行)的那一刻就计算好并绑定在函数对象的 __defaults__ 属性里的,而不是每次调用函数时重新创建!因此所有未传 roles 的调用,都在往同一个默认列表对象里塞数据。
工业级标准写法(使用 None 作为哨兵值):
Python
# ✅ 正确示范:默认参数永远使用不可变的 None
def add_user_role(
user_id: int, role: str, roles: list[str] | None = None
) -> list[str]:
if roles is None:
roles = [] # 每次调用时动态创建全新的独立列表
roles.append(role)
return roles
print("用户 1001 权限:", add_user_role(1001, "editor")) # ['editor']
print("用户 1002 权限:", add_user_role(1002, "viewer")) # ['viewer']
(小彩蛋:如果你在第一章按照我们的指南配置了 Ruff 并开启了 "B" 规则集,Ruff 会直接用 B006 规则在编辑器里给你标出红色波浪线警告!)
四、 浅拷贝(Shallow Copy)与深拷贝(Deep Copy)
当你的业务数据是一个嵌套结构(例如:一个列表里面套着字典,字典里又套着列表),直接赋值 b = a 会完全共享内存。这时我们需要显式拷贝:
- 浅拷贝(
a.copy()或copy.copy(a)):只克隆最外层的“壳子”,里面的嵌套子对象依然是共享引用; - 深拷贝(
copy.deepcopy(a)):递归克隆所有层级的对象,生成一棵与原数据100% 物理隔离的新对象树。
Python
import copy
# 嵌套配置模板
template = {"service": "helloworld-api", "ports": [8000, 8080]}
# 1. 浅拷贝:外层字典地址不同,但内层的 ports 列表依然是同一个!
shallow_cfg = template.copy()
shallow_cfg["ports"].append(9000)
print("浅拷贝污染了原模板:", template["ports"]) # [8000, 8080, 9000]
# 2. 深拷贝:彻底隔离,互不干扰
deep_cfg = copy.deepcopy(template)
deep_cfg["ports"].append(9999)
print("深拷贝后原模板安然无恙:", template["ports"]) # [8000, 8080, 9000]
💬 HelloWorld 社区实战打卡
内存模型是区分“会写 Python 脚本”和“真正懂 Python 工程”的第一道分水岭。今天我们来做一道极具迷惑性的代码推理打卡题!
请不要先运行代码,凭大脑推演下面这段代码的最终输出结果,然后再放入终端验证:
Python
t = (1, 2, [10, 20])
try:
t[2] += [30, 40]
except TypeError as e:
print("捕获异常:", e)
print("最终 t 的值:", t)
打卡任务: 带 #Python专栏打卡 标签,在评论区写下:
t[2] += [30, 40]为什么会抛出TypeError?- 抛出异常后,
t里面的列表到底有没有把[30, 40]加进去?为什么会出现这种反直觉的现象?
评论区第一位给出完整底层解释的同学,直接置顶并送出 100 社区积分!下一节(2.2),我们将深入剖析 Python 最常用的序列双雄——列表(List)的动态数组扩容机制与元组(Tuple)的性能秘密。