Ir al contenido principal

Bloques try-except: captura de excepciones

Introducción

En programación, los errores son inevitables, pero lo que marca la diferencia entre un código frágil y uno robusto es cómo manejamos esos errores. En Python, el mecanismo principal para gestionar excepciones es el bloque try-except. Este mecanismo nos permite "intentar" ejecutar código que podría fallar y "capturar" los errores que se produzcan, permitiendo que nuestro programa continúe funcionando en lugar de detenerse abruptamente. En este artículo, aprenderemos a utilizar los bloques try-except para capturar y manejar excepciones de manera efectiva, mejorando así la robustez y usabilidad de nuestros programas.

Estructura básica del bloque try-except

La estructura fundamental de un bloque try-except consta de dos partes principales:

try:
    # Código que podría generar una excepción
except:
    # Código que se ejecuta si ocurre una excepción

El intérprete de Python intenta ejecutar el código dentro del bloque try. Si no se produce ninguna excepción, el bloque except se ignora. Si ocurre una excepción en el bloque try, la ejecución de ese bloque se detiene inmediatamente y se pasa al bloque except.

Veamos un ejemplo sencillo:

try:
    numero = int(input("Introduce un número: "))
    print(f"Has introducido el número {numero}")
except:
    print("Error: No has introducido un número válido")

En este ejemplo, si el usuario introduce algo que no pueda convertirse a entero (como "abc"), se producirá una excepción ValueError que será capturada por el bloque except, mostrando el mensaje de error.

Captura de excepciones específicas

Aunque el ejemplo anterior funciona, es generalmente una mala práctica capturar todas las excepciones sin discriminación. Es mejor especificar qué tipo de excepción queremos capturar:

try:
    numero = int(input("Introduce un número: "))
    print(f"Has introducido el número {numero}")
except ValueError:
    print("Error: No has introducido un número válido")

De esta manera, solo capturamos las excepciones de tipo ValueError, que son las que esperamos que ocurran si el usuario introduce un valor no numérico. Otras excepciones no serán capturadas por este bloque y provocarán la terminación del programa.

¿Por qué especificar el tipo de excepción?

Especificar el tipo de excepción tiene varias ventajas:

  1. Mayor claridad: El código expresa claramente qué problemas específicos esperamos.
  2. Mejor depuración: Si ocurre una excepción inesperada, el programa se detendrá, lo que nos ayudará a identificar problemas que no habíamos previsto.
  3. Respuestas adecuadas: Podemos proporcionar respuestas específicas según el tipo de error.

Captura de múltiples excepciones

A veces, un bloque de código puede generar diferentes tipos de excepciones, y queremos manejarlas de manera diferente:

try:
    numero = int(input("Introduce un número: "))
    resultado = 10 / numero
    print(f"10 dividido por {numero} es {resultado}")
except ValueError:
    print("Error: No has introducido un número válido")
except ZeroDivisionError:
    print("Error: No se puede dividir por cero")

En este caso, capturamos dos tipos de excepciones con diferentes mensajes según el error que ocurra.

También podemos capturar múltiples excepciones con el mismo manejador:

try:
    # Código que podría generar diferentes excepciones
except (ValueError, ZeroDivisionError):
    print("Se ha producido un error de valor o una división por cero")

Acceso a la información de la excepción

Cuando capturamos una excepción, a menudo es útil acceder a la información que contiene. Podemos hacerlo asignando la excepción a una variable con la cláusula as:

try:
    with open("archivo_inexistente.txt", "r") as archivo:
        contenido = archivo.read()
except FileNotFoundError as error:
    print(f"Error: {error}")
    print(f"Tipo de error: {type(error)}")

La salida sería algo como:

Error: [Errno 2] No such file or directory: 'archivo_inexistente.txt'
Tipo de error: <class 'FileNotFoundError'>

Esta información puede ser muy útil para la depuración o para proporcionar mensajes de error más detallados.

El bloque except genérico

