Python中多重继承中的动态super（）

我有这样的代码：

class X(object):
    def __init__(self):
        print('X')
    def Print(self):
        print('X')


class Y(object):
    def __init__(self):
        print('Y')
    def Print(self):
        print('Y')

class Z(X,Y):
    def __init__(self):
        print('Z')
        def Print(self):
            print('z')
            super().Print()

>>> z=Z()
Z
>>> z.Print()
X

它根据以下内容搜索

打印

Z.__mro__
(<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.Y'>, <class 'object'>)

---

但这不是动态的。有更好的方法吗？

以下是评论中讨论的选项摘要，供将来参考

1。更改继承顺序

class Z(Y, X):
    ...

这将确保在使用

super

（包括

Print

方法）时，Y的方法比X的方法更容易调用

2。显式调用Y的打印方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，该调用将显式调用Y的

Print

3。（不要使用）显式调用第二个父类的方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

---

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，它将显式调用第二个父类的

Print

（在本例中为Y）。

为了将来的参考目的，下面是注释中讨论的选项的摘要

1。更改继承顺序

class Z(Y, X):
    ...

这将确保在使用

super

（包括

Print

方法）时，Y的方法比X的方法更容易调用

2。显式调用Y的打印方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，该调用将显式调用Y的

Print

3。（不要使用）显式调用第二个父类的方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

---

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，它将显式调用第二个父类的

Print

（在本例中为Y）。

为了将来的参考目的，下面是注释中讨论的选项的摘要

1。更改继承顺序

class Z(Y, X):
    ...

这将确保在使用

super

（包括

Print

方法）时，Y的方法比X的方法更容易调用

2。显式调用Y的打印方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，该调用将显式调用Y的

Print

3。（不要使用）显式调用第二个父类的方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

---

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，它将显式调用第二个父类的

Print

（在本例中为Y）。

为了将来的参考目的，下面是注释中讨论的选项的摘要

1。更改继承顺序

class Z(Y, X):
    ...

这将确保在使用

super

（包括

Print

方法）时，Y的方法比X的方法更容易调用

2。显式调用Y的打印方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，该调用将显式调用Y的

Print

3。（不要使用）显式调用第二个父类的方法

class Z(X, Y):
    ...
    def Print(self):
        Y.Print(self)

class Z(X, Y):
    ...
    def Print(self):
        self.__class__.__bases__[1].Print()

---

这将确保在使用

super

时，X的方法被调用而不是Y的方法，除了一个调用，该调用将显式调用第二个父类的

Print

（在本例中为Y）。

我真的取决于您试图做什么。如果要确保同时调用

X.Print

和

Y.Print

，则需要在

X.Print

和

Y.Print

中添加超级调用，以及使用占位符打印方法的基类

如果要根据某些条件调用

X.Print

或

Y.Print

，则继承可能是错误的模型。您可能希望尝试使用合成。在这里，您编写的类不是从

X

或

Y

继承的，而是将它们的实例作为成员并知道如何使用它们。例如

遗产 产出：

Inheiritance
X
Y

Composition
X
Y

作文 产出：

Inheiritance
X
Y

Composition
X
Y

---

我真的要看你想做什么。如果要确保同时调用

X.Print

和

Y.Print

，则需要在

X.Print

和

Y.Print

中添加超级调用，以及使用占位符打印方法的基类

如果要根据某些条件调用

X.Print

或

Y.Print

，则继承可能是错误的模型。您可能希望尝试使用合成。在这里，您编写的类不是从

X

或

Y

继承的，而是将它们的实例作为成员并知道如何使用它们。例如

遗产 产出：

Inheiritance
X
Y

Composition
X
Y

作文 产出：

Inheiritance
X
Y

Composition
X
Y

---

我真的要看你想做什么。如果要确保同时调用

X.Print

和

Y.Print

，则需要在

X.Print

和

Y.Print

中添加超级调用，以及使用占位符打印方法的基类

如果要根据某些条件调用

X.Print

或

Y.Print

，则继承可能是错误的模型。您可能希望尝试使用合成。在这里，您编写的类不是从

X

或

Y

继承的，而是将它们的实例作为成员并知道如何使用它们。例如

遗产 产出：

Inheiritance
X
Y

Composition
X
Y

作文 产出：

Inheiritance
X
Y

Composition
X
Y

---

我真的要看你想做什么。如果要确保同时调用

X.Print

和

Y.Print

，则需要在

X.Print

和

Y.Print

中添加超级调用，以及使用占位符打印方法的基类

如果要调用

X.Print

或