Tutorial Python: Herencia

Conceptos básicos

La herencia es uno de los pilares fundamentales de la programación orientada a objetos que permite crear nuevas clases basadas en clases existentes. Este mecanismo facilita la reutilización de código y establece relaciones jerárquicas entre clases.

En Python, la herencia permite que una clase (llamada clase hija o subclase) adquiera los atributos y métodos de otra clase (llamada clase padre o superclase). Esta relación se conoce como relación "es un", donde la clase hija representa una versión especializada de la clase padre.

Sintaxis básica

La sintaxis para crear una clase que hereda de otra es muy sencilla en Python:

class ClasePadre:
    # Atributos y métodos de la clase padre
    pass

class ClaseHija(ClasePadre):
    # Atributos y métodos de la clase hija
    # Más los heredados de la clase padre
    pass

El nombre de la clase padre se coloca entre paréntesis después del nombre de la clase hija. Esto indica a Python que la clase hija debe heredar todas las características de la clase padre.

Ejemplo práctico

Veamos un ejemplo sencillo con una jerarquía de vehículos:

class Vehiculo:
    def __init__(self, marca, modelo, año):
        self.marca = marca
        self.modelo = modelo
        self.año = año
        self.encendido = False
    
    def encender(self):
        self.encendido = True
        return f"{self.marca} {self.modelo} encendido"
    
    def apagar(self):
        self.encendido = False
        return f"{self.marca} {self.modelo} apagado"
    
    def describir(self):
        return f"Vehículo: {self.marca} {self.modelo} del año {self.año}"


class Automovil(Vehiculo):
    def __init__(self, marca, modelo, año, puertas):
        # Inicializamos la parte del padre
        Vehiculo.__init__(self, marca, modelo, año)
        # Añadimos atributos específicos
        self.puertas = puertas
    
    def describir(self):
        return f"Automóvil: {self.marca} {self.modelo} del año {self.año} con {self.puertas} puertas"

En este ejemplo:

1. Vehiculo es la clase padre que define atributos y comportamientos comunes a todos los vehículos.
2. Automovil es la clase hija que hereda de Vehiculo y añade características específicas (número de puertas).
3. La clase hija puede acceder a todos los atributos y métodos de la clase padre.

Podemos crear instancias y usar los métodos heredados:

# Creamos un automóvil
mi_auto = Automovil("Toyota", "Corolla", 2023, 4)

# Usamos métodos heredados
print(mi_auto.encender())  # Toyota Corolla encendido
print(mi_auto.describir())  # Automóvil: Toyota Corolla del año 2023 con 4 puertas

Herencia múltiple

A diferencia de otros lenguajes como Java, Python permite la herencia múltiple, donde una clase puede heredar de varias clases padre:

class ClaseA:
    def metodo_a(self):
        return "Método de ClaseA"

class ClaseB:
    def metodo_b(self):
        return "Método de ClaseB"

class ClaseC(ClaseA, ClaseB):
    def metodo_c(self):
        return "Método de ClaseC"

La clase ClaseC hereda todos los métodos y atributos tanto de ClaseA como de ClaseB. Sin embargo, la herencia múltiple puede introducir complejidad y ambigüedad, por lo que debe usarse con precaución.

Verificación de herencia

Python proporciona funciones útiles para verificar las relaciones de herencia:

• isinstance(): Comprueba si un objeto es instancia de una clase.
• issubclass(): Comprueba si una clase es subclase de otra.

mi_auto = Automovil("Toyota", "Corolla", 2023, 4)

# Verificamos instancias
print(isinstance(mi_auto, Automovil))  # True
print(isinstance(mi_auto, Vehiculo))   # True - también es instancia de la clase padre

# Verificamos relaciones de clases
print(issubclass(Automovil, Vehiculo))  # True
print(issubclass(Vehiculo, Automovil))  # False - la relación es unidireccional

Método de resolución de orden (MRO)

