Herencia y Polimorfismo

Herencia: una clase hija reutiliza todo lo de su clase padre. class Gato(Animal) crea Gato como hija de Animal, y el gato ya tiene los métodos de Animal sin reescribirlos.

super() → llama a un método del padre desde la hija. Sirve sobre todo en __init__: super().__init__(color) deja que el padre guarde el color y la hija solo agrega lo suyo. Polimorfismo: varias clases tienen un método con el mismo nombre (area()) y cada una lo hace a su manera. Quien lo llama no necesita saber cuál es cuál.

Una clase abstracta (ABC, del módulo abc) es un molde que no se puede usar directamente. Con @abstractmethod marcas los métodos que cada hija está obligada a escribir. Si falta uno y haces Figura(), Python lanza TypeError. Herencia múltiple: una clase puede tener varios padres, class C(A, B). El MRO es el orden en que Python busca un método: primero C, luego A, luego B. Se ve con C.__mro__.

from abc import ABC, abstractmethod

# Clase abstracta (no se puede instanciar)
class Figura(ABC):
    def __init__(self, color="negro"):
        self.color = color
    
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimetro(self):
        pass
    
    def describir(self):
        return f"Figura {self.color}: área={self.area():.2f}"

class Circulo(Figura):
    def __init__(self, radio, color="rojo"):
        super().__init__(color)  # Llama __init__ del padre
        self.radio = radio
    
    def area(self):
        import math
        return math.pi * self.radio ** 2
    
    def perimetro(self):
        import math
        return 2 * math.pi * self.radio

class Rectangulo(Figura):
    def __init__(self, ancho, alto):
        super().__init__()
        self.ancho = ancho
        self.alto = alto
    
    def area(self):
        return self.ancho * self.alto
    
    def perimetro(self):
        return 2 * (self.ancho + self.alto)

figuras = [Circulo(5, "azul"), Rectangulo(4, 6)]
for f in figuras:
    print(f.describir())  # Polimorfismo