特定于案例的混合？

Question

python 中有没有一种方法可以根据其他参数继承不同的 mixin 类？示例：

a = MyClass(case='A')  # spawns a class instance which inherits MixinA
b = MyClass(case='B')  # spawns a class instance which inherits MixinB

MixinA 和MixinB 都需要访问MyClass 的数据，但本身不托管任何数据。它们都定义了不同版本的some_method，self.some_method() 将在MyClass 中引用它们，但是根据传递给MyClass 的case-argument 执行不同的操作。

我不确定这是否有意义或是否有更好的设计。在我的应用程序中，性能是关键，因此在调用MixinA 和MixinB 定义的特定于案例的方法时，我想尽量避免开销。我在某处读到使用 mixins 会对此有好处。但也许有更好的方法。

Answer 1

正如我在评论中所说，这种事情可以使用元类来完成。以下是如何使用一个：

class MixinA:
    def some_method(self):
        print('In MixinA.some_method()')


class MixinB:
    def some_method(self):
        print('In MixinB.some_method()')


class MyMetaClass(type):
    mixins = {'A': MixinA, 'B': MixinB}  # Supported mix-ins.

    def __new__(cls, name, bases, classdict, **kwargs):
        case = kwargs.pop('case')
        mixin = cls.mixins.get(case)
        if not mixin:
            raise TypeError(f'Unknown mix-in case selector {case!r} specified')
        else:
            bases += (mixin,)

        return type.__new__(cls, name, bases, classdict, **kwargs)


class ClassA(metaclass=MyMetaClass, case='A'): ...
class ClassB(metaclass=MyMetaClass, case='B'): ...

a = ClassA()
b = ClassB()

a.some_method()  # -> In MixinA.some_method()
b.some_method()  # -> In MixinB.some_method()

---

它也可以在没有元类的情况下完成，至少有两种方法。一种方法是利用 Python 3.6 中添加的 __init_subclass__() 特殊方法。

class MixinA:
    def some_method(self):
        print('In MixinA.some_method()')


class MixinB:
    def some_method(self):
        print('In MixinB.some_method()')


class MyClass:

    mixins = {'A': MixinA, 'B': MixinB}  # Supported mix-ins.

    def __init_subclass__(cls, /, case, **kwargs):
        super().__init_subclass__(**kwargs)
        mixin = cls.mixins.get(case)
        if not mixin:
            raise TypeError(f'Unknown mix-in case selector {case!r} specified')
        else:
            cls.__bases__ += (mixin,)


class ClassA(MyClass, case='A'): ...
class ClassB(MyClass, case='B'): ...


a = ClassA()
b = ClassB()

a.some_method()  # -> In MixinA.some_method()
b.some_method()  # -> In MixinB.some_method()

---

另一种方法是通过普通函数，这是可能的，因为在 Python 中，类本身就是“first class objects”。

这是一个通过我命名为 mixer() 的函数执行此操作的示例：

class MixinA:
    def some_method(self):
        print('In MixinA.some_method()')


class MixinB:
    def some_method(self):
        print('In MixinB.some_method()')


class MyClass: ...


MIXINS = {'A': MixinA, 'B': MixinB}  # Supported mix-in classes.

def mixer(cls, *, case):
    mixin = MIXINS.get(case)
    if not mixin:
        raise TypeError(f'Unknown mix-in case selector {case!r} specified')

    mixed_classname = f'{cls.__name__}Plus{mixin.__name__}'
    return type(mixed_classname, (cls, mixin), {})


ClassA = mixer(MyClass, case='A')
ClassB = mixer(MyClass, case='B')

a = ClassA()
b = ClassB()

a.some_method()  # -> In MixinA.some_method()
b.some_method()  # -> In MixinB.some_method()

如您所见，所有这些技术都受到class factory pattern（或多或少我们在这里处理的内容）中常见的限制，即基类或元类方法或指定函数必须知道子类或混合类的所有可能性才能使它们可用。

虽然有一些解决方法可以缓解这种情况 — 至少在使用其他方法时，请参阅我对 Improper use of __new__ to generate classes? 的回答，它可以与“类工厂”模式一起使用。

但是，在这种特定情况下，您可以通过简单地将混合类 class 作为参数而不是 case 选择器来避免混合类的硬编码。