Aunque generalmente es recomendable capturar excepciones específicas, hay situaciones en las que un manejador genérico es apropiado. Por ejemplo, podríamos querer registrar todos los errores inesperados:

try:
    # Código que podría generar diferentes excepciones
except ValueError:
    # Manejo específico para ValueError
except ZeroDivisionError:
    # Manejo específico para ZeroDivisionError
except Exception as e:
    # Manejo para cualquier otra excepción no capturada anteriormente
    print(f"Error inesperado: {e}")
    # Podríamos registrar el error en un archivo de log

Nótese que el bloque except Exception debe colocarse después de los manejadores más específicos, ya que Python comprobará las cláusulas except en orden y ejecutará la primera que coincida. La clase Exception es la base de la mayoría de las excepciones, por lo que capturará casi cualquier excepción.

Ejemplos prácticos

Ejemplo 1: Lectura segura de un archivo

def leer_archivo(nombre_archivo):
    try:
        with open(nombre_archivo, "r", encoding="utf-8") as archivo:
            contenido = archivo.read()
        return contenido
    except FileNotFoundError:
        print(f"Error: El archivo '{nombre_archivo}' no existe")
    except PermissionError:
        print(f"Error: No tienes permisos para leer '{nombre_archivo}'")
    except UnicodeDecodeError:
        print(f"Error: No se puede decodificar el archivo '{nombre_archivo}'")
    except Exception as e:
        print(f"Error inesperado al leer '{nombre_archivo}': {e}")
    return None  # Retornamos None si hay algún error

# Uso de la función
contenido = leer_archivo("mi_archivo.txt")
if contenido:
    print("Contenido del archivo:")
    print(contenido)

Ejemplo 2: División segura

def division_segura(a, b):
    try:
        resultado = a / b
        return resultado
    except ZeroDivisionError:
        print("Error: No se puede dividir por cero")
        return None
    except TypeError:
        print("Error: Los valores deben ser numéricos")
        return None

# Pruebas de la función
print(division_segura(10, 2))      # 5.0
print(division_segura(10, 0))      # Error: No se puede dividir por cero
print(division_segura(10, "dos"))  # Error: Los valores deben ser numéricos

Ejemplo 3: Conversión de datos de usuario

def obtener_entero():
    while True:
        try:
            valor = input("Introduce un número entero: ")
            return int(valor)
        except ValueError:
            print("Error: Debes introducir un número entero válido. Inténtalo de nuevo.")

# Uso de la función
edad = obtener_entero()
print(f"Has introducido: {edad}")

Este último ejemplo muestra cómo podemos usar try-except en un bucle para solicitar repetidamente una entrada al usuario hasta que proporcione un valor válido.

Buenas prácticas en el manejo de excepciones

  1. Especifica las excepciones: Captura solo las excepciones que esperas y sabes cómo manejar.
  2. Maneja las excepciones cerca de su origen: Maneja las excepciones en el nivel donde puedes proporcionar un contexto significativo.
  3. No silencies errores importantes: Evita capturar excepciones sin proporcionar feedback adecuado.
  4. Mantén el código de manejo de excepciones limpio: El bloque except debe ser sencillo y directo.
  5. Usa finally y else cuando sea apropiado: Aprenderemos sobre estas cláusulas en el próximo artículo.
  6. Log de errores: Registra los errores inesperados para su posterior análisis.

Resumen

Los bloques try-except son una herramienta fundamental en Python para manejar situaciones de error de manera elegante y controlada. Nos permiten anticipar posibles problemas y proporcionar respuestas adecuadas, mejorando la robustez y la experiencia de usuario de nuestros programas. En lugar de dejar que el programa falle abruptamente, podemos capturar excepciones específicas, extraer información útil de ellas y tomar decisiones sobre cómo proceder.

En el próximo artículo, profundizaremos en el manejo de excepciones con las cláusulas adicionales else y finally, que complementan los bloques try-except y nos ofrecen aún más control sobre la ejecución de nuestro código en situaciones de error.

Volver arriba