Excepciones en Python: try, except, else, finally, raise y excepciones propias

Una excepción en Python es un objeto que indica que se ha producido un error y que interrumpe el curso normal del programa. Si nadie la captura, Python muestra un traceback y termina. Las excepciones se capturan con la construcción try/except y se provocan con la instrucción raise. Veamos cómo funciona todo esto, qué errores son los más frecuentes y cómo no convertir el manejo de errores en un modo de ocultarlos.

Qué es una excepción en Python

Cuando una operación no puede completarse —una división entre cero, el acceso a una clave que no existe, la conversión de una palabra a número—, Python crea un objeto de excepción y lo «lanza». La ejecución de la función actual se detiene, la excepción sube por la cadena de llamadas hasta encontrar un manejador adecuado. Si no lo encuentra, el programa se cae.

>>> 10 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Y respondiendo a una pregunta frecuente: al dividir entre cero en Python se produce la excepción ZeroDivisionError. Esto ocurre tanto con / como con // y con %.

Cómo leer un traceback

El traceback es el informe de cómo llegó el programa hasta el error. Es más cómodo leerlo de abajo arriba. La última línea es lo principal: el tipo de excepción y el mensaje. Más arriba está la línea de código donde ocurrió todo, y más arriba aún, quién la llamó, hasta llegar al punto de entrada.

Traceback (most recent call last):
  File "gastos.py", line 9, in <module>
    total = leer_importe(fila)
  File "gastos.py", line 4, in leer_importe
    return float(bruto.strip())
           ~~~~~^^^^^^^^^^^^^
ValueError: could not convert string to float: 'cien'

Desde Python 3.11, bajo la línea de código se dibujan marcas ~~~^^^ (PEP 657) que muestran qué expresión exacta de la línea falló. Esto ayuda mucho cuando en una misma línea hay varias llamadas seguidas.

Sugerencias «Did you mean»

Desde Python 3.10, si se escribe mal un nombre, el error propone la variante más cercana. En Python 3.15 las sugerencias son más inteligentes: el intérprete conoce los hábitos de otros lenguajes. Llamar a list.push sugerirá append, y "café".toUpperCase() sugerirá el método upper. La sugerencia también mira campos anidados: si un diccionario está en el atributo totals de un objeto y se llama a items() sobre el objeto mismo, el error propondrá .totals.items. Además, delattr() también sugiere nombres parecidos.

Tipos de excepciones en Python

Hay decenas de excepciones integradas, pero al empezar verá sobre todo estas:

Aparte está SyntaxError (y su caso particular IndentationError): se produce ya al analizar el archivo, antes de ejecutar el código, por lo que no se puede capturar con try en el mismo archivo.

Jerarquía de excepciones

Las excepciones son clases y están organizadas en una jerarquía. En la cima está BaseException. De ella heredan Exception (casi todos los errores «normales») y algunas excepciones del sistema: KeyboardInterrupt, SystemExit, GeneratorExit.

BaseException
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    └── ZeroDivisionError
      ├── LookupError
      │    ├── KeyError
      │    └── IndexError
      ├── OSError
      │    └── FileNotFoundError
      ├── TypeError
      └── ValueError

La jerarquía es importante al capturar: except LookupError captura tanto KeyError como IndexError. Y KeyboardInterrupt no es un error del código: así avisa Python de que el usuario ha pulsado Ctrl+C. No hereda de Exception a propósito, para que un except Exception no impida interrumpir el programa.

Gestión de excepciones: try/except/else/finally

El código que puede fallar se coloca en el bloque try. En el bloque except se indica el tipo de error y qué hacer con él. Precisamente except es el bloque que se usa en Python para el manejo de excepciones.

def leer_importe(bruto):
    try:
        valor = float(bruto)
    except ValueError as e:
        print(f"Omito la línea: {e}")
        return None
    else:
        return valor          # se ejecuta solo si no hubo error
    finally:
        print("análisis completado")   # se ejecuta siempre

print(leer_importe("250"))

En este ejemplo la salida empieza por «análisis completado» y después aparece 250.0. El return del bloque else guarda el valor; después Python ejecuta obligatoriamente finally y solo entonces devuelve el resultado. Por eso finally es fiable para la limpieza: cerrar un archivo, liberar una conexión.

Si en finally se escribe un return propio, sustituye al anterior e incluso «traga» la excepción. Desde Python 3.14 este código genera un SyntaxWarning (PEP 765): no escriba return en finally.

Varias excepciones a la vez

Se pueden escribir varios bloques except para tipos distintos, o enumerar los tipos en una tupla:

try:
    importe = int(datos["importe"])
except KeyError:
    importe = 0
except (ValueError, TypeError) as e:
    print("Importe incorrecto:", e)
    importe = 0

Los bloques se comprueban de arriba abajo y se ejecuta el primero que coincide, así que los tipos más concretos van antes que los generales. Desde Python 3.14 (PEP 758), los tipos se pueden enumerar sin paréntesis —except ValueError, TypeError:—, pero si se usa as, los paréntesis siguen siendo obligatorios.

Cómo mostrar el texto del error y conocer su tipo

El objeto de excepción está disponible mediante as e. str(e) da el mensaje y type(e).__name__ da el nombre del tipo:

try:
    int("cien")
except ValueError as e:
    print(type(e).__name__)   # ValueError
    print(e)                  # invalid literal for int() with base 10: 'cien'

