python多重继承_Python多重继承

python多重继承

We are going to learn about python multiple inheritance today. Before starting multiple inheritance, I suggest you to skim through Python Class and Python Inheritance if you are not familiar with them.

今天我们将学习python多重继承。 在开始多重继承之前，如果您不熟悉Python类和Python继承 ，建议您先略读一下。

Python多重继承 (Python Multiple Inheritance)

The name says it all. One class extending more than one class is called multiple inheritance. This is one of the cool specialties of python which makes it more convenient than java in some cases (Java doesn’t support multiple inheritance). Java doesn’t have it because at times multiple inheritance may create some ambiguity. We shall talk about it later in this tutorial.

这个名字说明了一切。 一类扩展一个以上的类称为多重继承。 这是python的很酷的特色之一，在某些情况下，它比java更加方便（Java不支持多重继承）。 Java没有它，因为有时多重继承可能会产生一些歧义。 我们将在本教程的后面部分讨论它。

多重继承与多层次继承 (Multiple Inheritance vs Multi-level Inheritance)

It may seem confusing if you are familiar with multi-level inheritance before. The main difference between multiple and multi-level inheritance is that, in multi-level inheritance the superclass may also inherit another super class. And in this way, different levels of inheritance can be created among the classes.

如果您以前熟悉多级继承，可能会感到困惑。 多级继承和多级继承之间的主要区别在于，在多级继承中，超类还可以继承另一个超类。 这样，可以在类之间创建不同级别的继承。

Python多重继承范例 (Python Multiple Inheritance Example)

Let’s demonstrate a short example of python multiple inheritance.

让我们演示python多重继承的简短示例。

#definition of the class starts here  
class Person:  
    #defining constructor  
    def __init__(self, personName, personAge):  
        self.name = personName  
        self.age = personAge  
  
    #defining class methods  
    def showName(self):  
        print(self.name)  
  
    def showAge(self):  
        print(self.age)  
  
    #end of class definition  
  
# defining another class  
class Student: # Person is the  
    def __init__(self, studentId):  
        self.studentId = studentId  
  
    def getId(self):  
        return self.studentId  
  
  
class Resident(Person, Student): # extends both Person and Student class  
    def __init__(self, name, age, id):  
        Person.__init__(self, name, age)  
        Student.__init__(self, id)  
  
  
# Create an object of the subclass  
resident1 = Resident('John', 30, '102')  
resident1.showName()  
print(resident1.getId())

The classes Person and Student are superclass here and Resident is the subclass. The class Resident extends both Person and Student to inherit the properties of both classes. The example is easily understandable if you have the slightest knowledge of python class and python inheritance. This code yields the following output.

这里的Person和Student类是超类，Resident类是子类。 Resident类将Person和Student扩展为继承这两个类的属性。 如果您最了解python类和python继承，则该示例很容易理解。 此代码产生以下输出。

/usr/bin/python3.5 "/home/imtiaz/PycharmProjects/python tutorial - 1/multiple_inheritance.py"
John
102

Process finished with exit code 0

使用python多重继承解决冲突 (Resolving the Conflicts with python multiple inheritance)

Let’s have a look at another example.

让我们看另一个例子。

class A:  
    def __init__(self):  
        self.name = 'John'  
        self.age = 23  
  
    def getName(self):  
        return self.name  
  
  
class B:  
    def __init__(self):  
        self.name = 'Richard'  
        self.id = '32'  
  
    def getName(self):  
        return self.name  
  
  
class C(A, B):  
    def __init__(self):  
        A.__init__(self)  
        B.__init__(self)  
  
    def getName(self):  
        return self.name  
  
C1 = C()  
print(C1.getName())

Class C inherits both A and B. And both of them has an attribute ‘name’. From which class the value of name will be inherited in C? Is it from A or B? What do you think? Well, the output is:

C类继承了A和B。它们都具有属性“名称”。 name的值将从哪个类继承自C？ 是来自A还是来自B？ 你怎么看？ 好，输出为：

/usr/bin/python3.5 "/home/imtiaz/PycharmProjects/python tutorial - 1/multiple_inheritance.py"
Richard

Process finished with exit code 0

The name when printed is ‘Richard’ instead of ‘John’. Let’s try to understand what’s happening here. In the constructor of C, the first constructor called is the one of A. So, the value of name in C becomes same as the value of name in A. But after that, when the constructor of B is called, the value of name in C is overwritten by the value of name in B. So, the name attribute of C retains the value ‘Richard’ when printed. The result would be same even if we declared class C as:

打印时的名称是“ Richard”而不是“ John”。 让我们尝试了解这里发生的事情。 在C的构造函数中，第一个调用的构造函数是A的构造函数。因此，C中的name值与A中的name值相同。但是此后，当调用B的构造函数时，name的值C中的name被B中的name值覆盖。因此，C的name属性在打印时保留值'Richard'。 即使我们将C类声明为：

Class C(B, A):

The hierarchy becomes completely depended on the order of __init__() calls inside the subclass. To deal with it perfectly, there is a protocol named MRO (Method Resolution Order).

层次结构完全取决于子类内部__init __（）调用的顺序。 为了完美地处理它，有一个名为MRO（方法解析顺序）的协议。

方法解析顺序（MRO） (Method Resolution Order (MRO))

Let’s replace the previous code with a slightly modified version.

让我们用稍微修改的版本替换之前的代码。

class A:  
    def __init__(self):  
        super().__init__()  
        self.name = 'John'  
        self.age = 23  
  
    def getName(self):  
        return self.name  
  
  
class B:  
    def __init__(self):  
        super().__init__()  
        self.name = 'Richard'  
        self.id = '32'  
  
    def getName(self):  
        return self.name  
  
  
class C(A, B):  
    def __init__(self):  
        super().__init__()  
  
    def getName(self):  
        return self.name  
  
C1 = C()  
print(C1.getName())

Can you guess the output? Well, let’s find out.

你能猜出输出吗？ 好吧，让我们找出答案。

/usr/bin/python3.5 "/home/imtiaz/PycharmProjects/python tutorial - 1/multiple_inheritance.py"
John

Process finished with exit code 0

MRO works in a depth first left to right way. super() in the __init__ method indicates the class that is in the next hierarchy. At first the the super() of C indicates A. Then super in the constructor of A searches for its superclass. If it doesn’t find any, it executes the rest of the code and returns. So the order in which constructors are called here is:
C -> A -> B
If we call print(C.__mro__), then we can see the MRO traceroute.

MRO的工作深度从左到右。 __init__方法中的super（）指示下一个层次结构中的类。 首先，C的super（）表示A。然后，A的构造函数中的super搜索其超类。 如果找不到任何内容，它将执行其余代码并返回。 因此，此处调用构造函数的顺序为：
C-> A-> B
如果我们调用print（C .__ mro__），则可以看到MRO跟踪路由。

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

Once the constructor of A is called and attribute ‘name’ is accessed, it doesn’t access the attribute ‘name’ in B. A better understanding of MRO is a must in order to work with python multiple inheritance.

一旦调用了A的构造函数并访问了属性“名称”，它就不会访问B中的属性“名称”。要使用python多重继承，必须更好地理解MRO。

So this was it for python multiple inheritance, hope to come with more interesting features of python afterwards. Happy Coding!

因此，这就是python多重继承，希望以后再提供python的更多有趣功能。 编码愉快！

Reference: Python Doc

参考： Python文档

翻译自: https://www.journaldev.com/14623/python-multiple-inheritance

python多重继承