¿Cómo funcionan la herencia y super()?

Question

Accepted Answer

La **herencia** permite que una clase derive de otra, reutilizando y extendiendo su comportamiento. **`super()`** llama a los métodos de la clase padre. Python admite **herencia múltiple**, resuelta mediante el **MRO** (Method Resolution Order, orden de resolución de métodos).

## Herencia básica y super()

```python
class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "some sound"

class Dog(Animal):                  # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name)       # call the parent's __init__ (reuse its logic)
        self.breed = breed
    def speak(self):                 # OVERRIDE the parent method
        return "Woof"

d = Dog("Rex", "Lab")
d.name      # "Rex" (set by Animal via super())
d.speak()   # "Woof" (Dog's override)
```

`super()` permite que una subclase invoque el comportamiento del padre — esencial en `__init__` para ejecutar la configuración del padre, y para extender (no solo reemplazar) métodos sobrescritos.

## Extender vs sobrescribir por completo

```python
class Cat(Animal):
    def speak(self):
        base = super().speak()       # call parent, then ADD to it
        return f"{base} ... Meow"
```

## Herencia múltiple y el MRO

```python
class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):                       # inherits from BOTH B and C
    pass

D().greet()       # "B" — found via the MRO
D.__mro__         # (D, B, C, A, object) — the search order
```

Con herencia múltiple, Python busca los métodos en un orden linealizado específico — el **MRO**, calculado por el algoritmo C3. `D.__mro__` lo muestra; `super()` lo sigue. El MRO garantiza que cada clase se visite una sola vez y que los padres aparezcan después de los hijos, resolviendo el "problema del diamante" de forma predecible.

## super() sigue el MRO (no solo el padre literal)

```python
# in cooperative multiple inheritance, super() goes to the NEXT class in the MRO,
# not necessarily the "parent" — enabling mixins to chain correctly
```

## Por qué es importante

La herencia y `super()` son herramientas fundamentales de la POO para reutilizar y extender comportamiento, usadas a lo largo de los frameworks de Python (p. ej. heredar de modelos de Django, jerarquías de excepciones).

Entender `super()` (llamar a la lógica del padre, especialmente en `__init__`) y el **MRO** es especialmente importante en Python porque admite **herencia múltiple** — el MRO es lo que hace que la resolución de métodos y las cadenas de `super()` sean predecibles en jerarquías complejas y mixins.

Saber cómo funciona el MRO (y que `super()` lo sigue) previene la confusión en diseños en forma de diamante o basados en mixins que son comunes en bases de código Python reales.