一个让我排查了三个小时的Bug

去年写了一个用户行为追踪模块，需要对每个访问用户记录一系列操作日志：

def log_user_action(action, history=[]):
    history.append(action)
    print(f"当前操作: {action}")
    print(f"操作历史: {history}")
    return history

看起来平平无奇对吧？一个函数记录用户操作，默认参数history=[]让每次调用都从空列表开始。

测试的时候单独跑，一切正常：

log_user_action("登录")  
# 当前操作: 登录
# 操作历史: ['登录']

上线之后，奇怪的事情发生了。运维同事跑过来跟我说：“日志系统出问题了，用户A的日志里全是B用户的操作。”

我赶紧去查代码，模拟了两个用户交替调用：

# 用户A
log_user_action("A登录")
log_user_action("A浏览商品")

# 用户B  
log_user_action("B登录")

猜猜输出是什么？

当前操作: A登录
操作历史: ['A登录']

当前操作: A浏览商品
操作历史: ['A登录', 'A浏览商品']

当前操作: B登录
操作历史: ['A登录', 'A浏览商品', 'B登录']    # B的列表里有A的数据！

用户B的操作历史里，赫然出现了用户A的操作记录。两个用户的数据串在一起，完全乱套了。

我盯着代码看了半天，history=[]明明每次都传了个空列表，怎么会累积呢？

那天下午，我把Python的可变和不可变对象、默认参数的求值时机彻底研究了一遍。今天把这些坑讲清楚，希望你别重蹈我的覆辙。

第一步：先搞清楚可变和不可变对象

Python里的对象分两种：

不可变对象： 一旦创建，值就不能改。数字、字符串、元组、布尔值、None都属于这一类。

a = 1
b = a
a = 2          # 这不是改1，是让a指向2
print(b)       # 还是1 —— b指向的对象没变

当你以为你在“改”一个不可变对象时，实际上是创建了一个新对象，然后让变量指向新对象。

s = "hello"
print(id(s))   # 假设是 140234567890
s = s + " world"
print(id(s))   # 新的id —— 创建了新字符串

可变对象： 创建之后可以原地修改内容。列表、字典、集合、自定义类的实例都属于这一类。

lst = [1, 2, 3]
print(id(lst))   # 假设是 140234567890
lst.append(4)
print(id(lst))   # 还是 140234567890 —— 对象没变，内容变了

可变对象就像一块白板，你可以在上面擦擦写写，白板还是那块白板。不可变对象就像刻在石头上的字，想改只能换块石头。

第二步：Python默认参数的一个冷门特性

搞清楚可变和不可变之后，现在说关键问题：

Python函数的默认参数，在函数定义时就被求值了，而不是在函数调用时。

什么意思？

def add(x, y=[]):
    y.append(x)
    return y

当Python解释器读到def add(x, y=[]):这一行的时候，它就执行了[]，创建了一个空列表对象，然后把这个对象“焊死”在函数对象上。之后的每一次调用，用的都是这同一个列表对象。

每次调用add(1)，都是往那个同一个列表里追加元素。这就是为什么用户B的日志里会出现用户A的数据——他们用的是同一个history列表。

验证一下：

def test_default(arg=[]):
    arg.append(1)
    print(id(arg))   # 每次打印的id都一样

test_default()  # 打印某个id
test_default()  # 打印同样的id
test_default()  # 还是同样的id

三调用的arg指向的是同一个列表对象。但如果是不可变对象作为默认参数：

def test_default(arg=1):
    arg = arg + 1
    print(id(arg))   # 每次打印的id都不同

test_default()  # 某个id
test_default()  # 不同的id
test_default()  # 又是不同的id

每次对不可变对象进行“修改”，实际上是创建了新对象，原来的默认参数对象纹丝不动。

第三步：为什么会有这种设计？

你可能会问：为啥Python要这么设计？这不是坑人吗？

其实这个设计背后的逻辑是：Python的函数是对象，默认参数是函数对象的属性。

def foo(x, y=10):
    pass

print(foo.__defaults__)   # (10,)

默认参数在函数定义时被求值，作为元组保存在__defaults__属性里。这样每次调用函数的时候，直接从这个属性里读默认值，不需要重新求值——提高了执行效率。

