Python3 通用继承层次结构

Question

这个问题是针对 python 3 的。假设我有一个像这样的类层次结构

class Base():
   def calculate():
       return 0

class Derived1(Base):
     def calculate():
        # some calculation

class Derived2(Base):
     def calculate():
        # some calculation

现在，我要做的是创建一个类，它定义了从派生类继承的通用方式，然后覆盖计算。换句话说，本着 C++ 模板的精神，避免复制子类代码，而是指定一种通用的子类化方式，然后能够将子类定义为一个衬垫，如下所示：

# pseudocode
class GenericDerived5(someGenericBase):
      def calculate():
          return super().calculate() + 5

class GenericDerived6(someGenericBase):
      def calculate():
          return super().calculate() + 5

class Derived5_1 = GenericDerived5(Derived1)
class Derived6_1 = GenericDerived6(Derived2)

（计算不是字面上这样，只是说明了继承结构的组合性质） 这段代码会是什么样子，我需要 python3 的相关工具是什么？我听说过元类，但不是很熟悉。

Answer 1

粗略地说，混合类是一个不打算直接实例化或充当独立基类的类（除了其他更专业的混合类），而是提供一个小的另一个类可以继承的功能子集。

在这种情况下，您的 GenericDerived 类是混合的完美示例：您没有创建 GenericDerived 的实例，但您可以从它们继承以将 calculate 方法添加到您自己的类中。

class Calculator:
    def calculate(self):
        return 9

class Calculator1(Calculator):
      def calculate(self):
          return super().calculate() + 5

class Calculator2(Calculator):
      def calculate(self):
          return super().calculate() + 10

class Base(Calculator):
    ...

请注意，Base 和 Calculator 层次结构彼此独立。 Base 除了提供其他功能之外，还提供基本的calculate 功能。 Base 的子类可以使用从Base 继承的calculate（通过Calculator），也可以从Calculator 的子类继承。

class Derived1(Base):
    ...

class Derived2(Base, Calculator1):
    ...

class Derived3(Base, Calculator2):
    ...

Answer 2

工厂函数体内的类定义

去那里最直接的方法是真的直接 - 但会感觉有点尴尬：

def derived_5_factory(Base):
    class GenericDerived5(Base):
        def calculate(self):
            return super().calculate() + 5
    return GenericDerived5

def derived_6_factory(Base):
    class GenericDerived6(Base):
        def calculate(self):
            return super().calculate() + 6
    return GenericDerived6

Derived5_1 = derived_5_factory(Derived1)
Derived6_2 = derived_6_factory(Derived2)

不方便的部分是您的类需要通用基础 必须在函数体内定义。这样，Python 重新执行 class 语句本身，具有不同的 Base，利用 在 Python 中的类是第一类对象。

这段代码的不便之处在于 (1) 类主体必须在函数内部，以及 (2) 它可能是完全错误的方法：

多重继承

如果您可以有一个额外的继承级别 - 这是您的示例的唯一区别，这是“正确”的方法。实际上，除了在其继承链中显式地包含以前的“GenericDerived”类之外，它们的行为将完全符合预期：

class Base():
   def calculate():
       return 0

class Derived1(Base):
     def calculate(self):
        return 1

class Derived2(Base):
     def calculate(self):
        return 2

#  mix-in bases:

class MixinDerived5(Base):
    def calculate(self):
        return super().calculate() + 5

class MixinDerived6(Base):
    def calculate(self):
        return super().calculate() + 6


Derived5_1 = type("Derived5_1", (MixinDerived5, Derived1), {})
Derived6_2 = type("Derived6_2", (MixinDerived6, Derived2), {})

这里，不是使用class 语句，而是使用type 调用创建一个动态类，同时使用需要动态基础的类和动态基础作为其bases 参数。就是这样 - Derived5_1 是一个完整的 Python 类，其继承链中包含两个 Bases

请注意，Python 的super() 将完全按照常识所期望的那样，在到达“Base”之前通过额外的中间“派生”类“重新路由”自身。所以，这是我在粘贴上面的代码后在交互式控制台上得到的：

In [6]: Derived5_1().calculate()                                                                 
Out[6]: 6

In [7]: Derived6_2().calculate()                                                                 
Out[7]: 8