Conceptos básicos de excepciones

9 ejemplos para empezar con las excepciones: 6 básicos y 3 intermedios.

Prerrequisitos

• Python 3.14.0 instalado.
• Las excepciones heredan de BaseException; captura Exception en el código de la aplicación, no BaseException.

Ejemplos básicos

1. try/except Tipo específico

Captura solo el error que puedes manejar.

def parse_port(text: str) -> int:
    try:
        port = int(text)
    except ValueError:
        raise ValueError(f"puerto no válido: {text!r}") from None
    return port

• Captura el tipo de excepción más específico que encaje.
• Vuelve a lanzar con contexto al traducir errores para los llamadores.
• from None suprime la cadena original cuando añade ruido.

Relacionado: Lanzamiento y encadenamiento - preservar tracebacks

2. Cláusula else

Ejecuta código solo cuando no ocurrió ninguna excepción en try.

def load_config(path: str) -> dict:
    try:
        f = open(path, encoding="utf-8")
    except FileNotFoundError:
        return {}
    else:
        with f:
            import json
            return json.load(f)

• else evita ejecutar código exclusivo para el éxito dentro de try (que también capturaría sus excepciones).
• Mantiene except centrado en el modo de fallo de apertura.
• Empareja con with cuando el recurso deba cerrarse en la ruta de éxito.

Relacionado: El módulo logging - registrar rutas de configuración faltantes

3. finally se ejecuta siempre

La limpieza se ejecuta tanto si se disparó una excepción como si no.

lock_acquired = False
try:
    lock_acquired = True  # simula adquisición
    print("sección crítica")
finally:
    if lock_acquired:
        print("liberar bloqueo")

• finally es para garantías de liberación/limpieza.
• No devuelvas valores desde finally; anula los retornos de try/except.
• Prefiere with cuando el objeto admita la gestión de contextos.

Relacionado: Gestores de contexto como patrón - limpieza estructurada

4. Jerarquía de excepciones

Captura una clase base para manejar una familia de errores.

try:
    int("no-es-un-número")
except (ValueError, TypeError) as exc:
    print(type(exc).__name__, exc)

• La jerarquía incorporada agrupa fallos relacionados (subclases de OSError).
• La tupla en except captura múltiples tipos.
• Ordena los manejadores de lo específico a lo general al encadenar bloques except.

Relacionado: Jerarquías de excepciones personalizadas - bases de dominio

5. Volver a lanzar con raise desnudo

Preserva el traceback original dentro de un bloque except.

def process():
    try:
        risky()
    except ValueError:
        log("valor incorrecto")  # simula registro
        raise

• raise desnudo repropagará la excepción activa con la pila intacta.
• Úsalo al registrar o enriquecer el contexto antes de que el fallo salga.
• No uses raise exc con una variable almacenada a menos que entiendas la vinculación del traceback.

Relacionado: Lanzamiento y encadenamiento - raise ... from

6. Atributos de excepción

Muchas excepciones transportan campos estructurados.

try:
    open("/no/tal/archivo.txt")
except FileNotFoundError as exc:
    print(exc.errno, exc.filename)

• Las subclases de OSError exponen .errno, .filename, .strerror.
• Lee los atributos para mensajes dirigidos al usuario y etiquetas de métricas.
• Las excepciones de dominio deben seguir el mismo patrón con campos personalizados.

Relacionado: Jerarquías de excepciones personalizadas - diseño de campos

Ejemplos intermedios

7. El gestor de contexto suprime al salir

Devolver True de __exit__ suprime las excepciones (raro, úsalo deliberadamente).

from contextlib import suppress
 
with suppress(FileNotFoundError):
    print(open("optional.txt").read())
 
print("continúa")

• contextlib.suppress documenta la supresión intencionada.
• Nunca uses except: pass desnudo en el código de la aplicación.
• Registra los errores suprimidos cuando indiquen problemas de datos, no archivos opcionales.

Relacionado: Mejores prácticas de errores y registro - nunca suprimir silenciosamente

8. Visión general de grupos de excepciones

Múltiples errores pueden aparecer como un único ExceptionGroup (3.11+).

def failing_tasks():
    raise ExceptionGroup(
        "lote fallido",
        [ValueError("a"), TypeError("b")],
    )
 
try:
    failing_tasks()
except* ValueError as eg:
    print("errores de valor:", len(eg.exceptions))

• except* maneja sub-excepciones coincidentes dentro de un grupo.
• Los grupos de tareas y el código concurrente pueden lanzar grupos.
• Consulta la página dedicada para conocer la semántica completa de except*.

Relacionado: Grupos de excepciones y except* - guía completa

9. Patrón de registro y lanzamiento

Registra el contexto, luego falla; no suprimas.

import logging
 
log = logging.getLogger(__name__)
 
def charge(amount: float) -> None:
    if amount < 0:
        log.error("monto de cargo no válido=%s", amount)
        raise ValueError("el monto debe ser no negativo")

• Registra en el nivel apropiado antes de lanzar para operatividad.
• Incluye campos estructurados (amount=%s) en lugar de f-strings en las llamadas de registro.
• Los llamadores aún reciben la excepción para el flujo de control.

Relacionado: Registro estructurado y contextual - campos JSON

Versiones de pila: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.