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__s 负责设置实例值，并让它们提供方法实现。

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'