Cuando trabajamos con herencia, especialmente herencia múltiple, Python utiliza un algoritmo de resolución de orden para determinar qué método o atributo usar cuando hay nombres duplicados. Podemos ver este orden usando el atributo __mro__ o el método mro():

print(Automovil.__mro__)
# Muestra el orden en que Python busca métodos: primero en Automovil, luego en Vehiculo, y finalmente en object

Herencia y constructores

En nuestro ejemplo anterior, usamos Vehiculo.__init__(self, marca, modelo, año) para llamar al constructor de la clase padre. Sin embargo, Python proporciona una forma más elegante de hacer esto usando super(), que veremos en la siguiente sección.

Ventajas de la herencia

• Reutilización de código: Evita duplicar código al compartir funcionalidad común.
• Extensibilidad: Facilita extender la funcionalidad existente sin modificar el código original.
• Jerarquías naturales: Permite modelar relaciones del mundo real de manera intuitiva.
• Polimorfismo: Permite tratar objetos de diferentes clases de manera uniforme si comparten una clase base común.

Consideraciones importantes

• La herencia debe usarse cuando existe una verdadera relación "es un". Por ejemplo, un automóvil es un vehículo.
• Evita crear jerarquías de herencia demasiado profundas, ya que pueden volverse difíciles de entender y mantener.
• Prefiere la composición sobre la herencia cuando la relación es más del tipo "tiene un" en lugar de "es un".

La herencia es una herramienta poderosa, pero debe usarse con criterio. En las siguientes secciones, exploraremos cómo usar super() para una gestión más elegante de la herencia y cómo implementar la sobreescritura de métodos para personalizar el comportamiento heredado.

Super()

La función super() es una herramienta fundamental en Python para trabajar con herencia de manera elegante y mantenible. Proporciona una forma de acceder a los métodos y propiedades de la clase padre sin tener que nombrarla explícitamente, lo que hace que el código sea más flexible y menos propenso a errores.

Uso básico de super()

En el contexto de la herencia, super() nos permite llamar a métodos de la clase padre desde la clase hija. Su uso más común es en el método __init__ para asegurar que la inicialización de la clase padre se realice correctamente:

class Vehiculo:
    def __init__(self, marca, modelo, año):
        self.marca = marca
        self.modelo = modelo
        self.año = año
        
class Automovil(Vehiculo):
    def __init__(self, marca, modelo, año, puertas):
        # Llamamos al constructor de la clase padre
        super().__init__(marca, modelo, año)
        # Añadimos atributos específicos
        self.puertas = puertas

En este ejemplo, super().__init__(marca, modelo, año) llama al método __init__ de la clase padre Vehiculo, evitando tener que escribir Vehiculo.__init__(self, marca, modelo, año).

Ventajas de usar super()

El uso de super() ofrece varias ventajas importantes:

• Desacoplamiento: No necesitamos mencionar explícitamente el nombre de la clase padre, lo que hace el código más mantenible.
• Compatibilidad con herencia múltiple: Funciona correctamente con el mecanismo de resolución de métodos (MRO) de Python.
• Adaptabilidad a cambios: Si cambiamos la jerarquía de clases, no necesitamos modificar las llamadas a los métodos de la clase padre.

Super() en métodos regulares

Aunque el uso más común de super() es en el constructor, también podemos utilizarlo para llamar a cualquier método de la clase padre:

class Vehiculo:
    def describir(self):
        return f"Vehículo: {self.marca} {self.modelo} ({self.año})"
        
class Automovil(Vehiculo):
    def describir(self):
        # Obtenemos la descripción básica del vehículo
        descripcion_base = super().describir()
        # Añadimos información específica del automóvil
        return f"{descripcion_base} - {self.puertas} puertas"

En este caso, la clase Automovil extiende el comportamiento del método describir() de la clase Vehiculo, añadiendo información sobre el número de puertas.

Sintaxis de super() en Python 3

En Python 3, la sintaxis simplificada de super() (sin argumentos) es suficiente en la mayoría de los casos:

super().__init__(args)  # Python 3

Esta forma abreviada es equivalente a:

