Custom Exceptions That Make Python Errors Clear

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:008:58

Custom Exceptions That Make Python Errors Clear

Curso de Python Orientado a Objetos

Clase 10 de 17

Clase 10 / 17

Recursos

Errors in programming are inevitable, and the difference between amateur and professional code lies in how you handle them. Python exception handling with try, except, and raise lets you catch errors, respond gracefully, and keep your program running, while custom exceptions make your code expressive and self documenting.

This walkthrough builds on a small library system where students request books, and shows how to evolve fragile validation into robust error management you would actually ship.

Why does my Python program authorize invalid data?

Imagine you have a solicitar_libro method inside an Estudiante class that adds a title to libros_prestados after some validations. If you call it from main.py passing None as the title, you would expect a rejection. Instead, the program happily prints that the empty book was authorized. That is a silent bug, the kind that breaks production systems quietly.

The fix starts by validating the input inside the method. If the title exists, continue. If not, you need to actively signal that something went wrong instead of returning a misleading success.

What does raise do in Python? raise interrupts execution and sends an error up to whoever called the function. Once raised, no further lines in that function run.

How do I use raise to signal errors explicitly?

Inside solicitar_libro, when the title is missing you use raise ValueError(f"El libro con el título {titulo} no es válido"). Now running the script no longer authorizes a None book. Instead you get a traceback showing the executed lines and a clear message pointing to the real problem.

The catch is that raise cancels everything below it. If your main.py tries to request a valid book like El Principito right after the failing call, that second request never executes, and the final print is also skipped. The program simply stops.

How do I keep the program running after an error?

This is where try and except come in. You wrap the risky call in a try block, and if the exception fires, the except block handles it without killing the script.

python try: resultado = estudiante.solicitar_libro(None) print(resultado) except: print("Error, no se pudo solicitar el libro")

With this structure, the failed request prints a friendly message, and the next request for El Principito runs normally. Execution continues.

Why is using except alone considered bad practice?

Python itself warns you against bare except clauses. A naked except catches every possible error, including ones you never anticipated, and hides them behind your generic message. If something fails for a reason unrelated to your validation, you would never know.

The professional solution is to define custom exception classes that describe your domain precisely.

What is a custom exception in Python? It is a class that inherits from Exception and represents a specific error in your application. It lets you catch only the errors you care about and ignore the rest.

How do I create custom exceptions for my application?

Create a new file called exceptions.py and define a base class for your domain:

python class BibliotecaError(Exception): pass

class TituloInvalidoError(BibliotecaError): pass

The pass keyword means you are not modifying the default Exception behavior, just renaming it for clarity. TituloInvalidoError inherits from BibliotecaError, so you can catch the parent and automatically capture every child error too.

In usuarios.py you import the specific exception and raise it instead of the generic ValueError:

python from exceptions import TituloInvalidoError raise TituloInvalidoError(f"El libro con el título {titulo} no es válido")

In main.py you only need to import and catch BibliotecaError. Because of inheritance, TituloInvalidoError is caught by the same block.

How do I inspect which specific error was raised?

Use the as keyword to bind the exception instance to a variable. Then you can read its message and even check its type to branch logic based on the concrete error.

python except BibliotecaError as e: print(f"{e}, tipo: {type(e)}")

When you run it, the output shows the message plus <class 'exceptions.TituloInvalidoError'>. That tells you exactly which subclass fired, which is gold when you want different recovery actions per error type.

This pattern delivers three concrete benefits:

Expressive code: exception names communicate the problem directly.
Robust behavior: every error case is handled deliberately.
Professional standards: you follow Python best practices around exception hierarchies.

Concepts and skills covered in the lesson

The class introduces several practical building blocks for exception handling in Python.

raise to actively signal an error and stop execution at that point [03:20].
ValueError as a built in exception used before migrating to custom classes [04:10].
Traceback reading to identify which lines executed before the failure [04:45].
try and except to capture errors and continue running the program [06:00].
Why bare except is discouraged and hides unrelated bugs [07:15].
Creating custom exceptions by inheriting from Exception in a dedicated exceptions.py file [08:00].
Exception hierarchies with a base BibliotecaError and specific children like TituloInvalidoError [09:30].
The as e syntax to access the exception instance and its type for branching logic [10:50].

