What is indirection in multiple inheritance in Python?

Using super()has two advantages:

1. You avoid explicitly putting the name of the parent class. This gives you more flexibility in making the code for those functions independent of the class they inherit from.

   In other words, following your example, if you decide to change your mind and make Empleado, instead of inheriting Personafrom another class, let's say Trabajador, the code you put as the second example would stop working correctly, since it would still be calling the constructor of Personainstead of the of Trabajador. For it to work correctly you would have to change Personato worker in all the methods of the class Empleado(it does not have to appear only in __init__(), it is common that other methods are also extended in derived classes).

   Using super()you don't need to touch anything in the class Empleado, except for the declaration of the class itself classto indicate that it now inherits from Trabajador.

2. The resolution of super()which class to use happens at run time and not at compile time. This allows flexible mechanisms especially in the face of multiple inheritance.

To clarify point 2, which is the most complex, imagine that we have your example classes implemented:

class Persona:
  def __init__(self, nombre, apellido, edad, sexo):
    print("Inicializando Persona")
    self.nombre = nombre
    self.apellido = apellido
    self.sexo = sexo
    self.edad = edad

class Empleado(Persona):
  def __init__(self, nombre, apellido, edad, sexo, salario):
    print("Inicializando Empleado")
    super().__init__(nombre, apellido, edad, sexo)
    self.salario = salario

But now we want to create a new type of "Person" that is an artificial intelligence, which, in addition to not having an age or gender (so it will ignore what it receives in those two parameters), will have an attribute is_a_bot.

class InteligenciaArtificial(Persona):
  def __init__(self, nombre, apellido, edad, sexo):
    print("Inicializando IA")
    super().__init__(nombre, apellido, edad=None, sexo=None)
    self.is_a_bot = True

Well, now comes the fun of using super(). We can create a new class that is a EmpleadoAIthat inherits from both Empleadoand InteligenciaArtificial, by simply writing:

class EmpleadoAI(Empleado, InteligenciaArtificial):
  pass

The class body is empty ( pass), so its method __init__()is not actually written, but is inherited from Empleado. But when Empleadointernally you do super().__init__(), now your "super" will no longer be Persona, but InteligenciaArtificial, because we have put this class "in the middle" between Empleadoand InteligenciaArtificial.

The inheritance structure is of the "diamond" type:

But Python has that graph "serialized" in what is called the MRO ( Method Resolution Order ) that depends on the order of declaration of the classes in the case of multiple inheritance. Because it EmpleadoAIdeclares to inherit first from Empleadoand after InteligenciaArtificial, the MRO will have these two classes in that order (and after both it will have Persona).

You can check the MRO of a class:

>>> EmpleadoAI.__mro__
(__main__.EmpleadoAI,
 __main__.Empleado,
 __main__.InteligenciaArtificial,
 __main__.Persona,
 object)

That is, when trying to invoke a method of EmpleadoAI, it will look first in EmpleadoAI, and if it's not there, Empleadothen in InteligenciaArtificial, and finally in Persona(and if not in the class objectthey all inherit from if they don't declare another).

Being super()evaluated at runtime, this allows you to know if it Empleado.__init__()was called when instantiating an object Empleado(in which case it super()would resolve to Persona), or if it is being called via another super()from EmpleadoAI(in which case it would resolve to InteligenciaArtificial).

An example of object creation and the output it produces will clarify the behavior:

>>> e = EmpleadoAI("Cortana", "Microsoft", edad=100, sexo="Femenino", salario=2000)
Inicializando Empleado
Inicializando AI
Inicializando Persona

We see the order in which the constructors are called and how the InteligenciaArtificialone of has "sneaked" between Empleadoand Persona. We can also see that the attributes finally initialized in this special employee are those of an AI:

>>> vars(e)
{'nombre': 'Cortana',
 'apellido': 'Microsoft',
 'edad': None,
 'sexo': None,
 'salario': 2000,
 'is_a_bot': True}

First of all, let me tell you that, as a style rule , in python the names of the classes are capitalized : Persona, Empleado.

The operation of inheritance is based on the mechanism that python has to search for inherited attributes between the parent classes, related to the so-called Descriptor Protocol ^1 . Thanks to this mechanism, multiple inheritance works , metaclasses , properties and abstract classes , to name a few language features.

Between put:

class Empleado(Persona):
    def __init__(self, nombre, apellido, edad, sexo, salario):
        super().__init__(nombre, apellido,edad, sexo)

Y

class Empleado(Persona):
    def __init__(self, nombre, apellido, edad, sexo, salario):
        Persona.__init__(self,nombre, apellido,edad, sexo)

they differ in who is responsible for looking up the method __init__among the ancestors . With Persona.__init__(self,...)you are forcing the class to Personause the instance selfand initialize it. With super().__init__(...)you are telling the instance selfto be initialized as an instance of the parent class (which doesn't have to be Persona, as we'll see later).

To see it better, we are going to add more classes, and we will stop Empleadodirectly invoking Persona, without super():

class Conductor(Persona):
    def __init__(self, ....):
        super().__init__(...)

class Viajante(Empleado, Conductor):
    def __init__(self, ....)
        super().__init__(...)

The first observation is that in Viajantea single line with is enough super()for the instance initialization to work correctly, as well Empleadoas Conductor. How is this achieved?

The trick is called the MRO Algorithm . Without going into details, this algorithm applies certain criteria by which the entire class hierarchy is linearly ordered. In practice, we turn a multiple hierarchy into a single hierarchy , making it easier to search.

Let's look at an example:

pedro = Viajante(...)

The result of the MRO algorithm is stored in the class attribute __mro__. If we look in Viajante.__mro__we see the tuple: (Viajante, Empleado, Conductor, Persona, object). This will be the search order that the instance will use pedro, starting with Viajanteand ending with object.

Using super()we are propagating the initialization up the class hierarchy. super()gets the type attribute __mro__of the instance and checks it against the class from which it is invoked. This way it knows which is the next class in the sequence to pass the call to.

Thus, the super()en Viajantesees that the next class in the chain is Empleado. In Empleado, super()you would see that the following is Conductor, from there to Persona, and from there to object.

But in the class Empleadowe had left a direct call to Persona.__init__, without using super(), so the class Conductorthat corresponded to MRO would be skipped.

When you programmed Empleadoit possibly works the same using super()or making the direct call. But if some other programmer wanted to use your code, they might find that multiple inheritance doesn't work as it should.

I have tried to summarize enough. It is not necessary to know the inner workings of the MRO algorithm to work with multiple inheritance. However, you may run into the error that the MRO algorithm is not capable of serializing a certain class hierarchy. Unfortunately, these errors are not easy to solve, even if you try to understand the algorithm.