Try y except en Python: guía completa

Los errores forman parte normal de cualquier programa. Un archivo puede no existir, una entrada puede tener un formato inválido, una petición de red puede agotar el tiempo o una operación puede recibir un valor imposible. Try y except en Python permiten manejar situaciones previstas sin ocultar fallos inesperados.

En esta guía aprenderás a capturar excepciones específicas, utilizar else y finally, lanzar errores con raise, crear excepciones propias, conservar el contexto y diseñar funciones que fallen de forma clara. La documentación oficial sobre errores y excepciones es la referencia principal.

Qué es una excepción

Una excepción es un objeto que representa una situación que interrumpe el flujo normal. Si nadie la maneja, Python muestra un traceback y termina la ejecución actual.

numero = int("abc")

Este código produce ValueError porque el texto no representa un entero. El traceback indica el tipo de excepción, el mensaje y la línea donde apareció.

Primer bloque try y except

texto = input("Edad: ")

try:
    edad = int(texto)
except ValueError:
    print("La edad debe ser un número entero")

Coloca dentro de try solamente la operación que puede producir el error esperado. Un bloque demasiado grande dificulta saber qué instrucción falló.

Capturar el objeto de la excepción

try:
    edad = int("doce")
except ValueError as error:
    print(f"Conversión no válida: {error}")

El mensaje puede ser útil para diagnóstico, pero no siempre debe mostrarse directamente a usuarios finales.

Capturar excepciones específicas

from pathlib import Path

ruta = Path("datos.txt")

try:
    contenido = ruta.read_text(encoding="utf-8")
except FileNotFoundError:
    print(f"No existe el archivo: {ruta}")
except PermissionError:
    print(f"No hay permiso para leer: {ruta}")
except UnicodeDecodeError:
    print("El archivo no utiliza la codificación esperada")

Cada error requiere una explicación y una posible recuperación diferente. La guía de pathlib en Python muestra operaciones seguras con rutas.

Evitar except sin tipo

# Evita este patrón
try:
    procesar()
except:
    pass

Un except: captura casi cualquier evento, incluidos errores que deberían detener el programa. También elimina información al usar pass. Cuando necesites capturar errores normales de aplicación, utiliza except Exception as error solamente en una frontera adecuada, registra el traceback y decide si debes relanzar.

Capturar varios tipos juntos

try:
    resultado = int(texto) / divisor
except (ValueError, ZeroDivisionError) as error:
    print(f"Operación no válida: {error}")

Agrupa excepciones solamente cuando la respuesta para todas sea realmente la misma.

Usar else

El bloque else se ejecuta cuando no aparece una excepción.

try:
    numero = int(input("Número: "))
except ValueError:
    print("Entrada no válida")
else:
    print(f"El doble es {numero * 2}")

Mover el procesamiento posterior a else mantiene el bloque try pequeño y evita capturar errores que no pertenecen a la conversión.

Usar finally

finally se ejecuta exista o no una excepción.

archivo = open("registro.txt", encoding="utf-8")

try:
    contenido = archivo.read()
finally:
    archivo.close()

Para archivos, un bloque with suele ser más simple:

with open("registro.txt", encoding="utf-8") as archivo:
    contenido = archivo.read()

La guía de archivos de texto en Python explica este patrón.

Lanzar una excepción con raise

def calcular_descuento(precio, porcentaje):
    if precio < 0:
        raise ValueError("El precio no puede ser negativo")

    if not 0 <= porcentaje <= 1:
        raise ValueError("El porcentaje debe estar entre 0 y 1")

    return precio * (1 - porcentaje)

raise comunica que una función no puede cumplir su contrato. La guía de funciones en Python ayuda a diseñar parámetros y retornos claros.

Relanzar una excepción

import logging

try:
    procesar_pedido()
except ValueError:
    logging.exception("Pedido no válido")
    raise

Un raise sin argumentos dentro de except conserva la excepción original y su traceback.

