Herencia

El superpoder de la reutilización. Aprende a construir jerarquías de clases que compartan comportamiento sin duplicar código.

1. ¿Qué es la Herencia?

La herencia permite que una clase hija tome todos los atributos y métodos de una clase padre, pudiendo añadir los suyos propios o modificar los que hereda.

Piénsalo como la biología: un perro hereda de "mamífero" la capacidad de respirar y alimentar a sus crías, pero añade sus propias características (ladrar, raza, etc.).

Regla de oro: La herencia tiene sentido cuando la relación entre clases es de tipo "ES UN/A". Un AgenteDeVentas ES UN Agente. Un motor NO ES UN coche; hace parte de él (eso es composición).

2. Sintaxis: La Clase Padre entre Paréntesis

class AgenteIA:
    """Clase padre: comportamiento base de todos los agentes."""

    def __init__(self, nombre, modelo):
        self.nombre = nombre
        self.modelo = modelo

    def responder(self, pregunta):
        return f"[{self.nombre}]: No sé responder a '{pregunta}'"

    def info(self):
        return f"Agente: {self.nombre} | Modelo: {self.modelo}"


# La clase hija pone al padre entre paréntesis
class AgenteDeVentas(AgenteIA):
    """Agente especializado en ventas que hereda de AgenteIA."""

    def __init__(self, nombre, modelo, producto):
        super().__init__(nombre, modelo)  # Llama al __init__ del padre
        self.producto = producto          # Atributo propio del hijo

    # Sobreescribe (Override) el método del padre
    def responder(self, pregunta):
        return f"[{self.nombre} - Ventas]: ¿Interesado en {self.producto}? {pregunta}"

    # Método propio de esta clase hija
    def pitch(self):
        return f"¡{self.producto} es la mejor inversión que harás hoy!"


# Uso
base = AgenteIA("Atlas", "gpt-4o")
ventas = AgenteDeVentas("Nova", "claude-3-5", "Python Expert Course")

print(base.responder("¿Qué es ML?"))
print(ventas.responder("¿Por qué debería comprarte?"))
print(ventas.info())    # ¡Hereda el método del padre!
print(ventas.pitch())   # Método propio del hijo

3. super(): El Puente con el Padre

La función super() te da acceso a los métodos del padre desde el hijo. El uso más habitual es en __init__ para inicializar los atributos del padre antes de añadir los propios.

Con super()

def __init__(self, nombre, producto):
    super().__init__(nombre)  # Correcto
    self.producto = producto

Sin super() (no recomendado)

def __init__(self, nombre, producto):
    self.nombre = nombre  # Duplicas código del padre
    self.producto = producto

4. isinstance() y issubclass()

Python te da herramientas para verificar relaciones de herencia en tiempo de ejecución:

ventas = AgenteDeVentas("Nova", "claude-3-5", "Curso Python")

# ¿Es una instancia de AgenteDeVentas?
print(isinstance(ventas, AgenteDeVentas))  # True
# ¿Es también una instancia del padre?
print(isinstance(ventas, AgenteIA))        # True (por herencia!)

# ¿AgenteDeVentas es subclase de AgenteIA?
print(issubclass(AgenteDeVentas, AgenteIA))  # True

← Anterior: Métodos y Atributos Siguiente: ¿Cuándo Usar Clases? →

¿Listo para convertirte en un Maestro?

Potencia tu carrera con el Máster Completo: Python de la A a la Z. Domina Ciencia de Datos, ML y Deep Learning.

Ver ahora