Cómo comprobar si se ha elevado una excepción en Python

Introducción

En este laboratorio, aprenderás cómo comprobar si se ha producido una excepción en Python. El laboratorio se centra en comprender las excepciones y utilizar bloques try-except para capturarlas y manejarlas, evitando que el programa se bloquee.

Comenzarás creando un script de Python que genere una excepción ZeroDivisionError. Luego, aprenderás cómo utilizar un bloque try-except para capturar esta excepción y manejarla adecuadamente, lo que permitirá que tu programa siga funcionando.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/ErrorandExceptionHandlingGroup(["Error and Exception Handling"]) python/ErrorandExceptionHandlingGroup -.-> python/catching_exceptions("Catching Exceptions") python/ErrorandExceptionHandlingGroup -.-> python/raising_exceptions("Raising Exceptions") subgraph Lab Skills python/catching_exceptions -.-> lab-559611{{"Cómo comprobar si se ha elevado una excepción en Python"}} python/raising_exceptions -.-> lab-559611{{"Cómo comprobar si se ha elevado una excepción en Python"}} end

Comprender las Excepciones

En este paso, aprenderás sobre las excepciones en Python. Las excepciones son eventos que ocurren durante la ejecución de un programa y que interrumpen el flujo normal de las instrucciones. Comprender las excepciones es crucial para escribir código Python robusto y confiable.

Cuando se produce un error en Python, se levanta una excepción. Si la excepción no se maneja, el programa terminará y mostrará un mensaje de error. Sin embargo, utilizando bloques try-except, puedes capturar y manejar las excepciones, evitando que tu programa se bloquee.

Comencemos con un ejemplo sencillo que levanta una excepción:

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado division.py en el directorio ~/project.
```
~/project/division.py
```
Añade el siguiente código al archivo division.py:
```
numerator = 10
denominator = 0
result = numerator / denominator
print(result)
```
Este código intenta dividir 10 entre 0, lo cual es una operación inválida y levantará una excepción ZeroDivisionError.
Ejecuta el script utilizando el siguiente comando en la terminal:
```
python division.py
```
Verás una salida similar a esta:
```
Traceback (most recent call last):
  File "/home/labex/project/division.py", line 3, in <module>
    result = numerator / denominator
ZeroDivisionError: division by zero
```
El seguimiento (traceback) muestra que se produjo una ZeroDivisionError en la línea 3 del archivo division.py. El programa terminó porque la excepción no se manejó.

Ahora, veamos cómo manejar esta excepción utilizando un bloque try-except.

Usar try-except para Capturar

En este paso, aprenderás cómo utilizar bloques try-except para capturar y manejar excepciones en Python. Esto permite que tu programa siga funcionando incluso cuando se producen errores.

La estructura básica de un bloque try-except es la siguiente:

try:
    ## Code that might raise an exception
except ExceptionType:
    ## Code to handle the exception

Se ejecuta el código dentro del bloque try. Si se produce una excepción del tipo ExceptionType, se ejecuta el código dentro del bloque except. Si no se produce ninguna excepción, se omite el bloque except.

Modifiquemos el archivo division.py del paso anterior para manejar la excepción ZeroDivisionError:

Abre el archivo division.py en el editor de VS Code.
Modifica el código para incluir un bloque try-except:
```
try:
    numerator = 10
    denominator = 0
    result = numerator / denominator
    print(result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
```
En este código, el bloque try contiene la operación de división que podría levantar una ZeroDivisionError. El bloque except captura la ZeroDivisionError e imprime un mensaje de error.
Ejecuta el script utilizando el siguiente comando en la terminal:
```
python division.py
```
Verás la siguiente salida:
```
Error: Cannot divide by zero.
```
En lugar de bloquearse, el programa ahora maneja adecuadamente la ZeroDivisionError e imprime un mensaje informativo.

Esto demuestra cómo se pueden utilizar los bloques try-except para evitar que tu programa se bloquee debido a excepciones.

Inspeccionar el Tipo de Excepción

En este paso, aprenderás cómo inspeccionar el tipo de excepción y acceder al mensaje de excepción dentro del bloque except. Esto te permite manejar diferentes tipos de excepciones de diferentes maneras y proporcionar mensajes de error más informativos.

Cuando se captura una excepción, puedes asignarla a una variable en la cláusula except utilizando la palabra clave as:

try:
    ## Code that might raise an exception
except ExceptionType as e:
    ## Code to handle the exception
    ## 'e' is the exception object

La variable e contendrá entonces el objeto de excepción, que puedes utilizar para acceder a información sobre la excepción, como su tipo y mensaje.

Modifiquemos el archivo division.py para inspeccionar el tipo de excepción e imprimir el mensaje de excepción:

Abre el archivo division.py en el editor de VS Code.
Modifica el código para inspeccionar el tipo de excepción e imprimir el mensaje:
```
try:
    numerator = 10
    denominator = 0
    result = numerator / denominator
    print(result)
except ZeroDivisionError as e:
    print(f"Error: {type(e).__name__} - {e}")
```
En este código, capturamos la ZeroDivisionError y la asignamos a la variable e. Luego, usamos type(e).__name__ para obtener el nombre del tipo de excepción y e para obtener el mensaje de excepción. Imprimimos ambos en una cadena formateada.
Ejecuta el script utilizando el siguiente comando en la terminal:
```
python division.py
```
Verás la siguiente salida:
```
Error: ZeroDivisionError - division by zero
```
La salida ahora incluye el tipo de excepción (ZeroDivisionError) y el mensaje de excepción (division by zero).

Esto te permite proporcionar información más detallada sobre el error que se produjo, lo que facilita la depuración de tu código. También puedes utilizar esta información para manejar diferentes tipos de excepciones de diferentes maneras, proporcionando un manejo de errores más específico para cada caso.

Resumen

En este laboratorio, aprendiste sobre las excepciones en Python, que son eventos que interrumpen el flujo normal de un programa. Cuando se produce un error, se levanta una excepción y, si no se maneja, el programa se termina.

También aprendiste cómo utilizar bloques try-except para capturar y manejar excepciones, evitando que el programa se bloquee. El laboratorio demostró una ZeroDivisionError y cómo utilizar try-except para manejarla.