Tutorial de Python Try-Except: Mejores prácticas y ejemplos reales

Cuando el código Python encuentra problemas durante la ejecución, a menudo genera una excepción. Si no se gestionan, las excepciones provocarán un fallo en el programa. Sin embargo, con los bloques « try-except », puedes detectarlos, recuperarte con elegancia y mantener tu aplicación en funcionamiento.

Este tutorial no trata sobre los conceptos básicos de las excepciones, ya que eso lo cubrimos en nuestra guía guía Manejo de excepciones y errores en Python. En su lugar, aquí profundizaremos en el uso práctico de try-except: cómo estructurar los bloques, evitar errores comunes y aplicar las mejores prácticas que hacen que tu código sea más fiable en situaciones reales.

Al final, comprenderás no solo cómo funciona try-except, sino también cómo utilizarlo al estilo Python: escribiendo código de gestión de errores que sea claro, fácil de mantener y listo para su uso en producción.

Si todavía estás aprendiendo Python, te recomiendo que eches un vistazo a la programa de habilidades Fundamentos de la programación en Python, que te ayudará a desarrollar todas las habilidades esenciales.

¿Por qué centrarse en try-except?

El manejo de errores en Python consiste fundamentalmente en diseñar programas que puedan hacer frente a lo inesperado. Y aunque existen muchas herramientas para gestionar errores, try-except es la columna vertebral del enfoque de Python.

¿Por qué es tan importante?

• Refleja la filosofía de Python. En Python, el estilo habitual es« » (EAFP, «Es más fácil pedir perdón que permiso»). En lugar de comprobar todo por adelantado (¿existe este archivo? ¿es válida esta entrada? ¿está disponible el servidor?), simplemente se intenta realizar la operación. Si falla, capturas la excepción y la gestionas. Esto da como resultado un código más corto y limpio.
• Mantiene el código en funcionamiento en entornos reales. Las entradas de los usuarios serán desordenadas, los archivos se perderán, las API fallarán y las redes se caerán. Con try-except, puedes escribir código que no se colapse ante el primer problema, sino que reaccione de forma inteligente.
• Es lo suficientemente flexible tanto para principiantes como para profesionales. Un principiante podría utilizar try-except para detectar un ValueError al convertir la entrada en un entero. Un sistema de producción puede utilizarlo para registrar errores, reintentar operaciones fallidas o generar excepciones personalizadas que faciliten la depuración.

Por eso, este artículo se centra en try-except. Dominarlo marca la diferencia entre escribir scripts que solo funcionan en condiciones perfectas y escribir software robusto, fácil de mantener y listo para su uso en producción.

Anatomía de un bloque Try-Except

En pocas palabras:

try:
    risky_thing()
except SomeError:
    handle_it()

Cuando Python encuentra un error dentro del bloque ` try `, salta al bloque ` except ` correspondiente en lugar de bloquear el programa.

También puedes ampliar este patrón con las cláusulas « else » y « finally »:

try:
    do_something()
except ValueError:
    print("Bad value!")
else:
    print("All good.")
finally:
    clean_up()

Aquí tienes un ejemplo básico que funciona:

try:
    x = int(input("Enter a number: "))
except ValueError:
    print("That wasn’t a number.")
else:
    print("You entered", x)
finally:
    print("Done.")

except se encarga del error, else solo se ejecuta si todo ha funcionado correctamente y, por último, siempre se ejecuta, incluso si pulsas Ctrl-C o sales.

Podés dominar los fundamentos del manejo de entradas de usuario en Python, desde indicaciones básicas hasta técnicas avanzadas de validación y manejo de errores, utilizando nuestro curso « » (Introducción al manejo de entradas de usuario en Python). Manejo, validación y mejores prácticasTutorial de .

Manejo de múltiples excepciones

A veces, un solo except no es suficiente. Las diferentes rutas de código pueden fallar de diferentes maneras, y capturar todo lo que se te ocurra con un simple «except» no es precisamente útil, ya que puede ocultar errores y convertir la depuración en un dolor de cabeza.

Supongamos que intentas convertir algo a un número entero y luego dividirlo. Esto es lo queno debes haceren :

try:
    result = int(user_input) / 2
