Python: super you don't know

Getting started with super()

In class inheritance, if a method is redefined, the method will override the method of the same name of the parent class, but sometimes, we hope to realize the functions of the parent class at the same time. In this case, we It is necessary to call the method of the parent class, which can be achieved by using super, such as:

class Animal(object):
    def __init__(self, name):
        self.name = name
    def greet(self):
        print 'Hello, I am %s.' % self.name

class Dog(Animal):
    def greet(self):
        super(Dog, self).greet()   # Python3 可使用 super().greet()
        print 'WangWang...'

In the above, Animal is the parent class and Dog is the subclass. We redefined the greet method in the Dog class in order to realize the parent class at the same time. function, we call the method of the parent class again, see the following usage:

>>> dog = Dog('dog')
>>> dog.greet()
Hello, I am dog.
WangWang..

One of the most common uses of super can be said to be to call the initialization method of the parent class in the subclass, such as:

class Base(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

class A(Base):
    def __init__(self, a, b, c):
        super(A, self).__init__(a, b)  # Python3 可使用 super().__init__(a, b)
        self.c = c

Go deeper into super()

After reading the above usage, you may think that the use of super is very simple. It is nothing more than getting the parent class and calling the parent class’s method. In fact, in the above case, the class obtained by super happens to be the parent class, but in other cases, this is not necessarily the case. Super actually has no substantial relationship with the parent class.

Let us look at a slightly more complicated example involving multiple inheritance. The code is as follows:

class Base(object):
    def __init__(self):
        print "enter Base"
        print "leave Base"

class A(Base):
    def __init__(self):
        print "enter A"
        super(A, self).__init__()
        print "leave A"

class B(Base):
    def __init__(self):
        print "enter B"
        super(B, self).__init__()
        print "leave B"

class C(A, B):
    def __init__(self):
        print "enter C"
        super(C, self).__init__()
        print "leave C"

Among them, Base is the parent class, A and B inherit from Base, and C inherits from A and B. Their inheritance relationship is as follows:

      Base
      /  \
     /    \
    A      B
     \    /
      \  /
       C

Now, let’s take a look at the usage:

>>> c = C()
enter C
enter A
enter B
enter Base
leave Base
leave B
leave A
leave C

If you think super means “calling the method of the parent class”, then you are probably wondering why the next sentence of enter A is not enter Base but enter B. The reason is that super has no substantial relationship with the parent class. Now let us figure out how super works.

MRO list

In fact, for each class you define, Python will calculate a method resolution order (MRO) list, which represents the order of class inheritance. We can use the following method to obtain a method Class MRO list:

>>> C.mro()   # or C.__mro__ or C().__class__.mro()
[__main__.C, __main__.A, __main__.B, __main__.Base, object]

So how is the order of this MRO list determined? It is implemented through a C3 linearization algorithm. We will not delve into this algorithm here. Interested readers can learn about it themselves. To summarize, in general, the MRO list of a class is to merge the MRO lists of all parent classes, and follow the following three principles:

Subclasses are always in front of the parent class

If there are multiple parent classes, they will be placed in the list according to them The order in is checked

If there are two legal choices for the next class, the first parent class is selected

super principle

super works as follows:

def super(cls, inst):
    mro = inst.__class__.mro()
    return mro[mro.index(cls) + 1]

where, cls represents the class, inst represents the instance, The above code does two things:

Get the MRO list of inst

Find the index of cls in the current MRO list, and return its next class, which is mro[index + 1]

When you use super( cls, inst), Python will search for the next class of cls on the MRO list of inst.

Now, let’s go back to the previous example.

First look at the __init__ method of class C:

super(C, self).__init__()

The self here is the current instance of C, self.__class__.mro() The result is:

[__main__.C, __main__.A, __main__.B, __main__.Base, object]

You can see that the next class of C is A, so jump When A's __init__ is reached, enter A will be printed and the following line of code will be executed:

super(A, self).__init__()

Note that self here is also an instance of the current C. The MRO list is the same as above. Search for the next class of A in the MRO. , and found that it was B, so it jumped to B's __init__. At this time, enter B will be printed instead of enter Base.

The whole process is relatively clear. The key is to understand how super works, rather than taking it for granted that super calls the method of the parent class.

Summary

In fact, super has no substantial relationship with the parent class.

super(cls, inst) gets the next class of cls in the MRO list of inst.