Clases abstractas en Python con ABC y @abstractmethod

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:004:31

Clases abstractas en Python con ABC y @abstractmethod

Curso de Python Orientado a Objetos

Clase 13 de 17

Clase 13 / 17

Recursos

Aprende a crear clases abstractas en Python con el módulo ABC para imponer contratos claros entre clases. Con el decorador @abstractmethod, podrás exigir la sobrescritura de métodos en cada subclase, detectar errores en tiempo de ejecución y reforzar la herencia con interfaces consistentes.

¿Qué es una clase abstracta en Python con ABC?

Una clase abstracta es un contrato: define qué debe hacer una clase, no cómo hacerlo. Piensa en planos arquitectónicos que aseguran puertas y ventanas en cada edificio. Con ABC, las subclases deben implementar los métodos marcados como abstractos. A diferencia de Protocol, aquí sí hay validación en ejecución de que el método fue implementado.

¿Cómo definir UsuarioBase con @abstractmethod?

from abc import ABC, abstractmethod

class UsuarioBase(ABC):
    @abstractmethod
    def solicitar_libro(self):
        pass

Define el contrato base que todas las subclases deben respetar.
Usa el decorador @abstractmethod para marcar métodos obligatorios.
Emplea pass para dejar el método sin implementación.

¿Cómo heredar e implementar en una subclase?

class Usuario(UsuarioBase):
    def solicitar_libro(self):
        # Lógica concreta de la subclase.
        ...

Hereda de UsuarioBase para reutilizar el contrato.
Implementa el método requerido para poder instanciar la clase.

¿Qué valida Python en tiempo de ejecución?

Si falta un método abstracto en la subclase, al instanciar se lanza TypeError.
La verificación ocurre al ejecutar, por ejemplo: python main.py.
El decorador @abstractmethod es la clave de esta verificación.

¿Cómo detectar y corregir errores al faltar un método?

Al ejecutar la aplicación con python main.py, todo funciona si las subclases implementan los métodos abstractos. Si agregas uno nuevo en la clase base, la siguiente ejecución fallará con TypeError hasta que lo implementes.

Agregar un nuevo método abstracto en la base:

from abc import ABC, abstractmethod

class UsuarioBase(ABC):
    @abstractmethod
    def solicitar_libro(self):
        pass

    @abstractmethod
    def metodo_de_prueba(self):
        pass

Se declara metodo_de_prueba como obligatorio.
Cualquier subclase debe implementarlo antes de poder instanciarse.

Implementarlo en la subclase para resolver el error:

class Usuario(UsuarioBase):
    def solicitar_libro(self):
        ...

    def metodo_de_prueba(self):
        return "Método de prueba para saber cómo funciona ABC"

Tras implementar, la aplicación vuelve a ejecutarse con normalidad.
El mensaje de retorno confirma el flujo correcto.

Checklist rápido.

Ejecuta: python main.py y verifica que todo corre.
Agrega @abstractmethod en la base y vuelve a ejecutar.
Observa el TypeError que impide instanciar la subclase.
Implementa el método faltante y prueba de nuevo.

¿Dónde conviene usar ABC y qué reto practicar?

Las clases abstractas con ABC crean contratos sólidos y aseguran interfaces consistentes entre subclases. Son especialmente útiles en frameworks y bibliotecas donde necesitas que todas las implementaciones cumplan el mismo conjunto de métodos.

Reto práctico.

Crea una clase abstracta para el libro: LibroBase que herede de ABC.
Declara con @abstractmethod todos los métodos que usan tus subclases de libro.
Ejecuta y verifica que las subclases implementen todo lo requerido.
Comparte tu solución en los comentarios.

Comentarios (13)13 comentarios

Gabriel Obregón

Hace un año

🌟 Clases Abstractas en Python (ABC)

🔹 1. Concepto esencial

📌 Una clase abstracta = un contrato. Define qué debe existir en cada subclase, no cómo debe funcionar. Imagina: planos de un edificio → siempre deben tener puertas y ventanas.

🔹 2. Elementos fundamentales

🎯 Para crear una clase abstracta necesitas:

🧩 Heredar de ABC
🏷️ Decorar métodos obligatorios con @abstractmethod
🚫 No instanciar la clase hasta que todo esté implementado
⚡ Python validará el contrato al ejecutar
🛡️ Mayor robustez que Protocol → aquí sí se revisa en runtime

🔹 3. Cómo se ve una clase abstracta

🧱 Estructura del contrato

from abc import ABC, abstractmethod

class UsuarioBase(ABC):

@abstractmethod

def solicitar_libro(self):

pass

