按理说，

add 与 __add__，哪种写法更优雅？

在实际项目中，Usage 这种统计类经常需要累计多个子任务的结果。面对「原地修改」和「返回新对象」两种实现方式，大家往往会纠结：

• 性能到底谁更好？
• 代码可读性和安全性如何权衡？
• 并发环境下会不会出现数据竞争？其实，

方案一这方面，add —— 原地修改

@dataclass
class Usage:
prompt的观点是，int = 0
completion: int = 0
再看total，int = 0
cached这方面，int = 0
再看calls，int = 0
至于cost。float = 0.0
def add -> None:
self.prompt += or.prompt
self.completion += or.completion
self.total += or.total
self.cached += or.cached
self.calls += or.calls
self.cost += or.cost

使用方式：

total = Usage
total.add
total.add

✅ 优点：性能更好

• 不产生额外的 Usage 实例，适合在「大量累加」的场景下使用。其实，
• 说到示例，

usage = Usage
for item in usages:
usage.add # 只维护一个对象。避免频繁 GC

❌ 缺点：会改变自身

原地修改会导致引用共享，引发意想不到的副作用。

a = Usage
b = a.add) # b 为 None。a 已被修改
print # 15
print # None

如果你误以为 b = a.add 会得到一个新副本，实际却是对同一个对象的引用，这在调试时极易埋下隐藏 bug。按理说，

再看方案二，__add__ —— 返回新对象

@dataclass
class Usage:
至于prompt，int = 0
completion: int = 0
total的观点是，int = 0
cached这方面，int = 0
再看calls，int = 0
说到cost，float = 0.0
def __add__ -> "Usage":
return Usage(
prompt=self.prompt + or.prompt,completion=self.completion + or.completion。total=self.total + or.total,cached=self.cached + or.cached,calls=self.calls + or.calls,cost=self.cost + or.cost,)

total = usage1 + usage2 # 返回全新的 Usage 实例
total = u1 + u2 + u3 + u4 # 链式计算，一样使用较稳定

✅ 优点：更安全、符合函数式思维

• 原始对象保持不变，避免「引用共享」导致的副作用。
• 适合在需要保留历史状态或进行链式运算的业务场景。
• 从示例来看，

total = usage1 + usage2
print # 未被修改，仍是原始值

❌ 缺点：创建额外对象带来一定开销

每一次 + 都会产生一个新实例。在大批量循环中可能导致大量临时对象：

result = Usage
for u in usages:
result = result + u # 每次循环都会生成一个新对象

如果 usages 数量极大且性能敏感这部分开销不可忽视。

常见痛点深度剖析

1️⃣ 引用共享导致意外修改

很多开发者误以为赋值会复制对象本身。其实 Python 默认复制的是引用：

usage = Usage
backup = usage # backup 与 usage 指向同一实例
usage.add)
print # 输出 15，备份也被改了！

This is root cause of many “莫名其妙的数据变化” bugs.

2️⃣ 函数参数传递时不小心改动全局状态

def calculate_total:
u.add)
return u
u = Usage
result = calculate_total
print # 被改成了 10 —— 函数内部改变了外部对象!

If you expect calculate_total to be pure,using .add

3️⃣ 多线程/并发环境下的数据竞争

# Thread A # Thread B # Result?tmp_a = global_usage.prompt tmp_b = global_usage.prompt
tmp_a += response_a.prompt tmp_b += response_b.prompt
global_usage.prompt = tmp_a global_usage.prompt = tmp_b
# 最终只保留后写入的值，前一次更新丢失。

from threading import Lock
lock = Lock
def safe_add:
with lock:
target.add