Herencia en Python para evitar duplicación de código

La herencia en Python es clave para escribir código limpio y evitar duplicación en proyectos reales como un sistema de biblioteca. Con una estructura similar a un árbol genealógico, permite que clases hijas reutilicen atributos y métodos de una clase padre, manteniendo la lógica central en un solo lugar y habilitando comportamientos específicos donde haga falta.

¿Qué es la herencia en Python y por qué evita duplicación?

La herencia establece relaciones de “es un tipo de”: un Estudiante es un tipo de Usuario, igual que un Profesor. Así, las clases hijas heredan atributos y métodos del padre, y los cambios en la clase base se propagan automáticamente. Además, el override permite redefinir métodos en subclases para comportamientos distintos, habilitando polimorfismo sin romper el diseño. Todo esto promueve reutilización y mantenibilidad del código.

• Clase padre con atributos y métodos comunes.
• Clases hijas que heredan y especializan comportamiento.
• Override para validar reglas específicas.
• Polimorfismo para responder distinto con la misma interfaz.
• Herencia múltiple cuando un objeto combina roles.

¿Cómo modelar usuarios con clases que heredan?

Partimos de una clase base Usuario con los datos mínimos: nombre y cédula, y un método común: solicitar_libro. Luego extendemos con Estudiante y Profesor, cada uno con validaciones particulares mediante override del método.

¿Cómo definir la clase base usuario?

Esta clase concentra lo compartido por todos los usuarios del sistema: identidad y la capacidad de solicitar libros.

class Usuario:
    def __init__(self, nombre, cedula):
        self.nombre = nombre
        self.cedula = cedula

    def solicitar_libro(self, titulo):
        # Lógica genérica de solicitud para cualquier usuario
        return f"Solicitud de '{titulo}' registrada para {self.nombre}."

¿Cómo extender con estudiante?

Estudiante hereda de Usuario y agrega atributos propios: libros_prestados, carrera y limite_libros. Con override de solicitar_libro se valida, por ejemplo, que la carrera esté activa y que no se exceda el límite de préstamos.

class Estudiante(Usuario):
    def __init__(self, nombre, cedula, libros_prestados=0, carrera=None, limite_libros=3):
        super().__init__(nombre, cedula)
        self.libros_prestados = libros_prestados
        self.carrera = carrera
        self.limite_libros = limite_libros

    def solicitar_libro(self, titulo):
        # override: validación extra para estudiantes
        if not self.carrera:
            return "No se puede prestar: carrera inactiva o no registrada."
        if self.libros_prestados >= self.limite_libros:
            return "No se puede prestar: alcanzó el límite de libros."
        return super().solicitar_libro(titulo)

¿Cómo especializar con profesor?

Profesor también hereda de Usuario, pero su validación es distinta: interesa el departamento y no la carrera. Se vuelve a crear el método con override para cubrir esa regla.

class Profesor(Usuario):
    def __init__(self, nombre, cedula, departamento=None):
        super().__init__(nombre, cedula)
        self.departamento = departamento

    def solicitar_libro(self, titulo):
        # override: validación para profesores
        if not self.departamento:
            return "No se puede prestar: departamento no asignado."
        return super().solicitar_libro(titulo)

¿Cuándo aplicar herencia múltiple y polimorfismo en una biblioteca?

Hay casos en los que un mismo usuario combina roles, por ejemplo, Profesor y Estudiante. La herencia múltiple permite componer ambos comportamientos y, si se requiere, priorizar las funcionalidades del profesor por encima de las del estudiante.

class ProfesorEstudiante(Profesor, Estudiante):
    pass  # Se priorizan comportamientos de Profesor al declarar primero esa clase

• Relación “es un tipo de” para estructurar jerarquías.
• Atributos compartidos: nombre, cédula, solicitar_libro.
• Atributos específicos: libros_prestados, carrera, limite_libros, departamento.
• Override para validar reglas por rol sin duplicar código.
• Polimorfismo para responder distinto con la misma interfaz.
• Herencia múltiple cuando un usuario cumple dos roles y se requiere prioridad.

En la próxima implementación, estos conceptos se aplicarán al sistema de biblioteca. Como reto: identifica posibles jerarquías y cuéntalas en los comentarios.