Simple Inheritance With Python Classes

Contenido del curso

Fundamentos de Clases y Objetos

Encapsulación y Comportamiento de Objetos

Implementar Protocolos con Métodos Especiales

Relaciones entre Clases y Polimorfismo

Diseño Avanzado y Patrones de Software

17
Loading JSON Data to Restore App State
11:43 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:52

Simple Inheritance With Python Classes

Curso de Python Orientado a Objetos

Clase 6 de 17

Clase 6 / 17

Recursos

Reusing code between similar classes is one of the cleanest wins of object oriented programming, and Python makes it straightforward with simple inheritance. You will learn how to build a Usuario base class and extend it into Estudiante and Profesor using super(), method overriding and shared attributes, so your projects scale without duplicated logic.

This walkthrough is for developers stepping into OOP who want a practical example: a small library system where students have a borrowing limit and teachers do not.

What is class inheritance in Python and why does it matter?

Inheritance lets a child class reuse the attributes and methods of a parent class, avoiding repeated code. In the example, both Estudiante and Profesor share nombre and cedula, so those live in the parent class Usuario [00:10].

The pattern starts with a base class built around a constructor that stores the shared data:

python class Usuario: def init(self, nombre, cedula): self.nombre = nombre self.cedula = cedula self.libros_prestados = []

def solicitar_libro(self, titulo):
    return f"Solicitud del libro {titulo} realizada"

The __init__ method runs automatically every time you create a new instance, which is why it is the right place to assign initial values.

What does super() do in Python? It calls a method from the parent class without naming it directly. Inside a child __init__, super().__init__(...) runs the parent constructor so shared attributes get set in one place.

How do you extend a parent class using super() in Python?

To inherit, you pass the parent class name in parentheses when declaring the child. Then super() brings the parent constructor into the child without rewriting it [01:05].

Here is the Estudiante class adding two attributes of its own: a carrera and a borrowing cap stored in limite_libros, defaulted to three.

python class Estudiante(Usuario): def init(self, nombre, cedula, carrera): super().init(nombre, cedula) self.carrera = carrera self.limite_libros = 3

Notice the trick: the __init__ inside super() belongs to Usuario, not to Estudiante. Mixing them up is one of the most common bugs when you start with inheritance.

How is the Profesor class different from Estudiante?

The Profesor class also inherits from Usuario, but its borrowing limit is set to None so there is no cap [02:55].

python class Profesor(Usuario): def init(self, nombre, cedula): super().init(nombre, cedula) self.limite_libros = None

That single difference, None versus 3, is what later drives different behavior when each user requests a book.

How do you override methods to add custom logic per subclass?

Method overriding means redefining a parent method inside the child to change its behavior. The base solicitar_libro only returns a generic message, but Estudiante needs to validate the limit before approving a loan [04:20].

The override uses len(self.libros_prestados) to count current loans and compares it against self.limite_libros:

python class Estudiante(Usuario): def solicitar_libro(self, titulo): if len(self.libros_prestados) < self.limite_libros: self.libros_prestados.append(titulo) return f"Préstamo del libro {titulo} autorizado" return f"No puedes prestar más libros. Límite alcanzado: {self.limite_libros}"

For Profesor, the override is simpler: append the title and return confirmation, no validation needed.

What is method overriding? It is when a subclass defines a method with the same name as one in its parent class to replace or extend its behavior. The child version runs whenever you call that method on an instance of the subclass.

Where should shared attributes live in an inheritance hierarchy?

If two child classes use the same attribute, move it up to the parent. The list libros_prestados was first written inside Estudiante, but Profesor also needed it, so the cleanest fix was relocating it to Usuario [06:10].

This is a core principle of inheritance design:

Put shared state in the parent class.
Put behavior that varies in the children.
Override only when the logic genuinely differs.

How do you test inheritance with real instances?

Instantiating a class means calling it with parentheses and arguments, which returns an object you store in a variable. Variable names should start with a lowercase letter as a Python convention.

python estudiante = Estudiante("Luis", "12345", "Ingeniería") profesor = Profesor("Ana", "67890")

print(estudiante.solicitar_libro("Python básico")) print(estudiante.solicitar_libro("Python intermedio")) print(estudiante.solicitar_libro("Python avanzado")) print(estudiante.solicitar_libro("Python Django"))

Running this in the terminal with python usuarios.py shows the first three loans authorized and the fourth blocked with the message No puedes prestar más libros, límite alcanzado: 3 [07:45]. Repeat the same four calls with profesor and all four go through, confirming the difference in behavior.

A quick challenge to lock in the concept: add a method to Estudiante called devolver_libro(titulo) that removes the book from libros_prestados and keeps the list in sync. Drop your version in the comments so we can compare approaches.

Diego Mauricio Zuluaga Rodríguez

Hace 8 meses

Les comparto mi código con el reto