As a challenge, modify the prestar method on the Libro class so it raises a new LibroNoDisponibleError when the book is not available. Import the exception, raise it from the method, and handle it from main.py. Share your implementation in the comments.

Gabriel Obregón

Hace un año

🎨Manejo Profesional de Errores en Python

────────────────────────────────────────

🎯 PROPÓSITO

Construir programas seguros, claros y a prueba de fallos usando:

👉 try

👉 except

👉 raise

👉 excepciones personalizadas

────────────────────────────────────────

🧱 1. Evitar que el programa se detenga

🔍 Problema

Entradas incorrectas → el programa se cae.

🛠 Solución

🟦 try: intenta ejecutar la acción.
🟧 except: reacciona solo a los errores esperados.
🔴 Evitar: except: genérico (oculta problemas reales).

⚠️ Errores frecuentes

📌 Título vacío
📌 None como entrada
📌 Datos corruptos

────────────────────────────────────────

📝 2. Validación de entradas

✔ Principio clave

Antes de continuar → verifica la validez.

💡 Si algo no es válido:

Lanza un raise con un mensaje claro.

⚙️ Ejemplo ilustrativo

if not titulo:

raise ValueError("El título no es válido.")

────────────────────────────────────────

🧰 3. Buen uso de try y except

✔ Cómo hacerlo bien

✨ Maneja los errores en la capa superior (por ejemplo, en main).
✨ Informa al usuario con mensajes comprensibles.
✨ Captura solo lo necesario.

❌ Cómo NO hacerlo

No ocultes errores con except: vacío.

Ejemplo visual:

try:

estudiante.solicitar_libro(None)

except Exception:

print("Error: no se pudo solicitar el libro.")

────────────────────────────────────────

🚨 4. Qué es raise

💥 Idea clave

Interrumpe inmediatamente el flujo. Después del raise → nada más se ejecuta.

🧭 Cuándo usarlo

Condición inválida detectada
La operación no puede continuar
Otro módulo debe decidir cómo resolverlo

────────────────────────────────────────

🧱 5. Excepciones personalizadas

🎨 ¿Por qué usarlas?

Más expresividad
Código profesional
Jerarquías claras
Capturas específicas sin silenciar otros errores

🧬 Ejemplo de jerarquía

class BibliotecaError(Exception): pass

class TituloInvalidoError(BibliotecaError): pass

⭐ Ventajas visuales

🎯 Captura solo el dominio que te interesa
🧩 type(e) permite diagnóstico rápido
🔍 Nombres que explican claramente qué falló

────────────────────────────────────────

🔗 6. Ejemplo integrado

🧠 En la lógica de negocio

if not titulo:

raise TituloInvalidoError("El título no es válido.")

🖥 En el programa principal

try:

estudiante.solicitar_libro(None)

except BibliotecaError as e:

print("Error:", e)

Comentarios (12)12 comentarios

Didier Fernando Aragón Moreno

Hace 10 meses•editado

# Clase Libro
class Libro:
    # Método constructor
    def __init__(self, titulo, autor, isbn, disponible=True):
        self.titulo = titulo
        self.autor = autor
        self.isbn = isbn
        self.disponible = disponible
        # Atributo privado
        self.__prestamos = 0  # Lista para guardar los préstamos
    # Método para imprimir la representación escrita del libro
    def __str__(self):
        return (
            f"Titulo: {self.titulo} - Autor: {self.autor} - "
            f"ISBN: {self.isbn} - Disponible: {self.disponible}"
        )
    # Método para cambiar la disponibilidad del libro
    def prestar_libro(self):
        if self.disponible:
            self.disponible = False
            self.__prestamos += 1  # Registrar el préstamo
            return f"El libro *{self.titulo} ha sido prestado"
        raise LibroNoDisponibleError(
            f"El libro *{self.titulo} no está disponible"
        )
    def devolver_libro(self):
        if not self.disponible:
            self.disponible = True
            return f"El libro *{self.titulo} ha sido devuelto"
    def es_popular(self):
        # Retorna True si el libro ha sido prestado más de 5 veces
        if self.__prestamos > 5:
            return (
                f"El libro *{self.titulo} es popular, "
                f"ha sido prestado {self.__prestamos} veces"
            )
        return (
            f"El libro *{self.titulo} no es popular, "
            f"ha sido prestado {self.__prestamos} veces"
        )
    # Método para acceder al atributo privado
    def get_prestamos(self):
        return self.__prestamos
    # Método para cambiar el atributo privado
    def set_prestamos(self, prestamos):
        self.__prestamos = prestamos
