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'

具体问题：

我们是否必须初始化此特定实例的父级？如果是，应该如何使用super()。
这确实可以帮助我摆脱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'

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

1 个答案: