¿Qué es el manejo de excepciones?

Un programa que pide la edad a la gente recibirá tarde o temprano "twenty" en lugar de 20. Convertir ese texto es un error en tiempo de ejecución: int("twenty") lanza ValueError y, sin un plan para ello, el programa se detiene. El manejo de excepciones es ese plan. Marcas el código que puede fallar y escribes el código que se ejecuta si falla.

answers = ["34", "twenty", "19"]

for text in answers:
    try:
        age = int(text)
        print("Next year you will be", age + 1)
    except ValueError:
        print("Not a number:", text)

print("Done")

Next year you will be 35
Not a number: twenty
Next year you will be 20
Done

La respuesta mala se notifica y el bucle sigue con la siguiente. Sin el try, el programa habría impreso una línea y después un traceback.

Cómo funciona el manejo de excepciones

1. El código dentro de try se ejecuta con normalidad.
2. Una operación falla y el runtime lanza una excepción: un objeto con un tipo (ValueError) y un mensaje (invalid literal for int() with base 10: 'twenty').
3. El bloque try se detiene en esa línea. Sus líneas restantes se saltan, y por eso "Next year you will be" no se imprime para "twenty".
4. El runtime compara el tipo de la excepción con cada cláusula except, de arriba abajo, y ejecuta la primera que coincide.
5. Cuando el manejador termina, el programa continúa en la primera línea después de toda la instrucción try.
6. Si ninguna cláusula coincide, la excepción sale de la función actual y la búsqueda continúa en la función que la llamó, y luego en la que llamó a esa. A esto se le llama deshacer la pila de llamadas. Si la búsqueda llega a lo más alto del programa sin coincidencia, el programa termina con un traceback.

El paso 6 significa que el manejador no tiene que estar en la función donde ocurre el error. Aquí el fallo está dos llamadas más abajo y el manejador del final lo captura igualmente:

def parse_price(text):
    print("parsing", text)
    return float(text)

def total(prices):
    result = 0
    for p in prices:
        result += parse_price(p)
    return result

try:
    print(total(["4.50", "free", "3.20"]))
except ValueError as error:
    print("Could not add the prices:", error)

parsing 4.50
parsing free
Could not add the prices: could not convert string to float: 'free'

float("free") falló dentro de parse_price. Ni parse_price ni total tenían manejador, así que ambas se abandonaron, y "3.20" nunca se llegó a analizar. Esta es la principal decisión de diseño que te da el manejo de excepciones: manejar un error donde sabes qué hacer con él, que muchas veces está lejos de donde ocurrió.

try, except, else y finally

La instrucción try de Python tiene dos partes opcionales más. else se ejecuta solo cuando el bloque try terminó sin excepción. finally se ejecuta en todos los casos: tras un éxito, tras una excepción manejada e incluso cuando la función retorna desde dentro del try.

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("b was zero")
        return None
    else:
        print("no error")
        return result
    finally:
        print("finally runs either way")

print(divide(6, 3))
print(divide(6, 0))

no error
finally runs either way
2.0
b was zero
finally runs either way
None

En finally va la limpieza: cerrar un archivo, liberar un lock, cerrar una conexión a la base de datos. En Python, la instrucción with hace esta limpieza automáticamente con los archivos, y es la opción habitual para ellos.

Lanzar tus propias excepciones

Las excepciones no son solo para los errores que detecta el lenguaje. Cuando tu propia función recibe una entrada con la que no puede trabajar, puede lanzar una excepción para rechazarla, y quien la llamó decide qué pasa después. Definir una pequeña clase de excepción le da al error un nombre que lo describe.

class InsufficientFunds(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFunds(f"cannot take {amount}, balance is {balance}")
    return balance - amount

print(withdraw(100, 30))

try:
    withdraw(100, 250)
except InsufficientFunds as error:
    print("Refused:", error)

70
Refused: cannot take 250, balance is 100

Python usa raise. Java, C++ y JavaScript usan throw para lo mismo.

El manejo de excepciones en otros lenguajes

El mismo ejemplo de conversión en Java queda así:

try {
    int age = Integer.parseInt("twenty");
    System.out.println(age + 1);
} catch (NumberFormatException e) {
    System.out.println("Not a number: " + e.getMessage());
} finally {
    System.out.println("done");
}

Java divide las excepciones en dos grupos. Las excepciones comprobadas (checked), como IOException, describen problemas fuera del control del programa, y el compilador se niega a compilar el código que ni las captura ni las declara. Las excepciones no comprobadas (unchecked), subclases de RuntimeException como NullPointerException, suelen indicar un bug, y el compilador no te obliga a manejarlas.

Errores comunes

• Capturarlo todo. Un except: a secas en Python también captura KeyboardInterrupt, así que Ctrl+C deja de funcionar, y except Exception: captura bugs que nunca previste. Captura el tipo concreto que sabes manejar.
• Tragarse el error. except ValueError: pass oculta el problema. Como mínimo, imprime o registra lo que salió mal.
• Un bloque try demasiado grande. Envuelve solo las líneas que pueden lanzar la excepción que capturas, para no manejar por accidente un error que no tiene nada que ver.
• Capturar bugs en vez de corregirlos. Un IndexError de un bucle que da un paso de más es un fallo del código. Manejarlo mantiene vivo el código incorrecto.
• Esperar que catch evite un fallo en C o C++. Un segmentation fault es una señal del sistema operativo, no una excepción, y en Linux y macOS un catch (...) de C++ nunca la ve.

Qué leer después

Los errores a los que responde el manejo de excepciones se describen en la página de error en tiempo de ejecución, y el fallo que no puede capturar, en la página de segmentation fault. Para la sintaxis completa, lee las guías de excepciones en Python, try y catch en Java, excepciones en C++ y try y catch en JavaScript. El curso de Java y el curso de Python los practican con ejercicios reales.