super(TipoActual, self).__init__(args)

Donde TipoActual es la clase en la que se está utilizando super() y self es la instancia actual.

Super() en herencia múltiple

Uno de los aspectos más potentes de super() es su comportamiento en escenarios de herencia múltiple. Python utiliza el algoritmo C3 para determinar el orden de resolución de métodos (MRO), y super() respeta este orden:

class Motor:
    def arrancar(self):
        return "Motor arrancado"
        
class Electrico:
    def arrancar(self):
        return "Sistema eléctrico iniciado"
        
class VehiculoElectrico(Vehiculo, Electrico):
    def arrancar(self):
        # Llama al método arrancar del siguiente en el MRO
        return f"{super().arrancar()} - Vehículo listo"

Para entender a qué método llamará super().arrancar(), podemos examinar el MRO:

print(VehiculoElectrico.__mro__)
# (<class '__main__.VehiculoElectrico'>, <class '__main__.Vehiculo'>, 
#  <class '__main__.Electrico'>, <class 'object'>)

En este caso, super().arrancar() llamará al método arrancar() de Vehiculo, ya que es el siguiente en el MRO después de VehiculoElectrico.

Ejemplo práctico completo

Veamos un ejemplo más elaborado que muestra cómo super() facilita la creación de jerarquías de clases mantenibles:

class Animal:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
    
    def hacer_sonido(self):
        return "Algún sonido animal"
    
    def info(self):
        return f"{self.nombre}, {self.edad} años"

class Perro(Animal):
    def __init__(self, nombre, edad, raza):
        super().__init__(nombre, edad)
        self.raza = raza
    
    def hacer_sonido(self):
        return "Guau guau"
    
    def info(self):
        # Combinamos la información básica con detalles específicos
        info_basica = super().info()
        return f"{info_basica} - Perro {self.raza}"

class PerroGuia(Perro):
    def __init__(self, nombre, edad, raza, persona_asistida):
        super().__init__(nombre, edad, raza)
        self.persona_asistida = persona_asistida
    
    def info(self):
        # Reutilizamos la implementación de la clase padre
        info_perro = super().info()
        return f"{info_perro} - Asiste a {self.persona_asistida}"

Podemos ver cómo cada nivel de la jerarquía extiende el comportamiento del nivel anterior sin duplicar código:

# Creamos instancias
animal = Animal("Criatura", 5)
perro = Perro("Rex", 3, "Pastor Alemán")
perro_guia = PerroGuia("Max", 4, "Labrador", "Ana")

# Mostramos información
print(animal.info())      # Criatura, 5 años
print(perro.info())       # Rex, 3 años - Perro Pastor Alemán
print(perro_guia.info())  # Max, 4 años - Perro Labrador - Asiste a Ana

Consideraciones importantes

• No uses super() fuera de una clase: La función super() solo funciona dentro de métodos de clase.
• Coherencia en las firmas de métodos: Asegúrate de que los métodos sobrescritos acepten los mismos parámetros que los métodos de la clase padre, o utiliza parámetros con valores predeterminados o *args y **kwargs para mayor flexibilidad.
• Orden de inicialización: En herencia múltiple, es crucial entender el MRO para predecir el comportamiento de super().

Patrones comunes con super()

Existen algunos patrones de diseño comunes al utilizar super():

• Extensión de comportamiento: Llamar al método de la clase padre y luego añadir funcionalidad adicional.

def metodo(self, arg):
    resultado = super().metodo(arg)
    # Añadir comportamiento adicional
    return resultado_modificado

• Pre-procesamiento: Realizar acciones antes de llamar al método de la clase padre.

def metodo(self, arg):
    # Pre-procesar argumentos
    arg_modificado = transformar(arg)
    return super().metodo(arg_modificado)

• Delegación condicional: Decidir si llamar o no al método de la clase padre.

def metodo(self, arg):
    if condicion:
        return super().metodo(arg)
    else:
        return resultado_alternativo

