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

写在前面

写 Python 的朋友，大概都见过这么个诡异 bug：一个看起来完全无状态的函数，第二次调用时居然“记得”第一次调用的数据。明明每次都是全新的调用，却像是共享了一个全局变量，让人摸不着头脑。

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

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

Python 里的一切都是对象，但对象分两类，区别就在于：创建之后，内容能不能被原地修改。

光看定义确实有点抽象，直接用 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 和 ==，为后面做铺垫

• is 比较的是身份——是不是同一个对象，本质上比的是两者的 id()
• == 比较的是值——内容是否相等，调用的是对象的 __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() 到底在拷贝什么，嵌套列表/字典浅拷贝之后为什么“改一个牵动两个”。