except:
    print("Something went wrong.")

Esto lo capta todo, incluso cosas que probablemente no pretendías ocultar, como errores tipográficos en nombres de variables o excepciones inesperadas que apuntan a problemas reales.

En su lugar, sé específico:

try:
    result = int(user_input) / 2
except ValueError:
    print("That wasn't a number.")
except ZeroDivisionError:
    print("Division by zero?")

Si tienes varios tipos de excepciones que deben tratarse de la misma manera, puedes agruparlos así:

try:
    result = some_function()
except (TypeError, ValueError):
    print("Something was wrong with the data.")

De esta manera, seguirás teniendo claro lo que podría salir mal, sin duplicar el mismo bloque una y otra vez.

Y luego está except Exception, que es mejor que un simple except, pero sigue siendo un poco demasiado amplio. Es mejor que te centres en los errores específicos que esperas encontrar.

Uso de los bloques else y finally

Cuando el código dentro del bloque « try » se ejecuta correctamente y no se produce ninguna excepción, Python ejecuta el bloque « else ». 

try:
    user_id = get_user_id()
except LookupError:
    print("User not found.")
else:
    print("Welcome, user", user_id)

Esto te ayuda a separar la lógica de gestión de excepciones de la ruta feliz, lo que facilita la lectura.

Luego está finally. No importa lo que haya pasado; funciona sin importar nada. ¿Excepción? Sigue funcionando. ¿Sin excepción? Sigue funcionando. ¿El programa se bloquea con Ctrl-C? Sigue funcionando. Ideal para limpiar cosas:

try:
    f = open("data.txt")
    process(f)
except IOError:
    print("Couldn’t open file.")
finally:
    f.close()

Recuerda que, si el archivo nunca se ha abierto, es posible que f ni siquiera exista, así que ten cuidado. Puedes utilizar el gestor de contexto de Python (with open(...) as f:) cuando trabajes con archivos. Es más seguro.

Si deseas aprender técnicas clave, como el manejo de excepciones y la prevención de errores, para manejar eficazmente la excepción KeyError en Python, te recomiendo nuestro tutorial Excepciones KeyError en Python y cómo solucionarlas .

Mejores prácticas y errores comunes de try-except en Python

Seamos sinceros: escribir bloques de « try‑except » es todo un arte. Si se hacen bien, evitan que tu programa se bloquee. Si se hace mal, los errores quedan tan ocultos que no los notarás hasta que tu aplicación falle y los usuarios empiecen a quejarse.

Aquí hay algunos hábitos que vale la pena desarrollar:

Mantén bien ajustados los bloques de try. No envuelvas cien líneas de código dentro de un solo try. Eso solo hace que sea más difícil saber qué causó el problema. En su lugar, envuelve solo el código que pueda fallar:

# Good
try:
    value = int(data)
except ValueError:
    print("Couldn’t convert.")

# Bad
try:
    # Tons of unrelated logic
    value = int(data)
    do_more()
    something_else()
except ValueError:
    print("Huh?")

Evita comprobar las condiciones antes de realizar la acción si es más fácil simplemente intentar detectar el error. Python tiene un nombre para esto: EAFP, es más fácil pedir perdón que permiso. Si estás comprobando si un archivo existe y luego lo abres, estás creando una condición de carrera. En su lugar:

try:
    with open("file.txt") as f:
        content = f.read()
except FileNotFoundError:
    print("No file.")

Este patrón evita un problema habitual en el que el archivo puede desaparecer entre la comprobación y la llamada de apertura. Simplemente pruébalo. Si falla, detecta el fallo.

Además, evita silenciar los errores capturándolos todos y sin hacer nada al respecto. No hagas esto:

try:
    something()
except:
    pass

A menos que realmente sepas lo que estás haciendo, aquí es donde los errores se esconden y se multiplican. Si tienes que silenciar, sé específico:

try:
    something()
except TimeoutError:
    # okay to ignore in this case
    pass

Y registra los errores en algún lugar. Tragártelos por completo significa que en el futuro no tendrás ni idea de qué salió mal.

Excepciones integradas frente a excepciones personalizadas

Python incluye numerosas excepciones integradas que cubren una sorprendente variedad de casos. Probablemente ya te hayas topado con algunos:

• ValueError: cuando algo tiene el tipo correcto pero un valor no válido, como int("hello").
• TypeError: cuando intentas utilizar una operación con un tipo incorrecto, como sumar una cadena y un número.
• ZeroDivisionErrorLo has adivinado, dividir entre cero.
• FileNotFoundError: intentando abrir un archivo que no existe.
• KeyError: cuando falta una clave en un diccionario.

Son útiles y, en la mayoría de los scripts o aplicaciones, son más que suficientes. Pero a veces querrás plantear algo más descriptivo, algo que tenga sentido en el mundo de tu proyecto, no solo en el de Python.

Supongamos que estás escribiendo una aplicación que procesa pedidos en línea y deseas generar un error cuando un usuario intenta comprar algo que está agotado. Podrías usar simplemente « ValueError », pero eso es un poco genérico. No le dice a la siguiente persona que lea tu código lo que ha sucedido.

Aquí es donde las excepciones personalizadas cobran protagonismo.

class OutOfStockError(Exception):
    pass

def check_inventory(product_id):
    if not in_stock(product_id):
        raise OutOfStockError(f"Product {product_id} is out of stock.")

Al crear la excepción personalizada, estás añadiendo una capa de significado. También te estás dando más control; puedes captar solo esta situación específica:

try:
    check_inventory("shirt-001")
except OutOfStockError:
    print("Sorry, that item is sold out.")

Es un detalle sin importancia, pero hace que el código sea más fácil de entender y mantener, especialmente en proyectos más grandes. Además, funciona bien con el registro y la supervisión, ya que los nombres de excepciones personalizados son mucho más fáciles de buscar que un vago « ValueError ».

Registro, reactivación y encadenamiento de excepciones

Hay un momento que se produce al depurar: ves un seguimiento, lo miras fijamente y te das cuenta de que no tienes ni idea de por qué ha fallado algo. Ahí es donde entra en juego la tala. No se trata solo de registrar los errores, sino de proporcionar al tú del futuro (o a tu equipo) las pistas necesarias para averiguar qué salió mal.

Supongamos que estás detectando una excepción y deseas registrarla antes de continuar:

import logging
logging.basicConfig(level=logging.ERROR)

try:
    do_something()
except ValueError as e:
    logging.error("Failed to do something: %s", e)
    raise

Es importante el comando « raise » al final, ya que vuelve a lanzar la misma excepción después de registrarla. Sin él, simplemente te has tragado el error. A veces eso está bien, pero normalmente no lo está.

Luego está el truco de « raise from ». Esta opción es para cuando estás gestionando un error, pero necesitas generar otro y no quieres perder el original. Python te permite encadenarlos:

try:
    connect_to_database()
except TimeoutError as e:
    raise ConnectionError("Database unavailable.") from e

De esta manera, el seguimiento cuenta toda la historia. Aparece el nuevo error « ConnectionError », pero también se muestra el error « TimeoutError » que lo ha provocado. 

También puedes suprimir el error original (lo que normalmente no deberías hacer) de esta manera:

raise ConnectionError("Just this error, nothing else.") from None

Pero, a menos que tengas una buena razón, mantener la cadena completa ayuda a todos a comprender qué salió mal y cómo se agravó la situación.

Puedes aprender los fundamentos del registro en Python en nuestro tutorial sobre el registro en Python.

Ejemplos reales y casos de uso

Una cosa es hablar del manejo de excepciones en abstracto, pero se entiende mejor cuando lo ves en código real.

Tomemos como ejemplo la entrada del usuario. Pregunta a cualquiera que haya creado alguna vez una herramienta de línea de comandos o un validador de formularios: los usuarios introducen las cosas más extrañas. ¿Pides un número? Alguien escribirá «doce». O pega un número de teléfono. O simplemente presiona Intro. Sucede.

En lugar de escribir una larga lista de comprobaciones hipotéticas, puedes hacer lo siguiente:

while True:
    user_input = input("Enter a number: ")
    try:
        number = int(user_input)
        break
    except ValueError:
        print("Try again with a whole number.")

