可变对象 vs 不可变对象：为什么"可变默认参数"是 Python 最经典的坑？实战解析

本文围绕可变对象 vs 不可变对象：为什么"可变默认参数"是 Python 最经典的坑实战解析展开，先梳理核心概念，再结合实践场景说明步骤、代码思路和容易忽略的细节，方便后续直接参考。

写在前面 如果你写过一段时间 Python，大概率遇到过这种诡异 bug：一个看起来完全无状态的函数，第二次调用的结果却"记得"第一次调用的数据，明明每次都是新调用，却像是共享了一个全局变量。 这就是 Python 最经典的入门陷阱——可变

写在前面

如果你写过一段时间 Python，大概率遇到过这种诡异 bug：一个看起来完全无状态的函数，第二次调用的结果却"记得"第一次调用的数据，明明每次都是新调用，却像是共享了一个全局变量。

这就是 Python 最经典的入门陷阱——可变默认参数。今天这篇从"可变 vs 不可变对象"这个更底层的概念讲起，把这个坑的成因彻底讲透，顺便理清 is 和 == 这对最容易被面试官盯上的操作符。

---

一、是什么：可变对象 vs 不可变对象

Python 里所有东西都是对象，但对象分两类，区别在于创建后内容能不能被原地修改：

分类	常见类型	说明
不可变（Immutable）	int float bool str tuple frozenset bytes	一旦创建，内容不能改；看起来像"修改"的操作，实际是创建了一个新对象
可变（Mutable）	list dict set bytearray，以及默认情况下的自定义类实例	可以原地修改内容，对象的内存地址（身份）不变

光看定义比较抽象，直接用 id() 把这个区别"看"出来：

 复制代码a = "hello" print(id(a)) # 假设是 140001 a += " world" print(id(a)) # 变了！比如 140002 —— += 创建了新的 str 对象，a 只是重新指向它b = [1, 2, 3] print(id(b)) # 假设是 140010 b.append(4) print(id(b)) # 没变，还是 140010 —— list.append 是原地修改，对象本体没换 

一句话记住这个区别：不可变对象的"修改"是换了个新对象重新贴标签；可变对象的修改是直接改对象本体，标签（引用）没变。

---

二、先搞清楚 is 和 ==，为后面做铺垫

1. is 比较的是身份——是不是同一个对象，本质上比较的是两者的 id()
2. == 比较的是值——内容是否相等，调用的是对象的 __eq__ 方法

 复制代码a = [1, 2, 3] b = [1, 2, 3] print(a == b) # True，内容相等 print(a is b) # False，是两个不同的对象，只是内容碰巧一样 print(id(a), id(b)) # 两个不同的内存地址 

记住这个区分，因为下面的默认参数陷阱，本质上就是靠 is/id() 才能真正"看穿"的问题。

---

三、默认参数陷阱：Python 最经典的坑

先看一个看起来完全正常、但实际上有大问题的函数：

 复制代码def add_item(item, items=[]): # items=[] 长什么样子先记住 items.append(item) return itemsprint(add_item("a")) # ['a'] print(add_item("b")) # ['a', 'b'] ← 期望应该是 ['b']！ print(add_item("c")) # ['a', 'b', 'c'] ← 一路累积，像个"记仇"的函数 

明明每次调用都没有传 items 参数，为什么它会一直往同一个列表里塞东西？

真相：默认参数只在函数定义时创建一次

核心结论：函数的默认参数值，只在 def 语句执行的那一刻被求值、创建一次，之后每次调用如果不显式传参，都会复用同一个对象，而不是每次调用重新创建。

用 id() 直接实锤这个说法：

 复制代码def add_item(item, items=[]): print(id(items)) # 三次调用打印出来的地址完全相同！ items.append(item) return itemsadd_item("a") add_item("b") add_item("c") 

还可以更直接地证明——默认参数本身就存放在函数对象的一个属性里：

 复制代码print(add_item.__defaults__) # ([...],)，能直接看到这个默认参数元组，全程只有一份 

为什么 Python 要这么设计：def 在 Python 里本质上是一条可执行语句，默认参数的表达式（比如 []）会在这条 def 语句被执行时求值一次，求值结果绑定在函数对象的 __defaults__ 属性上。之后每次调用函数、没有传对应参数时，直接从 __defaults__ 里取出这个"预制"好的对象来用——这是 Python 明确的既定行为，不是解释器 bug，只是和大多数人"每次调用都应该是全新状态"的直觉不符，所以才成了新手（甚至有些老手偶尔也会）踩的经典陷阱。