👉 Representa:

📜 Un método que todas las subclases deben crear
❗ Sin implementación en la clase base

🔹 4. Cómo luce una subclase que cumple el contrato

🛠️ Implementación obligatoria

class Usuario(UsuarioBase):

# Lógica específica de la subclase

...

✔ Permite instanciar la clase ✔ Satisface los métodos del contrato ✔ Mantiene la interfaz uniforme

🔹 5. ¿Qué valida Python al ejecutar?

⚠️ Detección automática de errores

Python revisa el contrato cuando corres:

python main.py

Si falta un método abstracto:

💥 TypeError → “No puedes instanciar esta clase, te falta implementar algo”.

🔹 6. Qué pasa al agregar un nuevo método abstracto

🔧 Actualizas el contrato en la clase base

def metodo_de_prueba(self):

➡️ Ahora todas las subclases deben cumplir el nuevo método.

✔ Corrección en la subclase:

return "Método de prueba para saber cómo funciona ABC"

🟢 Al implementar el nuevo método, la aplicación vuelve a funcionar.

🔹 7. Mini–guía rápida (checklist visual)

✅ Ejecuta: python ➕ Agrega método con @abstractmethod

🔁 Ejecuta de nuevo

⚠️ Observa el TypeError

🛠️ Implementa lo que falta

🟢 Vuelve a ejecutar → ¡todo en orden!

🔹 8. Cuándo usarlas

💡 Las clases abstractas son ideales cuando quieres:

🔒 Contratos estrictos
🧭 Interfaces coherentes
🧱 Estructuras comunes en múltiples subclases
🧰 Frameworks o librerías robustas

Eduardo Jimenez

Hace un mes

Aqui, hay algo que talvez sea porla version de python.

En el metodo de la Clase abstracta, el metodo solo recibe self segun muestra el profesor, sin embargo parece que ahora es necesario que la case abstracta reciba los mismos parametros.

class usuarioBase(ABC):
    @abstractmethod
    def solicitar_libro(self, titulo: str) -> str:
        pass

De otra manera, la clase Usuario, que hereda de usuarioBase, nos va a marcar un error como se ve aqui.

Santiago Javier Giler Paz

class ProtocolLibro(Protocol):
    def prestar(self) -> str:
        """Metodo de prestar Libro"""

    def devolver(self) -> str:
        """Metodo de devolver Libro"""

    def calcular_duracion(self):
        """Calcula la duracion del prestamo de un libro"""

Samuel Steven Bernal Martínez

Aqui la solución:

class LibroBase(ABC):
    @abstractmethod
    def prestar(self) -> str:
        """Metodo que debe implementar cualquier libro para ser prestado."""
        pass

    @abstractmethod
    def devolver(self) -> str:
        """Metodo que debe implementar cualquier libro para ser devuelto."""
        pass

    @abstractmethod
    def calcular_duracion_prestamo(self, dias: int) -> int:
        """Metodo que debe implementar cualquier libro para calcular la duración del préstamo."""
        pass

Luis Martinez

Profesor

Excelente solución. Puede combinarlo con Protocol!

LUIS FELIPE HERNANDEZ GOMEZ

class LibroBase(ABC):

    @abstractmethod
    def prestar(self) -> str:
        pass

    @abstractmethod
    def devolver(self) -> str:
        pass

Alejandro Cuello Maure

Hace 2 meses

Hola, recomienda mucho esta lectura para profundizar más en el tema:

La diferencia entre abc y protocol, está en que abc quiere que el metodo esté implementado sin importar que tipo arroje, mientras que protocol solo funciona en ejecución y se asegura que el resultado del metodo implementado sea del tipo que especificamos.

Sindy Leon

Creé la clase abstracta LibroBase, heredando de ABC, y declaré con @abstractmethod los métodos prestar(), devolver() y calcular_duracion().

Después creé la clase intermedia Libro, que implementa la lógica común de préstamo y devolución. Esta clase continúa siendo abstracta porque no implementa calcular_duracion().

Finalmente, LibroFisico y LibroDigital implementan su propia duración de préstamo: siete y catorce días, respectivamente. Verifiqué la solución intentando crear instancias de LibroBase y Libro, lo que genera TypeError, mientras que LibroFisico y LibroDigital pueden instanciarse correctamente porque cumplen todos los métodos requeridos.

Esta estructura permite definir un contrato obligatorio para cualquier nuevo tipo de libro, reutilizar la lógica común y detectar implementaciones incompletas desde el momento de la instanciación.

Camilo Calderon

Hace 3 meses

Porque no sé exactamente que pueda cambiar por parte del proveedor externo y no tengo que estar acoplado a su respuesta