class LibroFisico(Libro):
    def __init__(self, titulo, autor, isbn, disponible=True, dias_en_prestamo: int = 0):
        super().__init__(titulo, autor, isbn, disponible)
        self.dias_en_prestamo = dias_en_prestamo
    def prestar_libro(self):
        if self.disponible:
            self.disponible = False
            # Incrementa el número de préstamos
            self.set_prestamos(self.get_prestamos() + 1)
            return f"El libro físico *{self.titulo} ha sido prestado"
        raise LibroNoDisponibleError(
            f"El libro físico *{self.titulo} no está disponible"
        )
    def duracion_prestamo(self) -> int:
        return (
            f"La duración del préstamo del libro físico "
            f"*{self.titulo} es de {self.dias_en_prestamo} días"
        )
class LibroDigital(Libro):
    def __init__(self, titulo, autor, isbn, disponible=True, dias_en_prestamo: int = 0):
        super().__init__(titulo, autor, isbn, disponible)
        self.dias_en_prestamo = dias_en_prestamo
    def prestar_libro(self):
        if self.disponible:
            self.disponible = False
            # Incrementa el número de préstamos
            self.set_prestamos(self.get_prestamos() + 1)
            return f"El libro digital *{self.titulo} ha sido prestado"
        raise LibroNoDisponibleError(
            f"El libro digital *{self.titulo} no está disponible"
        )
    def duracion_prestamo(self) -> int:
        return (
            f"La duración del préstamo del libro digital "
            f"*{self.titulo} es de {self.dias_en_prestamo} días"
        )

class BibliotecaError(Exception):
    pass

class TituloInvalidoError(BibliotecaError):
    pass

class LibroNoDisponibleError(BibliotecaError):
    pass

try:
    print(libro1.prestar_libro())  # Primera vez: OK
    print(libro1.prestar_libro())  # Segunda vez: lanzará excepción
except LibroNoDisponibleError as e:
    print(f"Error capturado: {e}, tipo: {type(e)}")
    print("El libro ya está prestado, no se puede prestar de nuevo")

Luis Martinez

Profesor

Hace 10 meses

Perfecto, buen uso de excepciónes!

Ing. Moisés Toro

Hace 3 meses

Había visto clases de manejo de errores pero esta ha sido la mejor que he visto hasta ahora, la que mejor lo explica la verdad. Gracias profe!

Samuel Steven Bernal Martínez

Recordemos que teniamos un libro como no disponible, perfecto para usar en la captura de este ejemplo (luego de hacer las modificaciones en exeptions y en libros):

#ejemplo de error libro no disponible
try:
    print(mi_libro_no_disponible.prestar())
except BibliotecaError as e:
    print("Se ha producido un error al prestar el libro:", e)

Jeferson Andrés Cruz Herrera

Hace un mes

Paso 1:

Cree la clase LibroNoDisponibleError en exceptions.py así:

class LibroNoDisponibleError(BibliotecaError):
    pass

Paso 2:

