避免Python类定义中可变默认值陷阱：深入理解实例与类变量行为

在Python编程中，一个常见的陷阱是直接在类定义中为可变对象（如列表、字典或集合）赋默认值。这会导致该对象成为所有实例共享的类变量，而非每个实例独有的实例变量。这种行为在多实例场景，特别是单元测试或集成测试中，可能引发数据意外累积和不一致性，导致程序行为与预期不符。本文将深入探讨这一问题，并通过示例代码演示其影响，最终提供解决方案和最佳实践。

问题的根源：类变量与实例变量的混淆

Python中，变量的作用域分为类级别和实例级别。

• 类变量 (Class Variables)：在类定义内部、任何方法外部声明的变量。它们被所有类的实例共享。
• 实例变量 (Instance Variables)：在__init__方法或其他实例方法内部，通过self.variable_name形式声明的变量。每个实例都有其独立的副本。

当在类定义中直接为一个可变对象（如list）赋值时，这个可变对象实际上被创建了一次，并作为类变量存储。这意味着所有通过该类创建的实例都将引用同一个列表对象。如果一个实例修改了这个列表，其他实例也会看到这些修改。

考虑以下代码片段，其中session_starts列表在类定义时被初始化：

from datetime import datetime
from io import StringIO
import pandas
from pandas import DataFrame
FHD_TIME_FORMAT = '%m/%d/%Y %H:%M:%S'
class FhdbTsvDecoder:
tsv: str
legs_and_phase: list[tuple[datetime, int, int]]
# ⚠️ 问题所在：可变对象作为类变量被初始化
session_starts: list[datetime] = []
session_ends: list[datetime] # 此时未初始化，但如果也赋值[]，则同理
def __init__(self, tsv: str):
self.tsv = tsv
# self.legs_and_phase 和 self.session_ends 在 __extract_leg_and_phase 中被重新赋值
# 但如果它们也像 session_starts 一样在类定义时被初始化，则也会有同样的问题
self.__extract_leg_and_phase()
def __extract_leg_and_phase(self) -> None:
df: DataFrame = pandas.read_csv(StringIO(self.tsv), sep='\t', header=None,
converters={4: lambda x: datetime.strptime(x, FHD_TIME_FORMAT)},
skiprows=0)
# 这里的重新赋值避免了 legs_and_phase 的问题
self.legs_and_phase = []
# ⚠️ 如果 session_starts 和 session_ends 在类定义时被初始化为 []
# 并且这里没有再次赋值，那么它们会引用类变量
# self.session_starts = [] # 正确的初始化方式，但如果未执行，则会引用类变量
self.session_ends = [] # 这里的重新赋值避免了 session_ends 的问题
iterator = df.iterrows()
for index, row in iterator:
list.append(self.legs_and_phase, (row[4], row[5], row[6]))
if row[1] == row[2] == row[3] == row[5] == row[6] == 0:
self.session_ends.append(row[4])
self.session_starts.append(next(iterator)[1][4]) # ⚠️ 修改了共享的类变量

在上述FhdbTsvDecoder类中，session_starts: list[datetime] = []这一行使得session_starts成为一个类变量。当创建多个FhdbTsvDecoder实例时，它们都共享同一个session_starts列表。如果在测试环境中，一个测试用例创建了一个FhdbTsvDecoder实例，并向session_starts中添加了数据，那么在后续的测试用例中，即使创建了新的FhdbTsvDecoder实例，这个session_starts列表也将包含之前测试用例添加的数据，导致数据翻倍或不一致。

立即学习“Python免费学习笔记（深入）”；

简化示例：演示共享的可变状态

为了更直观地理解这个问题，我们来看一个简化的例子：

class SharedListExample:
# ⚠️ 错误：shared_data 是一个类变量，所有实例共享
shared_data = []
def __init__(self, item):
self.shared_data.append(item)
print(f"实例添加 '{item}', shared_data: {self.shared_data}")
# 创建第一个实例
instance1 = SharedListExample("Apple")
# 预期：['Apple']
# 实际：['Apple']
# 创建第二个实例
instance2 = SharedListExample("Banana")
# 预期：instance2 应该有 ['Banana']
# 实际：instance1.shared_data 和 instance2.shared_data 都是 ['Apple', 'Banana']
print(f"\ninstance1.shared_data: {instance1.shared_data}")
print(f"instance2.shared_data: {instance2.shared_data}")
# 再次创建实例
instance3 = SharedListExample("Cherry")
print(f"\ninstance1.shared_data: {instance1.shared_data}")
print(f"instance2.shared_data: {instance2.shared_data}")
print(f"instance3.shared_data: {instance3.shared_data}")

运行上述代码，你会发现instance1.shared_data、instance2.shared_data和instance3.shared_data都指向同一个列表对象，并且随着新实例的创建而不断增长。

解决方案：在__init__方法中初始化实例变量

