Python 类继承设计：假装看起来像鸭子但不要嘎嘎叫

Question

我今天搜索了几个小时，但没有得到最近令人满意的明确答案。

假设我们有两个特定的类，它们既有重叠的方法名称，又有特定的单个方法。摆脱不必要的部分，让我们使用以下类。

class A():
def __init__(self, a_arg1, a_arg2):
self.a_arg1 = a_arg1
self.a_arg2 = a_arg2
@property
def gimme_1(self):
return self.a_arg1
@property
def gimme_2(self):
return self.a_arg2
@property
def prop(self):
return 'A'

还有

class B():
def __init__(self, b_arg1, b_arg2, b_arg3):
self.b_arg1 = b_arg1
self.b_arg2 = b_arg2
self.b_arg3 = b_arg3
@property
def give_1(self):
return self.b_arg1
@property
def give_2(self):
return self.b_arg2
@property
def give_3(self):
return self.b_arg3
@property
def prop(self):
return 'B'

我的目标是制作第三个类，它可以变成其中之一，即，它将具有这两个具有的所有方法，并且无论请求什么，它都表现得好像它是其中之一。这就是问题标题的动机。

class C(A, B):
def __init__(self, some_list):
self.some_list = some_list
@property
def gimme_1(self):
return self.some_list[0]
@property
def gimme_2(self):
return self.some_list[1]
@property
def give_1(self):
return self.some_list[0] ** 2
@property
def give_2(self):
return self.some_list[1] ** 2
@property
def give_3(self):
return self.some_list[2]
@property
def prop(self):
return 'C'

具体问题：

1. 我们是否必须初始化此特定实例的父项？如果是，应该如何使用super()。
2. 这真的可以帮助我摆脱isinstance(x, A)或isinstance(x, B)类型的查询。是否有任何最佳实践可以阻止这种使用？请注意，在我的情况下，Pythonic 鸭子类型与我真的不是那么相关。对于不同的计算算法，必然会发生很多分支。因此，我实际上将类用作数据捆绑容器，而不是将它们用作状态记录器。换句话说，它们的实例数据几乎没有变化。但是他们的数据在不同的分支中使用，具体取决于它们所在的类别。因此，获得正确的对象对我来说至关重要。

Answer 1

与其重写方法，为什么不利用继承的好处呢？ 让父__init__负责设置实例值，并让他们提供方法实现。

class C(A, B):
def __init__(self, arg1, arg2, arg3):
A.__init__(self, arg1, arg2)
B.__init__(self, arg1**2, arg2**2, arg3)
@property
def prop(self):
return 'C'