Python中实现+=操作符的动态类型处理策略

class StringBuilder:
    def __init__(self):
        """
        初始化StringBuilder对象，内部维护一个空字符串作为缓冲区。
        """
        self.body = ""

    def __iadd__(self, other):
        """
        处理 += 操作。
        将传入的other对象转换为字符串并追加到self.body。
        """
        self.body += str(other)
        return self # 必须返回self，以便链式操作

    def __str__(self):
        """
        定义对象的字符串表示，返回内部缓冲区的内容。
        """
        return self.body

# 示例用法
print("--- StringBuilder 模式示例 ---")
builder_a = StringBuilder()
builder_a += "Hello, "
builder_a += 100
builder_a += " World!"
print(f"构建结果: {builder_a}") # 输出: 构建结果: Hello, 100 World!

builder_b = StringBuilder()
builder_b += 200
builder_b += True # 布尔值也会被转为字符串
builder_b += [1, 2, 3] # 列表也会被转为字符串
print(f"构建结果: {builder_b}") # 输出: 构建结果: 200True[1, 2, 3]

class UniversalIdentity:
    def __add__(self, other):
        """
        当UniversalIdentity对象在左侧时，返回右侧的操作数。
        """
        return other

    def __radd__(self, other):
        """
        当UniversalIdentity对象在右侧时，返回左侧的操作数。
        """
        return other

# 示例用法
print("\n--- UniversalIdentity 模式示例 ---")

# 整数加法场景
a = UniversalIdentity()
print(f"初始a的类型: {type(a)}") # 输出: <class '__main__.UniversalIdentity'>
a += 100 # a现在变成了整数100
print(f"第一次操作后a的值: {a}, 类型: {type(a)}") # 输出: 100, <class 'int'>
a += 200 # 现在a是整数，执行整数加法
print(f"第二次操作后a的值: {a}, 类型: {type(a)}") # 输出: 300, <class 'int'>

# 字符串拼接场景
b = UniversalIdentity()
print(f"初始b的类型: {type(b)}") # 输出: <class '__main__.UniversalIdentity'>
b += "Hello, " # b现在变成了字符串"Hello, "
print(f"第一次操作后b的值: {b}, 类型: {type(b)}") # 输出: Hello, , <class 'str'>
b += "world!" # 现在b是字符串，执行字符串拼接
print(f"第二次操作后b的值: {b}, 类型: {type(b)}") # 输出: Hello, world!, <class 'str'>

# 混合类型操作（首次操作后，类型已确定，再次尝试不同类型会报错）
c = UniversalIdentity()
c += "Initial String" # c 变为字符串
# c += 100 # 这行代码会引发 TypeError，因为c现在是字符串，不能与整数相加
#