La función super() es una herramienta esencial para implementar herencia de manera limpia y mantenible en Python, permitiendo crear jerarquías de clases flexibles y robustas sin duplicar código.

Sobreescritura

La sobreescritura de métodos es una técnica fundamental en la programación orientada a objetos que permite a una clase hija proporcionar una implementación específica de un método ya definido en su clase padre. Este mecanismo es esencial para implementar el polimorfismo y personalizar el comportamiento heredado.

En Python, sobreescribir un método es tan simple como definir en la clase hija un método con el mismo nombre que existe en la clase padre. Cuando se llama a este método en una instancia de la clase hija, se ejecutará la versión de la clase hija en lugar de la versión de la clase padre.

Implementación básica

Para sobreescribir un método, simplemente definimos un método con el mismo nombre en la clase hija:

class Animal:
    def hablar(self):
        return "El animal hace un sonido"

class Gato(Animal):
    def hablar(self):
        return "Miau"

En este ejemplo, la clase Gato sobreescribe el método hablar() de la clase Animal. Cuando llamamos a este método en una instancia de Gato, obtendremos "Miau" en lugar del mensaje genérico.

mi_animal = Animal()
mi_gato = Gato()

print(mi_animal.hablar())  # El animal hace un sonido
print(mi_gato.hablar())    # Miau

Cuándo sobreescribir métodos

La sobreescritura es apropiada en varios escenarios:

• Cuando la implementación de la clase padre es demasiado genérica y necesitamos una versión más específica
• Cuando queremos modificar completamente el comportamiento heredado
• Cuando necesitamos adaptar un método para que funcione con atributos específicos de la clase hija

Sobreescritura del método init

Un caso común de sobreescritura es el del constructor __init__. Cuando una clase hija necesita inicializar atributos adicionales, debe sobreescribir el constructor de la clase padre:

class Vehiculo:
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo
        self.en_marcha = False
    
    def arrancar(self):
        self.en_marcha = True
        return f"{self.marca} {self.modelo} arrancado"

class Motocicleta(Vehiculo):
    def __init__(self, marca, modelo, cilindrada):
        super().__init__(marca, modelo)
        self.cilindrada = cilindrada
    
    def arrancar(self):
        return f"{super().arrancar()} - {self.cilindrada}cc rugiendo"

En este ejemplo, Motocicleta sobreescribe tanto el método __init__ como el método arrancar. Observa cómo utilizamos super() para mantener la funcionalidad base y luego la extendemos.

Sobreescritura completa vs. extensión

Existen dos enfoques principales para sobreescribir métodos:

• Sobreescritura completa: Reemplazar totalmente la implementación del padre

class Pez(Animal):
    def hablar(self):
        return "Glub glub"  # Implementación completamente nueva

• Extensión del comportamiento: Utilizar la implementación del padre y añadir funcionalidad

class Perro(Animal):
    def hablar(self):
        sonido_base = super().hablar()
        return f"{sonido_base}, específicamente: Guau"

La elección entre estos enfoques depende de si necesitamos preservar parte del comportamiento original o reemplazarlo por completo.

Sobreescritura de métodos especiales

Python tiene métodos especiales (también llamados métodos dunder o mágicos) que podemos sobreescribir para personalizar el comportamiento de nuestras clases:

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"({self.x}, {self.y})"
    
class Punto3D(Punto):
    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z
    
    def __str__(self):
        return f"({self.x}, {self.y}, {self.z})"

En este ejemplo, Punto3D sobreescribe tanto __init__ como __str__ para adaptarlos a su naturaleza tridimensional.

Ejemplo práctico: Sistema de formas geométricas

Veamos un ejemplo más completo que muestra cómo la sobreescritura permite implementar comportamientos específicos en una jerarquía de clases:

class Forma:
    def __init__(self, color="negro"):
        self.color = color
    
    def area(self):
        # Método base que será sobreescrito
        return 0
    
    def describir(self):
        return f"Forma de color {self.color} con área {self.area()} unidades cuadradas"

