Crear excepciones personalizadas en Python

Crear excepciones personalizadas en Python

En Python, además de las excepciones estándar (como ValueError, TypeError, FileNotFoundError), puedes crear excepciones personalizadas para representar errores específicos de tu dominio o aplicación.

Esto es útil cuando quieres:

• Mensajes de error más claros
• Validaciones más expresivas
• Manejo de errores por tipo (en lugar de por texto)
• Código más profesional y mantenible

---

Sintaxis básica

Una excepción personalizada se crea normalmente heredando de Exception:

class MiError(Exception):
    pass

Ejemplo 1: Excepción personalizada mínima

class EdadInvalidaError(Exception):
    pass

raise EdadInvalidaError("La edad no puede ser negativa")

Salida:

EdadInvalidaError: La edad no puede ser negativa

Ejemplo 2: Lanzar excepción desde una función de validación

class EdadInvalidaError(Exception):
    pass

def validar_edad(edad):
    if edad < 0:
        raise EdadInvalidaError("La edad no puede ser negativa")
    return edad

print(validar_edad(10))

Salida:

10

Ejemplo 3: Capturar una excepción personalizada

class EdadInvalidaError(Exception):
    pass

def validar_edad(edad):
    if edad < 0:
        raise EdadInvalidaError("La edad no puede ser negativa")
    return edad

try:
    validar_edad(-5)
except EdadInvalidaError as e:
    print("Error:", e)

Salida:

Error: La edad no puede ser negativa

Ejemplo 4: Excepción personalizada con atributos

class SaldoInsuficienteError(Exception):
    def __init__(self, saldo, retiro):
        self.saldo = saldo
        self.retiro = retiro
        super().__init__(f"Saldo insuficiente: saldo={saldo}, retiro={retiro}")

def retirar(saldo, monto):
    if monto > saldo:
        raise SaldoInsuficienteError(saldo, monto)
    return saldo - monto

try:
    retirar(100, 150)
except SaldoInsuficienteError as e:
    print(e)
    print("Saldo:", e.saldo)
    print("Retiro:", e.retiro)

Salida:

Saldo insuficiente: saldo=100, retiro=150
Saldo: 100
Retiro: 150

Ejemplo 5: Jerarquía de excepciones personalizadas

class AppError(Exception):
    pass

class ValidacionError(AppError):
    pass

class AutenticacionError(AppError):
    pass

✔ Esto permite capturar:

un error específico (ValidacionError)

o todos los errores de la app (AppError)

Ejemplo 6: Capturar por jerarquía

class AppError(Exception):
    pass

class ValidacionError(AppError):
    pass

def validar(nombre):
    if not nombre:
        raise ValidacionError("El nombre no puede estar vacío")

try:
    validar("")
except AppError as e:
    print("Error de la aplicación:", e)

Salida:

Error de la aplicación: El nombre no puede estar vacío

Ejemplo 7: Excepción personalizada + else y finally

class ValidacionError(Exception):
    pass

def validar_numero(texto):
    try:
        n = int(texto)
        if n < 0:
            raise ValidacionError("El número no puede ser negativo")
    except ValueError:
        raise ValidacionError("No es un número válido")
    else:
        return n
    finally:
        pass

try:
    print(validar_numero("-1"))
except ValidacionError as e:
    print("Error:", e)

Salida:

Error: El número no puede ser negativo

Ejemplo 8: No abuses de excepciones personalizadas

class ErrorX(Exception):
    pass

⚠ No tiene sentido crear excepciones nuevas si una estándar ya encaja.

Ejemplos donde NO necesitas una personalizada:

Conversión de tipos → ValueError

Tipos incorrectos → TypeError

Archivo no encontrado → FileNotFoundError

Ejemplo 9: Cuándo sí conviene crear una personalizada

Caso típico: reglas de negocio o validaciones de dominio.

class PedidoInvalidoError(Exception):
    pass

def crear_pedido(items):
    if not items:
        raise PedidoInvalidoError("Un pedido debe tener al menos 1 item")
    return {"items": items}

try:
    crear_pedido([])
except PedidoInvalidoError as e:
    print("Error:", e)

Salida:

Error: Un pedido debe tener al menos 1 item

Ejemplo 10: Regla práctica rápida

¿Es un error genérico del lenguaje? → usa excepciones estándar
¿Es un error del dominio de tu app? → crea una excepción personalizada

Buenas prácticas

• Hereda normalmente de Exception
• Usa nombres claros: SaldoInsuficienteError, PedidoInvalidoError
• Mantén una jerarquía simple (si tu app crece)
• Incluye mensajes útiles y consistentes
• No uses excepciones para control de flujo normal

Conclusión

Las excepciones personalizadas permiten que tu código:

• Exprese mejor la intención
• Sea más fácil de depurar
• Tenga un manejo de errores más profesional

Son especialmente valiosas cuando modelas reglas de negocio o validaciones específicas.