Ubiqué el método prestar (libro.py) y lo que hice fue agregar una validación adicional, para luego agregar el raise con la nueva clase:

 def prestar(self):
        if not self.disponible:
            raise LibroNoDisponibleError(
                f"El libro solicitado '{self.titulo}' no se encuentra disponible para prestamo"
            )
        elif self.disponible:
            self.disponible = False
            self.__veces_prestado += 1
            return f"'{self.titulo}' prestado exitosamente. Total préstamos: {self.__veces_prestado}"
        return f"'{self.titulo}' no está disponible"

Paso 3:

Luego en el main.py me inventé un try y un exception, llamando el método prestar() y usando la clase BibliotecaError

otro_libro = LibroFisico(
    "El Principito",
    "Saint-Exupéry",
    "9781644731234728",
    False,
)

try:
    prestamo_1 = otro_libro.prestar()
    print(prestamo_1)
except BibliotecaError as el_error:
    print(f"El error generado por python es: {el_error} y su tipo es {type(el_error)}")
    print("Este mensaje me lo inventé yo en el except, para ver que onda")

En este caso no usé LibroNoDisponibleError en el main, por que esa clase es hija de BibliotecaError y en este caso, BibliotecaError reune tooodos los errores que se customicen; entonces, en main solo es llamar a BibliotecaError en vez de cada uno de los errores customizados que estan en exeptions.py. Mientras que en el método puntual "prestar()" allí se debemos colocar el error customizado

Poulette Lopez

Hace 4 meses

#exceptions.py
class LibroNoDisponibleError(BibliotecaError):
    pass
#Libro.py
 def prestar_libro(self):
         if not self.disponible:
             raise LibroNoDisponibleError("El libro no esta disponible seleccione otro")    
              
         self.__numPrestado += 1
         self.disponible = False
         if(self.__numPrestado>=5):
            self.popular = True
         return f"Solitidud de prestamo del Libro '{self.titulo}' realizada correctamente"
#main.py
try:
    bibioteca.libros[0].prestar_libro()
    bibioteca.libros[0].prestar_libro()
except BibliotecaError as e:
     print(f"{e}, {type(e)}")
"""
  result
Solicitud del Libro 'El Principito' realizada
 El libro no esta disponible seleccione otro, <class 
 'exceptions.LibroNoDisponibleError'>
"""

#exceptions.py

class LibroNoDisponibleError(BibliotecaError):

pass

#Libro.py

luis mejia

Hace 7 meses

No entiendo, para que me serviría romper el codigo usando un raise en vez de manejar ese error con un return el libro no se encontró... Siento que explicas por explicar, no me gusta este curso

Francisco Alejandro Bernal Castro

Hace 6 meses

Pues es una forma de mejorar la legibilidad del código, a simple vista puedes diferenciar el manejo de errores de la lógica normal. También puedes utilizarlo como una forma de indicar a otros desarrolladores a tratar el error manejándolo de la manera que más les convenga.

En código particularmente profundo permite ver la traza de ejecución además de que puedes agregar más contexto a la excepción del que podrías manejar con un simple str.

Y pues lo de romper la ejecución del código, además de asegurar que no se ejecuto ninguna pieza de código adicional que no debiera ejecutarse en esas condiciones, es una forma muy efectiva de llamar la atención de otros desarrolladores (o incluso a veces de uno mismo) y evitar que un error o validación se pierda de manera silenciosa.

Al final del video el profesor Luis explica las ventajas de usar excepciones, aunque entiendo por que podría parecer inútil o tonto sin ejemplos y escenarios detallados de las ventajas o sin experiencia de haber trabajado con código que no sigue buenas practicas y otro que no.

en mi trabajo, yo personalizo las excepciones, y me ha ayudado a no tener en mi codigo exception regados por todos lados, es parte de las buenas practicas

Iván Villarroel

Hace 5 meses

Amo este curso

Sergio Daniel Flamenco

🧑‍💻🫶📚☺️

Diego Mauricio Zuluaga Rodríguez

Hace 8 meses

main.py

"""
# Proyecto Biblioteca

Proyecto de catálogo de libros
Este proyecto define una clase Libro para representar libros en un catálogo.
Cada libro tiene un título, autor, ISBN y disponibilidad.
Se crean dos instancias de libros y se almacenan en una lista que representa el catálogo.
Finalmente, se imprime el catálogo de libros.    
"""