Este código no entra en pánico cuando recibe datos basura. Le indica al usuario que lo intentes de nuevo y repite el proceso hasta que todo esté bien. Mucho más limpio que apilar sentencias if para cada caso extremo.

Aquí hay otro: leer desde un archivo que podría no existir.

try:
    with open("config.json") as f:
        settings = f.read()
except FileNotFoundError:
    print("Missing config file. Using defaults.")
    settings = "{}"

No es necesario comprobar si el archivo está ahí. Simplemente intenta abrirlo y, si no funciona, sigue adelante. Si hubieras comprobado antes (os.path.exists()), es posible que otra persona hubiera eliminado el archivo entre la comprobación y la apertura. Eso es una condición de carrera, no algo que quieras depurar.

Las solicitudes de red son otra mina de oro para las excepciones. No siempre puedes confiar en que Internet se comporte correctamente. Los servidores se caen. Las conexiones se caen. El DNS falla. Entonces, si estás haciendo algo como esto:

import requests

try:
    response = requests.get("https://example.com/data")
    response.raise_for_status()
except requests.exceptions.RequestException as e:
    print("Network problem:", e)

La clase base RequestException captura convenientemente casi todo lo que requests puede generar, desde tiempos de espera hasta respuestas incorrectas. No es necesario que escribas diez bloques except diferentes, a menos que quieras manejarlos de manera diferente.

Y si estás escribiendo scripts de automatización o servicios de backend, envolver la lógica clave en bloques try-except puede marcar la diferencia entre el fallo de una tarea y la caída de todo el sistema. Quieres que se registren los errores, que se vuelvan a intentar las tareas recuperables y que las irrecuperables se cierren de forma limpia, sin trazas de pila crípticas que se desplazan sin cesar por tus registros.

Aprende sobre la automatización con Python, incluidos los conceptos fundamentales, las bibliotecas clave, el trabajo con datos, el uso de mejoras de IA y las mejores prácticas de nuestro curso « » (Automatización con Python: de cero a héroe). Una guía completa Tutorial de .

Try-except Python Usos avanzados

A estas alturas, probablemente ya hayas visto lo flexible que puede ser try‑except. Pero la flexibilidad tiene dos caras. Es fácil pasar de ser servicial a descuidado sin quererlo. A continuación te explicamos cómo mantener todo bajo control.

Captura excepciones específicas. Si sabes qué podría salir mal, dilo:

try:
    result = int(data)
except ValueError:
    # Only catches invalid numbers, not everything else under the sun

Evita el uso de except:. No hagas esto a menos que estés manejando algo muy especial. Capturará cosas como KeyboardInterrupt, SystemExit y otras cosas que probablemente no quieras silenciar.

Utiliza else y finally cuando aclaren el código. No los incluyas solo porque existen. Si la ruta normal de tu código queda oculta dentro de un try, quizá sea mejor moverla a un else.

Mantén pequeños los bloques de try. Cuanto más incluyas, más difícil será averiguar qué línea ha provocado el error. Envuelve solo la parte que pueda fallar. 

Registra los errores cuando sea necesario, especialmente en producción. Incluso si no se produce un fallo, saber qué ha fallado (y cuándo) facilita mucho la depuración posterior.

Las excepciones personalizadas no son obligatorias, pero resultan útiles. Si tienes problemas específicos con la aplicación, define tus propios errores. Pueden hacer que los registros sean más legibles y que tu código sea más fácil de entender.

Una última cosa: no utilices excepciones para controlar el flujo a menos que no haya otra opción mejor. Es tentador escribir una lógica del tipo «prueba esto; si falla, haz aquello», pero si es algo que esperas que ocurra todo el tiempo, probablemente haya una forma más limpia de hacerlo.

Conclusión

Como he explicado a lo largo de este artículo, el manejo de excepciones no solo consiste en evitar fallos. Se trata de escribir código que prevea los problemas, los gestione sin dramas y siga funcionando, o se apague de una manera que tenga sentido. Es la diferencia entre que un usuario reciba un mensaje útil y que te devuelva al terminal con un seguimiento largo e ilegible.

Recomiendo encarecidamente aprender más sobre las excepciones, con algunos ejercicios prácticos, en nuestro Capítulo sobre excepciones en Python de nuestro curso OOP en Python.