Jerarquía de errores en Python: try, except y finally

El manejo de errores en Python es clave para evitar que un programa termine de forma anticipada y para diseñar flujos de control robustos. Aquí aprenderás a usar la jerarquía de excepciones, a lanzar y capturar errores con intención, y a aplicar buenas prácticas que mejoran la calidad del código.

¿Por qué el manejo de errores en Python evita que tu programa termine?

Los errores en tiempo de ejecución son distintos a los de sintaxis: si hay un error de sintaxis, el programa ni siquiera corre. En cambio, con sintaxis correcta aún puedes fallar si ocurre una excepción en ejecución. Por eso, lanzar y capturar errores con una estrategia clara es esencial.

• Excepciones vs. sintaxis: las excepciones ocurren en ejecución, la sintaxis se valida antes de correr.
• Lanzar errores: se habla de throw y en Python se usa el keyword para “aventar un error”.
• Jerarquía rica: todo parte de BaseException, lo que permite extender y crear errores propios.
• Riesgo principal: si no manejas la excepción, el programa termina.

¿Cómo usar try, except, else y finally con estrategia?

La captura indiscriminada no es solución. Python promueve bloques try y except para modelar el flujo, pero con precisión: ser específicos con el tipo de error, evitar pass y preferir un solo enunciado dentro de try para aislar fallos.

• Una estrategia clara: no encierres todo el programa en try.
• Especificidad: evita capturar BaseException sin razón.
• Nada de pass: no atrapes para ignorar, es mala práctica y común en GitHub o GitLab.
• Un enunciado en try: reduces ambigüedad y manejas cada posible fallo con su excepción correcta.

¿Cuál es la sintaxis mínima de try y except?

Usa try para intentar una acción y except para manejar el error concreto que esperas.

# Ejemplo: división segura

def divide(numerador, denominador):
    if denominador == 0:
        raise ZeroDivisionError("No se puede dividir entre cero.")
    return numerador / denominador

try:
    resultado = divide(10, 0)
except ZeroDivisionError:
    print("Operación inválida: denominador en cero.")

• Idea clave: si esperas una división, captura solo ZeroDivisionError.
• Beneficio: el flujo no termina y el usuario recibe un manejo claro.

¿Cuándo usar else y finally?

Python permite extender el flujo con else y finally para expresar intención: qué pasa si todo sale bien y qué se ejecuta siempre.

try:
    airplane.takeoff()
except TakeoffError:
    airplane.land()
else:
    print("Despegue exitoso.")
finally:
    airplane.shutdown()

• else: se ejecuta solo si no hubo error. Útil para distinguir éxito real.
• finally: corre siempre. Ideal para liberar recursos como cerrar archivos.

¿Qué jerarquía de errores y ejemplos conviene conocer?

Python usa programación orientada a objetos para su sistema de excepciones. BaseException es la raíz y de ahí derivan errores comunes: EndOfFileError, ImportError, FileNotFoundError, FileExistsError, y ZeroDivisionError, entre otros. Conocerlos te ayuda a ser específico al capturar.

• BaseException: raíz de la jerarquía; permite extender con errores propios.
• ImportError: cuando un módulo no existe o falla al importarse.
• FileNotFoundError / FileExistsError: operaciones de archivo con rutas inexistentes o colisiones de creación.
• ZeroDivisionError: división entre cero.

También es buena práctica definir errores específicos de tu aplicación y extender la jerarquía cuando encaja con tu problema.

# Excepción de dominio propia
class AppError(BaseException):
    pass

# Uso en flujo de negocio
if not condiciones_validas:
    raise AppError("Reglas de negocio incumplidas.")

• Ventaja: expresividad y trazas más claras.
• Mantenimiento: facilita pruebas y lectura del código.

¿Has visto errores interesantes en la jerarquía de Python o definidos en algún sistema? Comparte ejemplos y cómo se adaptan a las necesidades del programa que conoces.