解决这个问题的关键是在类的__init__方法中初始化所有实例变量，尤其是可变对象。__init__方法在每次创建新实例时都会被调用，确保每个实例都获得其独立的属性副本。

from datetime import datetime
from io import StringIO
import pandas
from pandas import DataFrame
FHD_TIME_FORMAT = '%m/%d/%Y %H:%M:%S'
class FhdbTsvDecoderCorrected:
tsv: str
legs_and_phase: list[tuple[datetime, int, int]]
session_starts: list[datetime]
session_ends: list[datetime]
def __init__(self, tsv: str):
self.tsv = tsv
# ✅ 正确做法：在 __init__ 中初始化所有实例变量
self.legs_and_phase = []
self.session_starts = []
self.session_ends = []
self.__extract_leg_and_phase()
def __extract_leg_and_phase(self) -> None:
df: DataFrame = pandas.read_csv(StringIO(self.tsv), sep='\t', header=None,
converters={4: lambda x: datetime.strptime(x, FHD_TIME_FORMAT)},
skiprows=0)
# 此时 self.legs_and_phase, self.session_starts, self.session_ends
# 已经是各自实例独立的空列表，可以直接操作
iterator = df.iterrows()
for index, row in iterator:
self.legs_and_phase.append((row[4], row[5], row[6])) # 注意这里使用 .append() 方法
if row[1] == row[2] == row[3] == row[5] == row[6] == 0:
self.session_ends.append(row[4])
self.session_starts.append(next(iterator)[1][4])

通过将legs_and_phase、session_starts和session_ends的初始化移到__init__方法中，每个FhdbTsvDecoderCorrected实例都会在创建时获得全新的、独立的列表。这样，即使在多个测试用例或多个集成场景中创建了多个实例，它们的数据也不会相互干扰。

家作

淘宝推出的家装家居AI创意设计工具

38

查看详情

为什么在IDE和控制台运行结果不同？

原始问题中提到，在IntelliJ中运行测试时通过，而在控制台运行测试时失败。这种差异通常不是因为IDE或控制台本身的行为不同，而是因为它们在执行测试时对模块的加载和重用策略可能不同。

• 控制台 (例如 pytest): 当你从控制台运行测试套件时，pytest通常会加载一次测试模块。如果你的测试文件中有多个测试函数，或者有其他集成测试也使用了FhdbTsvDecoder类，那么该类可能只被加载一次。这意味着如果FhdbTsvDecoder中存在类变量（如session_starts = []），它将在模块加载时被初始化一次，并在所有后续的测试运行或实例创建中被重用。前一个测试用例对这个共享列表的修改会影响到下一个测试用例。
• IDE (例如 IntelliJ): 某些IDE在运行单个测试文件或测试方法时，可能会在每次运行时更彻底地重新加载模块或创建更隔离的执行环境。这可能导致每次测试运行时都获得一个“干净”的类定义，从而避免了类变量的累积效应。

关键在于： 无论在哪种环境下，问题的根本原因都是类变量的可变性及其共享特性。环境差异只是揭示或隐藏了这个问题。遵循在__init__中初始化实例变量的最佳实践，可以确保代码在任何环境下都表现一致且正确。

最佳实践与注意事项

1. 始终在__init__中初始化可变实例属性： 这是最核心的原则。任何在实例生命周期中需要独立维护状态的可变对象（如列表、字典、集合），都应该在__init__方法中通过self.attribute_name = default_value的形式进行初始化。

2. 理解类变量的用途： 类变量并非一无是处。它们适用于存储所有实例共享的常量、配置值或需要被所有实例访问的单一可变状态（但这种情况下通常需要更谨慎的同步机制）。

3. 使用default_factory处理默认值： 对于Python 3.7+的dataclasses或第三方库attrs，它们提供了default_factory参数来优雅地处理可变默认值，避免手动在__init__中赋值的样板代码：

   from dataclasses import dataclass, field
   @dataclass
   class MyDataClass:
   name: str
   # ✅ 使用 default_factory 确保每个实例获得独立的列表
   items: list[str] = field(default_factory=list)
   obj_a = MyDataClass("A")
   obj_a.items.append("item1")
   obj_b = MyDataClass("B")
   obj_b.items.append("item2")
   print(f"obj_a.items: {obj_a.items}") # 输出: ['item1']
   print(f"obj_b.items: {obj_b.items}") # 输出: ['item2']

4. 代码审查： 在代码审查中特别留意类定义中可变对象的默认值初始化，确保它们符合预期。

总结

Python中类定义时可变对象的默认值陷阱是一个常见但容易被忽视的问题。它会导致所有实例共享同一个可变对象，从而在多实例场景下引发数据累积和不一致性。解决之道是始终在__init__方法中初始化这些实例变量，确保每个实例都拥有独立的副本。理解Python的类变量与实例变量机制，并遵循在__init__中初始化可变实例属性的最佳实践，是编写健壮、可预测和易于维护的Python代码的关键。