如果默认参数是 int、str 这类不可变对象，其实不会有问题——因为你没法"原地修改"它，任何看起来像修改的操作（比如 +=）都会创建新对象重新赋值给局部变量，不会影响到 __defaults__ 里那份原始对象。陷阱只在默认参数是可变对象、并且在函数体内对它做了原地修改（append、update、下标赋值等）时才会触发。

---

四、正确写法：用 None 作哨兵值

 复制代码def add_item(item, items=None): if items is None: # 用 is 判断——None 是全局单例，身份判断更快也更准确 items = [] # 每次调用、真正需要时才创建全新的 list items.append(item) return itemsprint(add_item("a")) # ['a'] print(add_item("b")) # ['b'] ← 符合预期，互不影响 

为什么用 is None 而不是 == None：None 在整个 Python 进程里全局只有一个实例，is None 直接比较身份，性能更好；而且如果某个自定义类重写了 __eq__ 方法，== None 的结果可能会出乎意料（比如返回一个自定义对象而不是 bool），is None 完全不受这个影响，这也是为什么 PEP 8 明确推荐用 is/is not 来判断 None。

---

五、容易和这个坑搞混的现象：小整数缓存与字符串驻留

同样是要靠 is/id() 才能观察到"对象被复用"的现象，很容易和默认参数陷阱混为一谈，但两者成因完全不同：

 复制代码a = 100 b = 100 print(a is b) # True —— CPython 对 -5 ~ 256 的小整数做了缓存，复用同一个对象c = 10000 d = 10000 print(c is d) # 大概率 False —— 超出缓存范围，各自创建了新对象s1 = "hello" s2 = "hello" print(s1 is s2) # True —— 简单字符串字面量会被"驻留"（intern），复用同一个对象 

关键区别：默认参数陷阱是"该在每次调用时新建对象、但因为语言机制没有新建"，属于该规避的坑；而小整数缓存、字符串驻留是 CPython 解释器主动做的性能优化，不是 Python 语言规范承诺的行为（不同解释器实现、不同 Python 版本都可能有差异）。写业务代码判断相等性永远用 ==，is 只用在明确需要判断"是不是同一个对象"的场景（比如 is None、is True），不要拿它当成"判断值相等"的捷径去依赖这些缓存行为。

---

六、面试追问

Q1：可变对象和不可变对象的核心区别是什么？

能不能在不改变对象身份（内存地址）的前提下修改其内容。不可变对象（int/str/tuple 等）任何"修改"操作实际都是创建了新对象并重新绑定引用；可变对象（list/dict/set 等）可以原地修改内容，对象本身的身份不变，可以用 id() 前后对比验证。

Q2：is 和 == 的区别，什么场景该用哪个？

is 比较两个变量是否指向同一个对象（比较 id()），== 比较两个对象的值是否相等（调用 __eq__）。判断内容相等（比如两个列表内容是否一样）用 ==；判断是否是同一个对象、尤其是判断 None/True/False 这类单例，用 is，性能更好且语义更明确。

Q3：为什么可变对象作为函数默认参数会有坑？

因为默认参数的值只在函数定义（def 语句执行）时被求值一次，绑定在函数对象的 __defaults__ 属性上，之后每次调用、没有显式传参时都复用这同一个对象。如果默认参数是可变对象，且函数体内对它做了原地修改（如 append），修改结果会残留到下一次调用，造成"函数记住了上次调用状态"的诡异 bug。不可变类型作为默认参数不会有这个问题，因为任何修改都会生成新对象，不影响 __defaults__ 里的原始对象。

Q4：怎么修复可变默认参数陷阱？

把默认参数设为 None，在函数体内用 if xxx is None: xxx = 新对象 的方式，在每次真正需要时才创建一个全新的可变对象，避免复用同一个对象。

Q5：小整数缓存、字符串驻留和默认参数陷阱是同一类问题吗？

不是。默认参数陷阱是"该新建对象却没新建"，是需要程序员主动规避的语言机制坑；小整数缓存（-5~256）和字符串驻留是 CPython 解释器为了节省内存主动做的性能优化，且不是 Python 语言规范强制保证的行为（不能依赖它来判断相等性），两者只是表面上都能用 is/id() 观察到"复用同一对象"的现象，成因和应对方式完全不同。

---

下一篇预告

Day02 讲深拷贝和浅拷贝——copy.copy() 和 copy.deepcopy() 到底在拷贝什么，嵌套列表/字典浅拷贝之后为什么"改一个牵动两个"。

实际使用时，建议结合项目规模、依赖环境和团队习惯做取舍；先保证流程清晰和结果可验证，再逐步优化细节。