from biblioteca import Biblioteca
from libros import LibroFisico
from usuarios import Estudiante, Profesor, SolicitanteProtocol
from exceptions import BibliotecaError, LibroNoDisponibleError

biblioteca = Biblioteca("Platzi Biblioteca")

estudiante = Estudiante("Luis", "1123123123", "Sistemas")
estudiante_1 = Estudiante("Jose", "56789", "Salud")
profesor = Profesor("Felipe", "123123123")
usuarios: list[SolicitanteProtocol] = [estudiante, estudiante_1, profesor]


mi_libro = LibroFisico(
    "100 Años de Soledad",
    "Gabriel Garcia Marquez",
    "9781644734728",
    True,
)
mi_libro_no_disponible = LibroFisico(
    "No disponible",
    "Luis",
    "56789",
    False,
)
otro_libro = LibroFisico(
    "El Principito",
    "Saint-Exupéry",
    "9781644731234728",
    True,
)


biblioteca.libros = [mi_libro, mi_libro_no_disponible, otro_libro]


print(biblioteca.libros)

try:
    print(estudiante.solicitar_libro(None))
except BibliotecaError as e:
    print("Error: no se pudo solicitar el libro.")
    print(f"{e}, tipo: {type(e)}")

resultado = estudiante.solicitar_libro("El principito")
print(resultado)


try:
    resultado = mi_libro_no_disponible.prestar()
    print(resultado)
except LibroNoDisponibleError as e:
    print(e)  # imprimirá: El libro 'No disponible' no está disponible para préstamo.

exceptions.py

"""En este archivo se definen las excepciones personalizadas para la biblioteca."""

class BibliotecaError(Exception):
    pass

class TituloInvalidoError(BibliotecaError):
    pass

class LibroNoDisponibleError(BibliotecaError):
    def __init__(self, titulo: str | None = None):
        if titulo:
            mensaje = f"El libro '{titulo}' no está disponible para préstamo."
        else:
            mensaje = "El libro no está disponible para préstamo."
        super().__init__(mensaje)

libros.py

from typing import Protocol
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 Libro:
    def __init__(self, titulo, autor, isbn, disponible=True):
        self.titulo = titulo
        self.autor = autor
        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):
        if self.disponible:
            self.disponible = False
            self.__veces_prestado += 1
            return f"'{self.titulo}' prestado exitosamente. Total préstamos: {self.__veces_prestado}"
        raise LibroNoDisponibleError(self.titulo)

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

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

    def get_veces_prestado(self):
        return self.__veces_prestado

    def set_veces_prestado(self, veces_prestado):
        self.__veces_prestado = veces_prestado


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


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

Javier Medel

class LibraryError(Exception):

"""Base class for library-related exceptions."""

class InvalidTitleError(LibraryError):

"""Exception raised for invalid book titles."""

def __init__(self, title):

self.title = title

self.message = f"The book title '{self.title}' is invalid."

super().__init__(self.message)

Jesus Ivan Villalobos de la Cruz

class BookNotAvailableError(LibraryError):
  pass

from typing import Protocol

from exceptions import BookNotAvailableError

class BookProtocol(Protocol):
  def lend_book(self) -> str:
    ...

  def calculate_duration(self) -> int:
    ...

class Book:
  def __init__(self, title, author, isbn, available, pages):
    self.title = title
    self.author = author
    self.isbn = isbn
    self.available = available
    self.__lended_count = 0
    self.pages = pages
    self.duration = 14 #this value is in days

  def __str__(self):
    return f"Title: {self.title}, Author: {self.author}, ISBN: {self.isbn}, Available: {self.available}"

  def lend_book(self):
    if not self.available:
      raise BookNotAvailableError(f"Book '{self.title}' is not available")
    if self.available:
      self.available = False
      self.__lended_count += 1
      return f"'{self.title}' lended and is not available"

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

Custom Exceptions That Make Python Errors Clear

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