"""_Partimos del archivo usuarios.py y definimos la clase base con los 
atributos comunes. Las clases hijas heredan colocando el nombre de la 
clase padre entre paréntesis. 
El uso de super en el constructor (init) llama al init de la clase padre 
sin nombrarla directamente, evitando confusiones y acoplamientos innecesarios.
"""

class Usuario:
    def __init__(self, nombre, cedula):
        self.nombre = nombre
        self.cedula = cedula
        self.libros_prestados = [] # Se inicializa la lista de libros prestados para cada estudiante, lo que permite llevar un registro de los libros que cada estudiante tiene prestados.
        # Se pone aquí la lista porque ambos usuarios están usando la lista de libros prestados, por lo que es un atributo común que se puede definir en la clase padre Usuario para evitar duplicación de código en las clases hijas Estudiante y Profesor.

    def solicitar_libro(self, titulo): # Permite agregar dentro de una lista de libros prestados el título del libro solicitado por el usuario, lo que permite llevar un registro de los libros que cada usuario tiene prestados.
        return f"Solicitud de libro '{titulo}' realizada."


class Estudiante(Usuario): # Se hereda en el paréntesis para que herede los atributos de la clase padre.
    def __init__(self, nombre, cedula, carrera):

        super().__init__(nombre, cedula) # Super permite llamar al constructor de la clase padre para inicializar los atributos heredados sin tener que nombrar directamente la clase padre, lo que hace que el código sea más flexible y menos acoplado.
        # __init__ es el constructor de la clase, es decir, el método que se ejecuta al crear una instancia de la clase. Por ejemplo, cuando se crea un objeto de la clase Estudiante, se llama automáticamente al método __init__ para inicializar los atributos del objeto.
        self.carrera = carrera # Atributo específico de la clase Estudiante, que no es heredado de la clase Usuario. Se debe agregar en el constructor de la clase Estudiante para que se inicialice correctamente al crear una instancia de Estudiante.
        self.limite_libros = 3 # Se establece un límite de libros para los estudiantes, lo que significa que un estudiante no puede tener más de 3 libros prestados al mismo tiempo. Este atributo es específico de la clase Estudiante y no se hereda de la clase Usuario, por lo que se debe agregar en el constructor de la clase Estudiante para que se inicialice correctamente al crear una instancia de Estudiante.


    def solicitar_libro(self, titulo): # Copiamos el método solicitar_libro para agregar la lógica de límite de libros prestados para los estudiantes, ya que el comportamiento de solicitar un libro es diferente para los estudiantes en comparación con los profesores, por lo que se debe sobreescribir el método solicitar_libro en la clase Estudiante para implementar esta lógica específica.
        if len(self.libros_prestados) < self.limite_libros: # len permite obtener la cantidad de libros prestados actualmente por el estudiante, y se compara con el límite establecido para determinar si se puede autorizar el préstamo del libro solicitado.
            self.libros_prestados.append(titulo)
            return f"Préstamo del libro '{titulo}' autorizado."
        else:
            return (
                f"No puedes prestar más libros. Límite alcanzado: {self.limite_libros}."
            )

    def devolver_libro(self, titulo): # Permite a un estudiante devolver un libro y actualiza la lista de libros prestados. Gestiona el caso en que el estudiante intente devolver un libro que no tiene.
        if titulo in self.libros_prestados: # Verifica si el libro solicitado está en la lista de libros prestados del estudiante.
            self.libros_prestados.remove(titulo) # Si el libro está en la lista, lo elimina usando el método remove().
            return f"Devolución del libro '{titulo}' registrada. Total de libros: {len(self.libros_prestados)}."
        else: # Si el libro no está en la lista de libros prestados, se retorna un mensaje de error.
            return f"No tienes el libro '{titulo}' prestado."

class Profesor(Usuario): # Al agregar la clase Profesor como hija de Usuario, se heredan los atributos y métodos de la clase padre como nombre y cedula.
    def __init__(self, nombre, cedula): # El método constructor se ejecuta automáticamente al crear una instancia de la clase Profesor.
        super().__init__(nombre, cedula)
        self.limite_libros = None # No hay límite de libros para los profesores, por lo que se establece como None. Este atributo es específico de la clase Profesor y no se hereda de la clase Usuario, por lo que se debe agregar en el constructor de la clase Profesor para que se inicialice correctamente al crear una instancia de Profesor.