这个设计对不可变对象来说完全没问题。10就是10，谁来了它都不变。

但问题是Python不限制默认参数的类型。如果你用了可变对象（列表、字典），这个对象也是定义时创建一次，然后被所有调用共享。这就出事了。

这算不算设计缺陷？Python之父Guido van Rossum在2012年的邮件里承认：“这个问题让每个人都踩过坑。如果时光倒流，我会让默认参数在函数调用时求值。”但作为一门已经跑了几十年的语言，这种兼容性问题改不了，只能靠开发者自己注意。

第四步：正确的写法

既然知道了问题，怎么改？

用None做哨兵值，在函数内部创建新对象：

# 错误写法
def log_user_action(action, history=[]):
    history.append(action)
    return history

# 正确写法
def log_user_action(action, history=None):
    if history is None:
        history = []
    history.append(action)
    return history

现在每次调用，如果没传history，都会创建一个全新的空列表。用户之间不再互相污染：

log_user_action("A登录")     # ['A登录']
log_user_action("A浏览")     # ['A登录', 'A浏览']  
log_user_action("B登录")     # ['B登录']  —— 干净的新列表

None是不可变对象，作为默认参数绝对安全。用None做哨兵，在函数内部判断并创建可变对象，这是Python社区公认的标准写法。

同样的套路适用于所有可变对象：

# 字典
def process_data(data, config=None):
    if config is None:
        config = {}
    # ...

# 集合
def track_tags(tags, tag_set=None):
    if tag_set is None:
        tag_set = set()
    # ...

# 自定义对象
def create_user(name, profile=None):
    if profile is None:
        profile = UserProfile()
    # ...

第五步：还有一些更隐蔽的坑

坑一：类属性里的可变对象

class User:
    permissions = []  # 类属性，所有实例共享

alice = User()
bob = User()
alice.permissions.append("admin")
print(bob.permissions)  # ['admin'] —— Bob也被加了权限！

正确写法是在__init__里创建实例属性：

class User:
    def __init__(self):
        self.permissions = []  # 每个实例自己的一份

坑二：函数默认参数依赖另一个可变默认参数

# 极其危险的写法
def build_url(base="", params={}):
    # ...

def make_request(url=build_url(""), headers={}):
    # ...

默认参数之间如果有依赖关系，一个变了另一个也跟着变，调试的时候能把人逼疯。

坑三：缓存陷阱

有人想用默认参数做缓存：

def expensive_calc(key, cache={}):
    if key in cache:
        return cache[key]
    result = really_slow_calculation(key)
    cache[key] = result
    return result

这代码看起来聪明，实际上有问题——cache是全局共享的，不会被清理，内存会一直涨。而且测试之间会互相污染。正确的做法是用functools.lru_cache。

第六步：一个常见的面试题

这个坑太经典了，面试官特别喜欢考：

def func(a, b=[]):
    b.append(a)
    return b

print(func(1))
print(func(2))
print(func(3, []))  # 注意这里传了参数
print(func(4))

输出是什么？

• func(1)：[1]

• func(2)：[1, 2] —— 同一个列表

• func(3, [])：[3] —— 传了新列表，不受默认参数影响

• func(4)：[1, 2, 4] —— 又回到了那个累积的列表

这道题考的就是你对默认参数求值时机和可变对象共享的理解。能答上来，说明你已经避开了这个坑。

总结

一句话记住：默认参数在定义时只创建一次，可变对象会被所有调用共享；不可变对象安全，可变对象危险。

用我那个日志系统的例子来总结：

• **用history=[]**：像是给所有用户发了一本共同的日记本，A写的内容B也能看到

• **用history=None**：像是每个用户发了一本全新的空白日记本，各写各的

现在我写函数但凡默认参数是可变的（列表、字典、集合），一定用None做哨兵，在函数内部创建。这个习惯救了我无数次，希望也能救你。

有一个简单的记忆方法：默认参数用不可变，可变对象内部造。每次写完函数看一眼默认参数，如果是[]或{}，立马改成None。想清楚再动手，少排查几小时Bug。