Exacto. Al no obligarlos a heredar de tu clase, el proveedor externo mantiene su libertad y tú mantienes tu estabilidad. El Protocol actúa como un filtro de seguridad: si tiene el método, funciona; si no, ni siquiera intentas ejecutarlo.

Si ya tienes claro que el Protocol te da esa flexibilidad, ¿qué riesgo crees que corres al abandonar la jerarquía estricta de las clases abstractas?

Sergio Daniel Flamenco

Hace 6 meses

LibroBase.py

class LibroBase(ABC):

def prestar(self) -> str:

def devolver(self) -> str:

def calcular_duracion_prestamo(self, dias: int) -> int:

Main8.py

from LibroBase import LibroBase

class LibroFisico(LibroBase):

def __init__(self, titulo: str):

self.titulo = titulo

self.prestado = False

if not self.prestado:

self.prestado = True

return f"El libro '{self.titulo}' ha sido prestado."

return f"El libro '{self.titulo}' ya está prestado."

if self.prestado:

return f"El libro '{self.titulo}' ha sido devuelto."

return f"El libro '{self.titulo}' no estaba prestado."

return dias

if __name__ == "__main__":

mi_libro = LibroFisico("Cien Años de Soledad")

print(mi_libro.prestar())

print(mi_libro.devolver())

Marcos Agustín Caballero

Hace 7 meses

class BaseBook(ABC):
    @abstractmethod
    def set_lend(self) -> str:
        pass

    @abstractmethod
    def set_return(self):
        pass

    @abstractmethod
    def is_popular(self):
        pass

    @abstractmethod
    def get_lend_times(self):
        pass

    @abstractmethod
    def set_lend_times(self, times: int):
        pass

Juan Nicolas JIMENEZ URIBE

Hace 7 meses•editado

class LibroBase(ABC):
    @abstractmethod
    def prestar(self):
        pass

    @abstractmethod
    def devolver(self):
        pass

    @abstractmethod
    def es_popular(self):
        pass

    @abstractmethod
    def get_veces_prestado(self):
        pass

    @abstractmethod
    def set_veces_prestado(self):
        pass

Diego Mauricio Zuluaga Rodríguez

Hace 8 meses

Solución al reto:


from typing import Protocol, Optional
from abc import ABC, abstractmethod

from exceptions import LibroNoDisponibleError


class LibroProtocol(Protocol):
    def prestar(self) -> str:
        """Método de prestar un libro"""
        ...

    def devolver(self) -> str:
        """Método de devolver un libro"""
        ...

    def calcular_duracion(self) -> str:
        """Calcula el tiempo de prestamo"""
        ...


class LibroBase(ABC):
    def __init__(self, titulo: str, autor: str, paginas: Optional[int] = None, es_nuevo: bool = False):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas
        self.es_nuevo = es_nuevo

    @abstractmethod
    def calcular_duracion(self) -> str:
        raise NotImplementedError


class Libro(LibroBase):
    def __init__(self, titulo: str, autor: str, isbn: str, disponible: bool = True,
                 paginas: Optional[int] = None, es_nuevo: bool = False):
        super().__init__(titulo, autor, paginas, es_nuevo)
        self.isbn = isbn
        self.disponible = disponible
        self.__veces_prestado = 0

    def __str__(self):
        return f"{self.titulo} por {self.autor} disponible: {self.disponible}"

    def prestar(self) -> str:
        if not self.disponible:
            raise LibroNoDisponibleError(f"'{self.titulo}' no está disponible")

        self.disponible = False
        self.__veces_prestado += 1
        return f"'{self.titulo}' prestado exitosamente. Total préstamos: {self.__veces_prestado}"

    def devolver(self) -> str:
        self.disponible = True
        return f"'{self.titulo}' devuelto y disponible nuevamente"

    def es_popular(self) -> bool:
        return self.__veces_prestado > 5

    def get_veces_prestado(self) -> int:
        return self.__veces_prestado

    def set_veces_prestado(self, veces_prestado: int) -> None:
        self.__veces_prestado = veces_prestado


class LibroFisico(Libro):
    def calcular_duracion(self) -> str:
        return "7 días"


class LibroDigital(Libro):
    def calcular_duracion(self) -> str:
        return "14 días"

Jesus Ivan Villalobos de la Cruz

class BaseBook(ABC):
  @abstractmethod
  def lend_book(self):
    pass

  @abstractmethod
  def calculate_duration(self):
    pass

  @abstractmethod
  def return_book(self):
    pass

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

Clases abstractas en Python con ABC y @abstractmethod

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