Saltearse al contenido

Herencia, MRO y super()

super() es el malentendido más caro de la programación orientada a objetos en Python. No significa «llama a mi padre»: significa «sigue en el MRO desde donde estoy». Esa diferencia es invisible con una jerarquía simple y decisiva cuando hay herencia múltiple, que es exactamente cuando nadie la entiende.

super() no sube un nivel: avanza al siguiente de una lista que se calcula al definir la clase.

Toda clase tiene un orden de resolución de métodos, calculado con el algoritmo C3 y accesible en Clase.__mro__:

class A: ...
class B(A): ...
class C(A): ...
class D(B, C): ...
D.__mro__ # (D, B, C, A, object)

D busca un método en ese orden. Si B y C lo definen, gana B; si sólo lo define C, se encuentra en C sin pasar por A.

El algoritmo garantiza dos cosas: que una clase aparezca antes que sus bases, y que el orden de las bases se respete. Cuando no puede satisfacer ambas, la definición falla con TypeError: Cannot create a consistent MRO.

class A:
def saluda(self):
return ["A"]
class B(A):
def saluda(self):
return super().saluda() + ["B"]
class C(A):
def saluda(self):
return super().saluda() + ["C"]
class D(B, C):
def saluda(self):
return super().saluda() + ["D"]
D().saluda() # ['A', 'C', 'B', 'D']

Fíjate en el resultado: D no llama a A directamente, y B no llama a A tampoco. Cada super() avanza desde su posición en el MRO de la instancia real (D). Por eso C se ejecuta entre A y B, y por eso la cooperación funciona.

Esa es la razón de que todos los métodos de una cadena cooperativa deban llamar a super(): si uno no lo hace, la cadena se corta y las clases posteriores del MRO nunca se ejecutan.

Un millón de llamadas
Forma Coste
super().metodo() 76 ns
Base.metodo(self) 57 ns

python mediciones/04-01-04-poo.py

super() cuesta un 33 % más porque resuelve el MRO en cada llamada. Es el precio de la cooperación, y merece la pena: sin él, la herencia múltiple no compone.

Un mixin es una clase que aporta comportamiento y no representa un «es un». El patrón es:

class Registrable:
def registrar(self):
self._registro.append(self)

Se pone antes en la lista de bases para que su método gane en el MRO, y no tiene __init__ propio o lo hace cooperativo. Las clases que lo usan ganan registrar() sin que la jerarquía principal lo sepa.

class Animal: ...
class Perro(Animal): ...
p = Perro()
type(p) is Perro # True
type(p) is Animal # False — el tipo exacto, no la jerarquía
isinstance(p, Animal) # True — respeta la herencia

type(x) is C exige el tipo exacto y rechaza subclases; isinstance(x, C) acepta la jerarquía, incluidas las subclases virtuales registradas con register. Casi siempre quieres isinstance.

La excepción: cuando una subclase cambia el contrato y no debe aceptarse. Un dict que hace algo distinto en __getitem__ no debería pasar un type(x) is dict. Es raro, y conviene documentarlo cuando ocurre, porque rompe la sustitución de Liskov que el resto del código espera.

  • Si la relación no es «es un». Un GestorDePedidos que hereda de Pedido para reutilizar campos es un error de modelado.
  • Si sólo quieres reutilizar código. Composición o funciones sueltas.
  • Si la jerarquía tiene más de dos niveles. Las jerarquías profundas son frágiles; el mixin o la composición se leen mejor.
  • Si la clase base tiene estado y la hija también. Los __init__ cooperativos se vuelven un rompecabezas.

Explica por qué este código imprime ['Base', 'Derecha', 'Izquierda', 'Hija'] y qué pasaría si Izquierda no llamara a super().

class Base:
def nombre(self): return ["Base"]
class Izquierda(Base):
def nombre(self): return super().nombre() + ["Izquierda"]
class Derecha(Base):
def nombre(self): return super().nombre() + ["Derecha"]
class Hija(Izquierda, Derecha):
def nombre(self): return super().nombre() + ["Hija"]
Solución

El MRO de Hija es (Hija, Izquierda, Derecha, Base, object). Hija.nombre llama a super(), que avanza a Izquierda; esta llama a su super(), que en el MRO de la instancia es Derecha; y Derecha llega a Base. Cada método añade su nombre al volver.

Si Izquierda.nombre no llamara a super(), la cadena se cortaría ahí: Derecha nunca se ejecutaría y el resultado sería ['Izquierda', 'Hija']. Es el síntoma típico de un mixin mal escrito: funciona en la clase sola y deja de funcionar al combinarla.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 14: Inheritance: For Better or for Worse.
  • CPython 3.13: Objects/typeobject.c (mro_implementation), Objects/superobject.c.
  • Mediciones: mediciones/04-01-04-poo.py.
  • 03 · Composición y delegación: la alternativa cuando la herencia no encaja.
  • 04 · ABCs y Protocol: herencia nominal frente a estructural.
  • 07 · Metaclases: quién construye el MRO.