Encadenar excepciones

import json


def cargar_configuracion(ruta):
    try:
        with open(ruta, encoding="utf-8") as archivo:
            return json.load(archivo)
    except FileNotFoundError as error:
        raise RuntimeError(
            f"No fue posible cargar la configuración: {ruta}"
        ) from error

from error conserva la causa técnica y añade contexto del dominio. La jerarquía oficial de excepciones ayuda a elegir tipos existentes.

Crear una excepción personalizada

class SaldoInsuficienteError(Exception):
    """Indica que una cuenta no tiene saldo suficiente."""


def retirar(saldo, cantidad):
    if cantidad <= 0:
        raise ValueError("La cantidad debe ser positiva")

    if cantidad > saldo:
        raise SaldoInsuficienteError(
            f"Saldo disponible: {saldo:.2f}"
        )

    return saldo - cantidad

Una excepción propia tiene sentido cuando las personas que usan la función necesitan distinguir esa situación de otros errores.

Validar entrada con reintentos

def leer_entero(mensaje, minimo=None, maximo=None):
    while True:
        texto = input(mensaje).strip()

        try:
            valor = int(texto)
        except ValueError:
            print("Escribe un número entero")
            continue

        if minimo is not None and valor < minimo:
            print(f"El valor mínimo es {minimo}")
            continue

        if maximo is not None and valor > maximo:
            print(f"El valor máximo es {maximo}")
            continue

        return valor

El bucle reintenta solamente errores que el usuario puede corregir.

Manejar peticiones HTTP

import requests

try:
    respuesta = requests.get(
        "https://api.example.com/datos",
        timeout=10,
    )
    respuesta.raise_for_status()
    datos = respuesta.json()
except requests.Timeout:
    print("La petición superó el tiempo límite")
except requests.ConnectionError:
    print("No fue posible conectar")
except requests.HTTPError as error:
    print(f"Respuesta HTTP no válida: {error}")

La guía de Requests en Python cubre timeouts, sesiones y respuestas HTTP.

Registrar excepciones

import logging

try:
    ejecutar_tarea()
except OSError:
    logging.exception("La tarea falló por un error del sistema")

logging.exception() registra el traceback cuando se llama dentro de un bloque except. No registres contraseñas, tokens ni datos personales. Consulta la guía de logging en Python.

Probar excepciones con Pytest

import pytest


def test_descuento_invalido():
    with pytest.raises(ValueError, match="porcentaje"):
        calcular_descuento(100, 1.5)

Una prueba confirma que la función falla con el tipo y mensaje esperados. La guía de Pytest para principiantes incluye más ejemplos.

Errores frecuentes

• Capturar Exception en todas las funciones.
• Usar pass y perder información.
• Colocar demasiadas instrucciones dentro de try.
• Capturar un error y continuar con datos incompletos.
• Mostrar tracebacks técnicos directamente al usuario.
• Registrar secretos dentro de mensajes de error.
• Crear excepciones personalizadas sin necesidad.
• No conservar la causa original al traducir errores.

Flujo recomendado

1. Evita el error mediante validación cuando sea posible.
2. Captura solamente excepciones que sabes interpretar.
3. Recupera, informa o traduce el error en la capa adecuada.
4. Conserva el traceback para diagnóstico.
5. Relanza cuando la capa actual no puede resolver el problema.
6. Prueba los caminos de error.

Conclusión

Try y except en Python permiten construir programas resistentes cuando se usan con precisión. Captura tipos específicos, mantén el bloque try pequeño, utiliza else para el camino exitoso y finally solamente para limpieza que siempre debe ocurrir.

Una excepción no es algo que deba ocultarse. Es información sobre un contrato incumplido o una condición externa. Diseña mensajes claros, conserva la causa, registra lo necesario sin exponer secretos y añade pruebas para asegurar que cada fallo previsto recibe el tratamiento correcto.