如果将基类的可选功能存储在次要类中，次要类是否应该继承基类？

Question

我知道标题可能有点混乱，所以让我举个例子。假设您有一个基类Base，它旨在被子类化以创建更复杂的对象。但是你也有可选的功能，你不需要每个子类，所以你把它放在一个二级类OptionalStuffA，它总是打算和基类一起子类化。你是否也应该让那个二级类成为Base的子类？

这当然只有当你有多个OptionalStuff 类并且你想以不同的方式组合它们时才相关，因为否则你不需要子类Base 和OptionalStuffA （并且只需OptionalStuffA 是Base 的子类，所以你只需要子类OptionalStuffA)。我知道如果 Base 不止一次继承自 MRO，这对 MRO 没有影响，但我不确定让所有次要类都继承自 Base 是否有任何缺点。

下面是一个示例场景。我还将QObject 类作为“第三方”令牌类添加，其功能对于辅助类之一的工作是必需的。我在哪里子类化它？下面的例子展示了我到目前为止是如何做到的，但我怀疑这是要走的路。

from PyQt5.QtCore import QObject

class Base:
    def __init__(self):
        self._basic_stuff = None

    def reset(self):
        self._basic_stuff = None


class OptionalStuffA:
    def __init__(self):
        super().__init__()
        self._optional_stuff_a = None

    def reset(self):
        if hasattr(super(), 'reset'):
            super().reset()
        self._optional_stuff_a = None

    def do_stuff_that_only_works_if_my_children_also_inherited_from_Base(self):
        self._basic_stuff = not None


class OptionalStuffB:
    def __init__(self):
        super().__init__()
        self._optional_stuff_b = None

    def reset(self):
        if hasattr(super(), 'reset'):
            super().reset()
        self._optional_stuff_b = None

    def do_stuff_that_only_works_if_my_children_also_inherited_from_QObject(self):
        print(self.objectName())


class ClassThatIsActuallyUsed(Base, OptionalStuffA, OptionalStuffB, QObject):
    def __init__(self):
        super().__init__()
        self._unique_stuff = None

    def reset(self):
        if hasattr(super(), 'reset'):
            super().reset()
        self._unique_stuff = None

Answer 1

我可以从您的问题中得到的是，您希望根据不同的条件具有不同的功能和属性，这听起来是使用 MetaClass 的好理由。 这完全取决于您的每个类有多复杂，以及您要构建什么，如果它是针对某些库或 API 的，那么如果使用得当，MetaClass 可以发挥作用。

MetaClass 非常适合根据某种条件向类添加函数和属性，您只需将所有子类函数添加到一个元类中，然后将该 MetaClass 添加到您的主类中

从哪里开始

您可以阅读有关 MetaClass 的信息here，或者您可以观看它here。 在您对 MetaClass 有了更好的了解后，请查看来自 here 和 here 的 Django ModelForm 的源代码，但在此之前先简要了解一下 Django Form 如何从外部工作，这将使您了解如何实现它.

这就是我的实现方式。

#You can also inherit it from other MetaClass but type has to be top of inheritance
class meta_class(type):
    # create class based on condition

    """
    msc: meta_class, behaves much like self (not exactly sure).
    name: name of the new class (ClassThatIsActuallyUsed).
    base: base of the new class (Base).
    attrs: attrs of the new class (Meta,...).
    """

    def __new__(mcs, name, bases, attrs):
        meta = attrs.get('Meta')
        if(meta.optionA){
            attrs['reset'] = resetA
        }if(meta.optionB){
            attrs['reset'] = resetB
        }if(meta.optionC){
            attrs['reset'] = resetC
        }
        if("QObject" in bases){
            attrs['do_stuff_that_only_works_if_my_children_also_inherited_from_QObject'] = functionA
        }
        return type(name, bases, attrs)


class Base(metaclass=meta_class): #you can also pass kwargs to metaclass here

    #define some common functions here
    class Meta:
        # Set default values here for the class
        optionA = False
        optionB = False
        optionC = False


class ClassThatIsActuallyUsed(Base):
    class Meta:
        optionA = True
        # optionB is False by default
        optionC = True

编辑：详细说明如何实现 MetaClass。

Answer 2

让我从另一种选择开始。在下面的示例中，Base.foo 方法是一个普通的标识函数，但选项可以覆盖它。

class Base:
    def foo(self, x):
        return x

class OptionDouble:
    def foo(self, x): 
        x *= 2  # preprocess example
        return super().foo(x)

class OptionHex:
    def foo(self, x): 
        result = super().foo(x)
        return hex(result)  # postprocess example

class Combined(OptionDouble, OptionHex, Base):
    pass

b = Base()
print(b.foo(10)) # 10

c = Combined()
print(c.foo(10)) # 2x10 = 20, as hex string: "0x14"

关键是在Combined的定义中的bases是Options在Base之前指定的：

class Combined(OptionDouble, OptionHex, Base):

在这个简单的例子中，从左到右读取类名 这是foo() 实现的排序顺序。 它被称为方法解析顺序（MRO）。 它还定义了 super() 在特定类中的确切含义，这很重要，因为 Options 是作为 super() 实现的包装器编写的

反之则不行：

class Combined(Base, OptionDouble, OptionHex):
    pass

c = Combined()
print(Combined.__mro__)
print(c.foo(10))  # 10, options not effective!

在这种情况下，首先调用Base 实现并直接返回结果。

您可以手动处理正确的基本顺序，也可以编写一个检查它的函数。它遍历 MRO 列表，一旦看到 Base，它就不允许在其后出现 Option。

class Base:
    def __init_subclass__(cls, *args, **kwargs):
        super().__init_subclass__(*args, **kwargs)
        base_seen = False
        for mr in cls.__mro__:
            if base_seen:
                if issubclass(mr, Option):
                    raise TypeError( f"The order of {cls.__name__} base classes is incorrect")
            elif mr is Base:
                base_seen = True

    def foo(self, x): 
        return x

class Option:
    pass

class OptionDouble(Option):
    ... 

class OptionHex(Option):
    ... 

---

现在回答您的评论。我写道@weettler 的方法可以简化。我的意思是这样的：

class Base:
    def __init_subclass__(cls, *args, **kwargs):
        super().__init_subclass__(*args, **kwargs)
        print("options for the class", cls.__name__)
        print('A', cls.optionA)
        print('B', cls.optionB)
        print('C', cls.optionC)
        # ... modify the class according to the options ...

        bases = cls.__bases__
        # ... check if QObject is present in bases ...

    # defaults
    optionA = False
    optionB = False
    optionC = False


class ClassThatIsActuallyUsed(Base):
    optionA = True
    optionC = True

此演示将打印：

options for the class ClassThatIsActuallyUsed
A True
B False
C True