「Python 进阶之路」系列 Day01
写在前面
如果你写过一段时间 Python，大概率遇到过这种诡异 bug：一个看起来完全无状态的函数，第二次调用的结果却"记得"第一次调用的数据，明明每次都是新调用，却像是共享了一个全局变量。
这就是 Python 最经典的入门陷阱------可变默认参数 。今天这篇从"可变 vs 不可变对象"这个更底层的概念讲起，把这个坑的成因彻底讲透，顺便理清 is 和 == 这对最容易被面试官盯上的操作符。
一、是什么：可变对象 vs 不可变对象
Python 里所有东西都是对象，但对象分两类，区别在于创建后内容能不能被原地修改：
| 分类 | 常见类型 | 说明 |
|---|---|---|
| 不可变（Immutable） | int float bool str tuple frozenset bytes |
一旦创建，内容不能改；看起来像"修改"的操作，实际是创建了一个新对象 |
| 可变（Mutable） | list dict set bytearray，以及默认情况下的自定义类实例 |
可以原地修改内容，对象的内存地址（身份）不变 |
光看定义比较抽象，直接用 id() 把这个区别"看"出来：
python
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__方法
python
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 最经典的坑
先看一个看起来完全正常、但实际上有大问题的函数：
python
def add_item(item, items=[]): # ❌ items=[] 长什么样子先记住
items.append(item)
return items
print(add_item("a")) # ['a']
print(add_item("b")) # ['a', 'b'] ← 期望应该是 ['b']！
print(add_item("c")) # ['a', 'b', 'c'] ← 一路累积，像个"记仇"的函数明明每次调用都没有传 items 参数，为什么它会一直往同一个列表里塞东西？
真相：默认参数只在函数定义时创建一次
核心结论：函数的默认参数值，只在 def 语句执行的那一刻被求值、创建一次，之后每次调用如果不显式传参，都会复用同一个对象，而不是每次调用重新创建。
用 id() 直接实锤这个说法：
python
def add_item(item, items=[]):
print(id(items)) # 三次调用打印出来的地址完全相同！
items.append(item)
return items
add_item("a")
add_item("b")
add_item("c")还可以更直接地证明------默认参数本身就存放在函数对象的一个属性里：
python
print(add_item.__defaults__) # ([...],)，能直接看到这个默认参数元组，全程只有一份为什么 Python 要这么设计 ：def 在 Python 里本质上是一条可执行语句，默认参数的表达式（比如 []）会在这条 def 语句被执行时求值一次，求值结果绑定在函数对象的 __defaults__ 属性上。之后每次调用函数、没有传对应参数时，直接从 __defaults__ 里取出这个"预制"好的对象来用------这是 Python 明确的既定行为，不是解释器 bug，只是和大多数人"每次调用都应该是全新状态"的直觉不符，所以才成了新手（甚至有些老手偶尔也会）踩的经典陷阱。
如果默认参数是 int、str 这类不可变对象，其实不会有问题------因为你没法"原地修改"它，任何看起来像修改的操作（比如 +=）都会创建新对象重新赋值给局部变量，不会影响到 __defaults__ 里那份原始对象。陷阱只在默认参数是可变对象、并且在函数体内对它做了原地修改（append、update、下标赋值等）时才会触发。
四、正确写法：用 None 作哨兵值
python
def add_item(item, items=None):
if items is None: # 用 is 判断------None 是全局单例，身份判断更快也更准确
items = [] # 每次调用、真正需要时才创建全新的 list
items.append(item)
return items
print(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() 才能观察到"对象被复用"的现象，很容易和默认参数陷阱混为一谈，但两者成因完全不同：
python
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() 到底在拷贝什么，嵌套列表/字典浅拷贝之后为什么"改一个牵动两个"。