class Circulo(Forma):
    def __init__(self, radio, color="rojo"):
        super().__init__(color)
        self.radio = radio
    
    def area(self):
        import math
        return math.pi * self.radio ** 2
    
    def describir(self):
        return f"Círculo {self.color} de radio {self.radio} con área {self.area():.2f} unidades cuadradas"

class Rectangulo(Forma):
    def __init__(self, ancho, alto, color="azul"):
        super().__init__(color)
        self.ancho = ancho
        self.alto = alto
    
    def area(self):
        return self.ancho * self.alto

Podemos usar estas clases de la siguiente manera:

# Creamos instancias
forma = Forma()
circulo = Circulo(5)
rectangulo = Rectangulo(4, 6, "verde")

# Mostramos descripciones
print(forma.describir())      # Forma de color negro con área 0 unidades cuadradas
print(circulo.describir())    # Círculo rojo de radio 5 con área 78.54 unidades cuadradas
print(rectangulo.describir()) # Forma de color verde con área 24 unidades cuadradas

Observa que Rectangulo sobreescribe area() pero utiliza la implementación de describir() de la clase Forma. Esto demuestra que no es necesario sobreescribir todos los métodos, solo aquellos que necesitan un comportamiento específico.

Polimorfismo a través de la sobreescritura

La sobreescritura es la base del polimorfismo, que permite tratar objetos de diferentes clases de manera uniforme si comparten una clase base común:

def imprimir_area(forma):
    print(f"El área es: {forma.area()}")

# Podemos pasar cualquier objeto que herede de Forma
imprimir_area(circulo)      # El área es: 78.53981633974483
imprimir_area(rectangulo)   # El área es: 24

La función imprimir_area() funciona con cualquier objeto que tenga un método area(), independientemente de su implementación específica.

Buenas prácticas para la sobreescritura

• Mantén la firma del método: Los parámetros del método sobreescrito deben ser compatibles con los del método original.
• Respeta el contrato: El método sobreescrito debe cumplir con el mismo propósito general que el método original.
• Documenta los cambios: Si el comportamiento cambia significativamente, documéntalo claramente.
• Usa super() cuando sea apropiado: Si necesitas extender el comportamiento en lugar de reemplazarlo completamente.

class Ave(Animal):
    def hablar(self):
        # Documentamos el cambio de comportamiento
        """Produce el sonido característico del ave."""
        return "Pío pío"

Sobreescritura vs. sobrecarga

Es importante distinguir entre sobreescritura (override) y sobrecarga (overload):

• La sobreescritura implica redefinir un método en una clase hija manteniendo la misma firma.
• La sobrecarga implica definir múltiples versiones de un método con diferentes parámetros.

Python no admite sobrecarga de métodos de la misma manera que otros lenguajes como Java o C++. En Python, si defines múltiples métodos con el mismo nombre, el último definido sobrescribirá a los anteriores.

Sin embargo, podemos simular la sobrecarga utilizando parámetros opcionales o *args y **kwargs:

class Calculadora:
    def sumar(self, *args):
        return sum(args)

Esta implementación permite llamar a sumar() con cualquier número de argumentos.

Sobreescritura de propiedades

También podemos sobreescribir propiedades en las clases hijas:

class Empleado:
    def __init__(self, nombre, salario_base):
        self.nombre = nombre
        self._salario_base = salario_base
    
    @property
    def salario(self):
        return self._salario_base

class Gerente(Empleado):
    def __init__(self, nombre, salario_base, bonus):
        super().__init__(nombre, salario_base)
        self.bonus = bonus
    
    @property
    def salario(self):
        # Sobreescribimos la propiedad para incluir el bonus
        return self._salario_base + self.bonus

En este ejemplo, la propiedad salario se sobreescribe en la clase Gerente para incluir el bonus en el cálculo.

La sobreescritura de métodos es una técnica poderosa que permite adaptar y especializar el comportamiento heredado, facilitando la creación de jerarquías de clases flexibles y expresivas que modelan con precisión los dominios del problema.