初始化时如何动态继承？

Question

我有以下类结构：

class Base:
  def z(self):
    raise NotImplementedError()

class A(Base):
  def z(self):
    self._x()
    return self._z()

  def _x(self):
    # do stuff

  def _a(self):
    raise NotImplementedError()

class B(Base)
  def z(self):
    self._x()
    return self._z()

  def _x(self):
    # do stuff

  def _z(self):
    raise NotImplementedError()


class C(A):
  def _z(self):
    print(5)

class D(B):
  def _z(self):
    print(5)

C(A) 和D(B) 的实现完全一样，并不关心它继承自哪个类。概念上的区别仅在于A 和B（并且这些需要作为单独的类保存）。我不想为C 和D 编写单独的定义，而是希望能够根据在创建@ 实例 时提供的参数从A 或B 动态继承@ 987654331@/D（最终C和D必须同名）。

似乎元类可能有效，但我不确定如何将 __init__ 参数传递给元类 __new__（以及这是否真的有效）。我真的更喜欢能解决课堂内部问题的解决方案。

Answer 1

您是否考虑过使用组合而不是继承？似乎它更适合这个用例。详情见答案底部。

不管怎样，

• class C(A): ......... class C(B): ..... 甚至无效，只会导致定义 class C(B)。

• 我不确定元类能否在这方面为您提供帮助。我相信最好的方法是使用type，但我很想得到纠正。

使用type 的解决方案（并且可能滥用locals()，但这不是重点）

class A:
    def __init__(self):
        print('Inherited from A')

class B:
    def __init__(self):
        print('Inherited from B')

class_to_inherit = input()  # 'A' or 'B"

C = type('C', (locals()[class_to_inherit],), {})

C()

'A' or 'B'
>> A
Inherited from A

'A' or 'B'
>> B
Inherited from B

作曲

回到我回答开头的问题，您声明自己“C(A)”和“C(B)”的实现是相同的，它们实际上并不关心A 或@987654330 @。对我来说使用组合似乎更正确。然后你可以按照以下方式做一些事情：

class A: pass

class B: pass

class C:
    def __init__(self, obj):  # obj is either A or B instance, or A or B themselves
        self.obj = obj  # or self.obj = obj() if obj is A or B themselves

c = C(A())  #  or c = C(A) 

如果C 应该公开与A 或B 相同的API，C 可以覆盖__getattr__：

class A:
    def foo(self):
        print('foo')

class C:
    def __init__(self, obj):
        self.obj = obj

    def __getattr__(self, item):
        return getattr(self.obj, item)

C(A()).foo()
# foo