Python中实现通用对象包装类：直接赋值被包装对象__dict__方案的弊端探讨

这个思路看起来简单直接，但确实存在不少容易踩坑的弊端，我来逐一拆解：

1. 原对象与包装对象属性完全绑定，失去独立性 #

当你执行self.__dict__ = object.__dict__时，实际上是让包装类实例的属性字典直接引用原对象的属性字典，而非创建副本。这意味着：

• 原对象的属性发生变化时，包装对象的对应属性会立即同步；反过来，修改包装对象的属性也会直接修改原对象的属性。这种隐式双向绑定几乎肯定会导致意外的副作用。

举个例子：

city = City(100_000, 'M')
city_wrapper = Wrapper(city)

# 修改原对象属性
city.inhabitants = 200_000
print(city_wrapper.inhabitants)  # 输出 200000，而非初始的100000

# 修改包装对象属性
city_wrapper.mayor = 'New M'
print(city.mayor)  # 输出 'New M'，原对象被修改

2. 无法兼容使用__slots__的类 #

如果被包装的类定义了__slots__（用于节省内存，避免实例创建__dict__），那么该类的实例并不具备__dict__属性。此时执行object.__dict__会直接抛出AttributeError，导致包装类初始化失败。

示例：

class Person:
    __slots__ = ['name', 'age']
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 30)
wrapper = Wrapper(p)  # 报错：AttributeError: 'Person' object has no attribute '__dict__'

3. 包装类自身的方法/属性可能被原对象覆盖 #

Python中，实例的属性字典（__dict__）优先级高于类的属性/方法。如果原对象存在和包装类同名的属性，会直接覆盖包装类的方法或属性，导致意外行为。

比如：

class Wrapper:
    def __init__(self, obj):
        self.__dict__ = obj.__dict__
        self.new_attr = 'attr'
    
    def get_details(self):
        return f"Wrapper details: {self.new_attr}"

class TestObj:
    def __init__(self):
        self.get_details = "I'm an attribute from the original object"

test = TestObj()
wrapper = Wrapper(test)
print(wrapper.get_details)  # 输出 "I'm an attribute from the original object"，而非调用Wrapper的get_details方法

4. 无法继承原对象的类型特性与特殊方法 #

包装类实例的类型是Wrapper，而非原对象的类型，这会导致类型检查失效（比如isinstance(city_wrapper, City)返回False）。更关键的是，原对象的特殊方法（如__str__、__repr__、__eq__等）不会被包装类继承或代理——因为特殊方法是从类的命名空间查找，而非实例的__dict__。

示例：

class City:
    def __init__(self, inhabitants, mayor):
        self.inhabitants = inhabitants
        self.mayor = mayor
    
    def __str__(self):
        return f"City(inhabitants={self.inhabitants}, mayor={self.mayor})"

city = City(100_000, 'M')
print(city)  # 输出 "City(inhabitants=100000, mayor=M)"

city_wrapper = Wrapper(city)
print(city_wrapper)  # 输出 "<__main__.Wrapper object at 0x...>"，使用默认的对象字符串表示

5. 可变属性的浅引用风险 #

即使原对象没有使用__slots__，其__dict__中的可变属性（如列表、字典）是通过引用传递的。修改包装对象中的这些可变属性，会直接影响原对象，反之亦然，破坏了封装性。

示例：

class City:
    def __init__(self, inhabitants, mayor):
        self.inhabitants = inhabitants
        self.mayor = mayor
        self.districts = ['Downtown', 'Uptown']

city = City(100_000, 'M')
city_wrapper = Wrapper(city)

city_wrapper.districts.append('Suburb')
print(city.districts)  # 输出 ['Downtown', 'Uptown', 'Suburb']，原对象的属性被修改

内容的提问来源于stack exchange，提问作者lauberton