Cómo comprobar si una excepción tiene un determinado mensaje en Python

Introducción

En este laboratorio, aprenderás cómo explorar y acceder a los mensajes de excepción en Python para depurar y manejar errores de manera efectiva. El laboratorio te guía a través de la creación de un script de Python con una función divide que utiliza un bloque try...except para capturar posibles excepciones durante la división. Observarás cómo diferentes tipos de excepciones, como ZeroDivisionError y TypeError, generan mensajes de error específicos.

Luego, el laboratorio demuestra cómo acceder al objeto de excepción y su tipo para obtener información más detallada sobre el error. Al ejecutar el script con diferentes entradas, verás cómo los mensajes de excepción brindan información valiosa sobre la causa de los errores, lo que te permite identificar y corregir problemas en tu código.

Skills Graph

Explorar Mensajes de Excepción

En este paso, aprenderás cómo explorar los mensajes de excepción en Python. Los mensajes de excepción proporcionan información valiosa sobre lo que salió mal en tu código, lo que te ayuda a depurar y corregir errores.

Primero, creemos un archivo de Python llamado exceptions.py en tu directorio ~/project utilizando el editor VS Code.

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", e)

divide(10, 2)
divide(10, 0)
divide("hello", 5)

En este código:

• Definimos una función divide(x, y) que intenta dividir x entre y.
• Utilizamos un bloque try...except para capturar cualquier excepción que pueda ocurrir durante la división.
• Si se produce una excepción, imprimimos un mensaje de error junto con el objeto de excepción e.

Ahora, ejecutemos el script exceptions.py utilizando el comando python:

python exceptions.py

Deberías ver la siguiente salida:

The result is: 5.0
An error occurred: division by zero
An error occurred: unsupported operand type(s) for /: 'str' and 'int'

Como puedes ver, la primera llamada a divide(10, 2) se ejecuta correctamente y muestra el resultado. La segunda llamada, divide(10, 0), genera una excepción de division by zero, que es capturada por el bloque except, y se imprime el mensaje de error correspondiente. La tercera llamada, divide("hello", 5), genera una excepción TypeError porque no se puede dividir una cadena por un entero.

Ahora, modifiquemos el archivo exceptions.py para imprimir el tipo de la excepción:

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", type(e), e)

divide(10, 2)
divide(10, 0)
divide("hello", 5)

Ejecutemos el script nuevamente:

python exceptions.py

Deberías ver la siguiente salida:

The result is: 5.0
An error occurred: <class 'ZeroDivisionError'> division by zero
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Esta salida muestra el tipo de cada excepción que se produjo, proporcionando aún más información para la depuración.

Acceder a los argumentos de la excepción

En este paso, aprenderás cómo acceder a los argumentos (args) asociados a una excepción en Python. Los argumentos de una excepción pueden proporcionar detalles más específicos sobre el error que se ha producido.

Modifiquemos el archivo exceptions.py que creaste en el paso anterior para acceder e imprimir los argumentos de la excepción. Abre exceptions.py en tu directorio ~/project utilizando el editor VS Code.

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", type(e), e.args)

divide(10, 2)
divide(10, 0)
divide("hello", 5)

En este código, hemos modificado el bloque except para imprimir e.args. El atributo args es una tupla que contiene los argumentos que se pasaron al constructor de la excepción.

Ahora, ejecuta el script exceptions.py:

python exceptions.py

Deberías ver la siguiente salida:

The result is: 5.0
An error occurred: <class 'ZeroDivisionError'> ('division by zero',)
An error occurred: <class 'TypeError'> ("unsupported operand type(s) for /: 'str' and 'int'",)

Como puedes ver, la salida ahora incluye los argumentos asociados a cada excepción. Para ZeroDivisionError, el argumento es una tupla que contiene la cadena 'division by zero'. Para TypeError, el argumento es una tupla que contiene la cadena "unsupported operand type(s) for /: 'str' and 'int'".

Modifiquemos el archivo exceptions.py nuevamente para acceder directamente al primer argumento:

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", type(e), e.args[0])

divide(10, 2)
divide(10, 0)
divide("hello", 5)

Ejecuta el script nuevamente:

python exceptions.py

Deberías ver la siguiente salida:

The result is: 5.0
An error occurred: <class 'ZeroDivisionError'> division by zero
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Al acceder a e.args[0], podemos extraer el primer argumento de la excepción, que suele ser la parte más descriptiva del mensaje de error.

Coincidir con la cadena del mensaje

En este paso, aprenderás cómo coincidir con la cadena del mensaje de una excepción en Python. Esto es útil cuando quieres manejar tipos específicos de excepciones de manera diferente según su mensaje.

Modifiquemos el archivo exceptions.py con el que has estado trabajando para capturar específicamente la excepción ZeroDivisionError e imprimir un mensaje personalizado. Abre exceptions.py en tu directorio ~/project utilizando el editor VS Code.

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except ZeroDivisionError as e:
        print("Cannot divide by zero!")
    except Exception as e:
        print("An error occurred:", type(e), e.args[0])

divide(10, 2)
divide(10, 0)
divide("hello", 5)

En este código:

• Hemos agregado un bloque except específico para ZeroDivisionError.
• Si se produce una excepción ZeroDivisionError, imprimimos el mensaje "Cannot divide by zero!".
• El bloque genérico except Exception as e capturará cualquier otra excepción.

Ahora, ejecuta el script exceptions.py:

python exceptions.py

Deberías ver la siguiente salida:

The result is: 5.0
Cannot divide by zero!
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Como puedes ver, cuando se llama a divide(10, 0), la excepción ZeroDivisionError es capturada por el bloque except específico, y se imprime el mensaje personalizado "Cannot divide by zero!". La excepción TypeError generada por divide("hello", 5) sigue siendo capturada por el bloque except genérico.

También puedes coincidir directamente con la cadena del mensaje, aunque esto generalmente es menos recomendable que capturar tipos específicos de excepciones. Así es como puedes hacerlo:

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        if "division by zero" in str(e):
            print("Cannot divide by zero!")
        else:
            print("An error occurred:", type(e), e.args[0])

divide(10, 2)
divide(10, 0)
divide("hello", 5)

En este código:

• Capturamos todas las excepciones en el bloque except genérico.
• Verificamos si la cadena "division by zero" está presente en la representación en cadena del objeto de excepción e.
• Si está presente, imprimimos "Cannot divide by zero!". De lo contrario, imprimimos el mensaje de error genérico.

Ejecuta el script nuevamente:

python exceptions.py

Deberías ver la misma salida que antes:

The result is: 5.0
Cannot divide by zero!
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Si bien coincidir con la cadena del mensaje puede ser útil en algunos casos, generalmente es mejor capturar tipos específicos de excepciones porque los mensajes de excepción pueden cambiar, lo que hace que tu código sea menos confiable.

Resumen

En este laboratorio, has explorado los mensajes de excepción en Python para entender cómo depurar y corregir errores. Has aprendido a utilizar un bloque try...except para capturar excepciones durante las operaciones de división e imprimir el objeto de excepción e para ver el mensaje de error.

También has modificado el script para imprimir el tipo de excepción, lo que te ha permitido obtener una comprensión más profunda de la naturaleza de los errores encontrados, como ZeroDivisionError y TypeError. Esto permite una depuración y gestión de errores más específicas.