Módulo traceback: el texto completo del error

A veces hay que capturar el error pero conservar el traceback completo, para un registro o un informe. Para eso existe el módulo traceback:

import traceback

try:
    1 / 0
except ZeroDivisionError:
    traceback.print_exc()             # imprime el traceback en stderr
    texto = traceback.format_exc()    # el mismo texto como cadena

Si escribe registros con el módulo logging, es más sencillo llamar a logging.exception("no se pudo calcular") dentro de except: el traceback se añade automáticamente al mensaje.

Python raise: cómo provocar una excepción

La instrucción raise lanza una excepción manualmente. Así una función indica que no puede trabajar con esos datos:

def añadir_gasto(importe):
    if importe < 0:
        raise ValueError(f"El importe no puede ser negativo: {importe}")
    ...

añadir_gasto(-5)
# ValueError: El importe no puede ser negativo: -5

raise de Python es una instrucción, no una función, así que tras la palabra raise no van paréntesis adicionales: dentro de los paréntesis se pasan los argumentos del constructor de la excepción. Elija el tipo según el significado: un valor incorrecto es ValueError, un tipo incorrecto es TypeError.

raise sin argumentos y raise from

Dentro de un except, un raise sin nada reenvía la excepción actual sin cambios. Es útil cuando se quiere registrar algo, pero dejar el tratamiento al código que llama.

Si se sustituye una excepción por otra, use raise ... from e: el error original se conserva en la cadena y en el traceback se ven ambos:

def cargar_configuracion(ruta):
    try:
        with open(ruta) as f:
            return f.read()
    except FileNotFoundError as e:
        raise RuntimeError(f"No hay configuración en {ruta}") from e

add_note: añadir contexto al error

Desde Python 3.11 (PEP 678), a una excepción se le puede añadir una nota con el método add_note() y volver a lanzarla. El tipo del error no cambia, y la nota aparece bajo el mensaje:

def analizar(bruto, num_linea):
    try:
        return float(bruto)
    except ValueError as e:
        e.add_note(f"archivo gastos.csv, línea {num_linea}")
        raise

analizar("cien", 17)
# ValueError: could not convert string to float: 'cien'
# archivo gastos.csv, línea 17

Cómo crear una excepción propia en Python

Las excepciones propias sirven para los errores del dominio: presupuesto superado, pedido ya pagado, usuario bloqueado. Basta con una clase que herede de Exception:

class PresupuestoSuperado(Exception):
    def __init__(self, categoria, limite, gastado):
        super().__init__(f"{categoria}: límite {limite}, gastado {gastado}")
        self.categoria = categoria
        self.limite = limite
        self.gastado = gastado

def comprobar_presupuesto(categoria, limite, gastado):
    if gastado > limite:
        raise PresupuestoSuperado(categoria, limite, gastado)

try:
    comprobar_presupuesto("Comida", 10000, 12500)
except PresupuestoSuperado as e:
    print("Aviso:", e)   # Aviso: Comida: límite 10000, gastado 12500

Así el código que llama captura exactamente el caso de presupuesto superado y no lo confunde con erratas. En un proyecto grande conviene crear una clase base común (class ErrorRastreador(Exception)) y heredar de ella todas las excepciones propias; así se pueden capturar con un único except ErrorRastreador. Herede de Exception, no de BaseException.

Grupos de excepciones y except*

A veces hay varios errores a la vez, por ejemplo al validar un archivo entero o en tareas paralelas de asyncio.TaskGroup. Desde Python 3.11 se pueden agrupar en un ExceptionGroup y tratarlos por tipo con except*:

def validar_todo(filas):
    errores = []
    for f in filas:
        try:
            float(f)
        except ValueError as e:
            errores.append(e)
    if errores:
        raise ExceptionGroup("errores en el archivo", errores)

try:
    validar_todo(["1", "a", "b"])
except* ValueError as grupo:
    print(f"Líneas incorrectas: {len(grupo.exceptions)}")   # Líneas incorrectas: 2

try except de todos los errores: por qué no conviene

El hábito más perjudicial es capturarlo todo: except: pass. El programa «deja de caerse», pero en realidad deja de avisar de los problemas. Un except desnudo captura incluso KeyboardInterrupt y SystemExit, así que el programa no se puede detener con Ctrl+C. except Exception: pass es algo mejor, pero también traga en silencio las erratas en los nombres y los errores de lógica.

Para gestionar excepciones correctamente en Python:

• capture solo el tipo que sabe tratar: except ValueError, no todo;
• mantenga el bloque try corto: solo las líneas que pueden fallar de esa forma;
• si captura de forma amplia (except Exception) en el nivel superior del programa, registre siempre el traceback;
• no use excepciones para ramificar el flujo cuando basta una comprobación: en casos simples, dict.get() en lugar de try/except KeyError;
• para los recursos prefiera with: cierra el archivo aunque haya un error.

Resumen

Las excepciones en Python son el mecanismo normal para señalar errores, no un motivo para ocultarlos. Lea el traceback de abajo arriba, capture tipos concretos con try/except, use else para el código de «todo ha ido bien» y finally para la limpieza. Con raise se señala un error, raise from y add_note conservan el contexto, y las excepciones propias heredan de Exception. El curso de Python trabaja este tema en la práctica: el registro de gastos deja de caerse por una línea de CSV incorrecta y expresa el presupuesto superado con su propia excepción.