Excepciones — Python: Profundizando en las clases

• ¿Qué son las excepciones?
• Capturar errores con try/except
• ¿Por qué es útil capturar errores?
• Crear nuestras propias excepciones
• Herencia en Excepciones
• Bloque finally: Código que siempre se ejecuta
• Tabla resumen de bloques

Al escribir programas, es común que ocurran errores inesperados, como un archivo que falta o una división por cero. Si no manejamos estos errores, el programa puede fallar.

En esta lección, aprenderemos cómo gestionar estos errores en Python usando try/except, cómo crear nuestras propias excepciones y cómo usar finally para asegurarnos de que ciertas acciones se ejecuten, sin importar si hubo un error o no.

¿Qué son las excepciones?

Por ejemplo, si intentamos dividir por cero:

x = 10 / 0  # Esto genera un error llamado ZeroDivisionError

Para evitar que el programa falle por completo, podemos atrapar ese error y manejarlo, como si dijéramos: “si pasa esto, entonces haz tal cosa”.

Capturar errores con try/except

La forma básica de manejar errores en Python es con try y except.

try:
    # Intentamos algo que podría fallar
    resultado = 10 / 0
except ZeroDivisionError:
    # Si falla, llegamos acá
    print("No se puede dividir por cero.")

¿Qué pasa aquí?

• En el bloque try intentamos dividir 10 entre 0.
• Como eso no se puede, se lanza una excepción del tipo ZeroDivisionError.
• Python entonces salta al bloque except, y allí decidimos qué hacer.

También podemos capturar cualquier error, sin importar su tipo:

try:
    hacer_algo_peligroso()
except Exception as e:
    print("Ocurrió un problema:", e)  # Esto imprime el mensaje del error

Aquí estamos diciendo: captura cualquier excepción (el tipo más general es Exception). La variable e contiene el error que se generó.

¿Por qué es útil capturar errores?

• Evitamos que el programa se detenga.
• Podemos tomar decisiones según el error.
• Nos ayuda a encontrar y entender problemas (por ejemplo, mostrar mensajes claros al usuario).

Podemos tener varios except para diferentes tipos de errores:

try:
    proceso()
except FileNotFoundError:
    print("Archivo no encontrado.")
except ValueError:
    print("Dato inválido.")
except Exception:
    print("Ocurrió un error desconocido.")

Crear nuestras propias excepciones

A veces queremos definir nuestros propios tipos de errores, para que el programa sepa exactamente qué pasó y cómo reaccionar.

Para crear un error personalizado, hacemos una clase que herede de Exception:

class MiError(Exception):
    pass

Ahora podemos lanzar este error con raise:

raise MiError("Algo salió mal en mi código")

Y capturarlo:

try:
    raise MiError("Ocurrió un error personalizado")
except MiError as e:
    print("Capturamos un error propio:", e)

Herencia en Excepciones

Podemos hacer jerarquías de errores para organizarlos mejor.

class ErrorBase(Exception):
    pass

class ErrorConexion(ErrorBase):
    pass

class ErrorAutenticacion(ErrorBase):
    pass

Esto nos permite manejar errores a diferentes niveles:

try:
    # Código que puede lanzar varios errores personalizados
    raise ErrorConexion("No hay internet")
except ErrorConexion:
    print("Error de conexión")
except ErrorAutenticacion:
    print("Error de login")
except ErrorBase:
    print("Error base general")
except Exception as e:
    raise e  # Re-lanzamos errores que no conocemos

Bloque finally: Código que siempre se ejecuta

A veces necesitamos ejecutar algo sí o sí, haya o no habido error. Por ejemplo, cerrar un archivo o terminar una conexión con una base de datos.

Para eso usamos finally:

try:
    archivo = open("datos.txt")
    # Procesamos el archivo
except FileNotFoundError:
    print("Archivo no encontrado.")
finally:
    print("Se ejecuta esto pase lo que pase")

Así, finally nos ayuda a limpiar o cerrar recursos, sin repetir código.

Tabla resumen de bloques