Python中如何为单个对象动态添加Mixin而不影响同类其他对象

你当前的问题根源在于：修改obj.__class__.__bases__是直接改动了类的基类，而类是所有实例共享的，所以后续创建的实例都会继承修改后的基类，导致b1的属性被b2的修改覆盖。

下面提供两种可行的解决方案：

方案1：为每个实例创建动态子类 #

核心思路是不为原类修改基类，而是为需要Mixin的实例单独创建一个继承原类和目标Mixin的动态子类，然后将实例的__class__指向这个新类。每个实例的动态子类独立，互不影响。

修改后的元类代码：

class M(type):
    def __call__(cls, *args, **kwargs):
        obj = type.__call__(cls, *args, **kwargs)
        if hasattr(obj, "mixin"):
            # 生成唯一的动态子类名，避免冲突
            dynamic_cls_name = f"{cls.__name__}_With{obj.mixin.__name__}"
            # 创建动态子类，继承Mixin和原类（注意顺序，Mixin在前会优先覆盖同名属性）
            dynamic_cls = type(dynamic_cls_name, (obj.mixin, cls), {})
            # 将实例的类替换为动态子类
            obj.__class__ = dynamic_cls
        return obj

完整测试代码：

def external_function(some_value):
    if some_value == 'X':
        return MixinA
    elif some_value == 'Y':
        return MixinB
    raise ValueError("Invalid value")

class M(type):
    def __call__(cls, *args, **kwargs):
        obj = type.__call__(cls, *args, **kwargs)
        if hasattr(obj, "mixin"):
            dynamic_cls_name = f"{cls.__name__}_With{obj.mixin.__name__}"
            dynamic_cls = type(dynamic_cls_name, (obj.mixin, cls), {})
            obj.__class__ = dynamic_cls
        return obj

class MixinA:
    name = "A"
    attr1 = 100

class MixinB:
    name = "B"
    attr2 = 200

class A(metaclass=M):
    pass

class B(A):
    def __init__(self, some_value):
        self.mixin = external_function(some_value)

b1 = B('X')
print(b1.name, b1.__class__.__bases__)  # 输出: A (<class '__main__.MixinA'>, <class '__main__.A'>)

b2 = B('Y')
print(b2.name, b2.__class__.__bases__)  # 输出: B (<class '__main__.MixinB'>, <class '__main__.A'>)
print(b1.name, b1.__class__.__bases__)  # 输出: A (<class '__main__.MixinA'>, <class '__main__.A'>)

优点：完全模拟类继承的行为，支持方法重写、super()调用、属性优先级等完整的继承特性。
缺点：每个实例会生成一个新的类对象，若大量实例需要不同Mixin，会增加内存开销。

方案2：通过__getattr__代理Mixin属性访问 #

如果不需要严格的类继承关系，只是希望实例能访问Mixin的属性和方法，可以用__getattr__方法做代理。当实例访问自身没有的属性时，自动去绑定的Mixin中查找。

修改后的B类代码：

class B(A):
    def __init__(self, some_value):
        self.mixin = external_function(some_value)
        # 保存原有的__getattr__（如果存在）
        original_getattr = getattr(self, '__getattr__', None)
        
        # 定义实例专属的__getattr__
        def __getattr__(self, name):
            # 先尝试从Mixin获取属性/方法
            try:
                return getattr(self.mixin, name)
            except AttributeError:
                # 原__getattr__存在则调用，否则抛出异常
                if original_getattr is not None:
                    return original_getattr(self, name)
                raise
        
        # 将__getattr__绑定到当前实例（必须用__get__来绑定实例方法）
        self.__getattr__ = __getattr__.__get__(self, B)

完整测试代码：

def external_function(some_value):
    if some_value == 'X':
        return MixinA()  # 注意这里返回Mixin实例，不是类
    elif some_value == 'Y':
        return MixinB()
    raise ValueError("Invalid value")

class MixinA:
    name = "A"
    attr1 = 100

class MixinB:
    name = "B"
    attr2 = 200

class A:
    pass

class B(A):
    def __init__(self, some_value):
        self.mixin = external_function(some_value)
        original_getattr = getattr(self, '__getattr__', None)
        
        def __getattr__(self, name):
            try:
                return getattr(self.mixin, name)
            except AttributeError:
                if original_getattr is not None:
                    return original_getattr(self, name)
                raise
        
        self.__getattr__ = __getattr__.__get__(self, B)

b1 = B('X')
print(b1.name, type(b1))  # 输出: A <class '__main__.B'>
print(b1.attr1)  # 输出: 100

b2 = B('Y')
print(b2.name, type(b2))  # 输出: B <class '__main__.B'>
print(b2.attr2)  # 输出: 200
print(b1.name)  # 输出: A

优点：轻量，不会创建新类，内存开销小；Mixin可以是实例，支持带状态的Mixin。
缺点：仅处理属性访问，不支持类级别的特性（如isinstance判断、super()调用）；如果实例自身有同名属性，会优先使用自身的，不会触发Mixin的覆盖。

内容的提问来源于stack exchange，提问作者Ali Hasan Imam