# Esta es una herencia simple, ya que solo hay una clase padre (Usuario) y dos clases hijas (Estudiante y Profesor). No debemos sobreescribir el método solicitar_libro en las clases hijas, ya que el comportamiento de solicitar un libro es el mismo tanto para estudiantes como para profesores, por lo que se puede utilizar el método heredado de la clase Usuario sin necesidad de modificarlo.
# Tampoco debemos volver a escribir las líneas de nombre y cedula en las clases hijas, ya que estos atributos son heredados de la clase Usuario y se inicializan correctamente al llamar al constructor de la clase padre con super().__init__(nombre, cedula). Esto evita la duplicación de código y mantiene una estructura más limpia y mantenible.
    
    def solicitar_libro(self, titulo):
        self.libros_prestados.append(titulo)
        return f"Préstamo del libro '{titulo}' autorizado."

    def devolver_libro(self, titulo): # Permite a un profesor devolver un libro y actualiza la lista de libros prestados.
        if titulo in self.libros_prestados:
            self.libros_prestados.remove(titulo)
            return f"Devolución del libro '{titulo}' registrada. Total de libros: {len(self.libros_prestados)}."
        else:
            return f"No tienes el libro '{titulo}' prestado."

# Hacemos las pruebas creando instancias de Estudiante y Profesor, y solicitando libros para cada uno, lo que permite verificar que la lógica de límite de libros prestados para los estudiantes se implementa correctamente, mientras que los profesores pueden solicitar libros sin restricciones.

# Instanciar objetos: retorna una variable que representa un objeto de la clase, lo que permite crear múltiples objetos con diferentes atributos y comportamientos basados en la misma clase. Por ejemplo, al crear una instancia de Estudiante, se puede asignar un nombre, cédula y carrera específicos para ese estudiante, lo que permite tener múltiples estudiantes con diferentes características en el sistema. De manera similar, al crear una instancia de Profesor, se puede asignar un nombre y cédula específicos para ese profesor, lo que permite tener múltiples profesores con diferentes características en el sistema. Esto es fundamental para la programación orientada a objetos, ya que permite modelar entidades del mundo real de manera más flexible y organizada.

estudiante = Estudiante("Luis", "123456", "Ingeniería") # Las variables empiezan con minúscula por convención, y en mayúscula para las clases, así podemos crear instancias de las clases.
profesor = Profesor("Ana", "987654")

# Pruebas de préstamo
print("=== PRUEBAS DE PRÉSTAMO ===")
print("\n")

print(estudiante.solicitar_libro("Python básico"))
print(estudiante.solicitar_libro("Python intermedio"))
print(estudiante.solicitar_libro("Python avanzado"))
print(estudiante.solicitar_libro("Python Django"))  # Debe indicar límite alcanzado: 3

print("\n") # Salto de línea para separar las pruebas de estudiante y profesor

print(profesor.solicitar_libro("Python básico"))
print(profesor.solicitar_libro("Python intermedio"))
print(profesor.solicitar_libro("Python avanzado"))
print(profesor.solicitar_libro("Python Django"))    # Todos autorizados

# Pruebas de devolución de libros
print("\n=== PRUEBAS DE DEVOLUCIÓN ===")
print(f"Libros prestados del estudiante antes: {estudiante.libros_prestados}")
print(estudiante.devolver_libro("Python básico"))  # Debe devolver exitosamente
print(f"Libros prestados del estudiante después: {estudiante.libros_prestados}")

print("\nIntentando devolver un libro que no tiene...")
print(estudiante.devolver_libro("Python Django"))  # Debe indicar que no tiene este libro

print("\n")
print(f"Libros prestados del profesor antes: {profesor.libros_prestados}")
print(profesor.devolver_libro("Python intermedio"))  # Debe devolver exitosamente
print(f"Libros prestados del profesor después: {profesor.libros_prestados}")

print("\nIntentando devolver un libro que no tiene...")
print(profesor.devolver_libro("Harry Potter"))  # Debe indicar que no tiene este libro

Fundamentos de Clases y Objetos

OOP in Python: Modeling Real World Systems

Classes and Objects in Python Explained

Instance Methods That Make Python Objects Act

Private Attributes and Data Integrity in Python

Encapsulación y Comportamiento de Objetos

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

Simple Inheritance With Python Classes

Python Protocol for Flexible Polymorphism

Implementar Protocolos con Métodos Especiales

Composition Over Inheritance in Python

Organizing Python Projects Into Modules

Custom Exceptions That Make Python Errors Clear

Sistema de préstamos con identificación de usuarios en Python

Relaciones entre Clases y Polimorfismo

Book Search and Lending Flow in Python OOP

Clases abstractas en Python con ABC y @abstractmethod

Decoradores property en Python para atributos con validación

Decoradores @staticmethod y @classmethod en Python

Serialización de objetos Python a JSON para persistencia de datos

Diseño Avanzado y Patrones de Software

Loading JSON Data to Restore App State

Simple Inheritance With Python Classes

Progreso del curso

Fundamentos de Clases y Objetos

Encapsulación y Comportamiento de Objetos

Implementar Protocolos con Métodos Especiales

Relaciones entre Clases y Polimorfismo

Diseño Avanzado y Patrones de Software

Recursos

Recursos