Contenido del curso
Cómo manejar errores con try y except en Python
Cuando desarrollas software en Python, tarde o temprano algo va a fallar: un servidor caído, un usuario que escribe texto donde esperabas un número o una división por cero. Aprender a usar try y except para manejar errores te permite anticipar esos fallos y mostrar mensajes claros en lugar de dejar que el programa se rompa. Es una habilidad clave para cualquier persona que empieza a programar y quiere escribir código robusto.
Por qué necesitas manejar errores al recibir datos
Cada vez que conviertes o recibes datos, abres la puerta a un fallo. Piensa en un servidor de noticias caído: al hacer el request obtienes un error y toda la ejecución se detiene [00:12].
El ejemplo más simple lo ves con una división. Si pides dos números al usuario con la función input, los conviertes a integer y divides el primero entre el segundo, todo funciona bien con 10 y 2. Pero si el usuario escribe 0 como divisor, Python lanza un error porque dividir por cero no está permitido [01:47].
¿Qué hace try except en Python? Ejecuta el bloque dentro de
tryy, si ocurre un error, salta al bloqueexceptpara manejarlo sin detener todo el programa.
python try: a = int(input("Digita un número: ")) b = int(input("Digita otro número: ")) resultado = a / b print(resultado) except Exception as e: print(e)
Al envolver el código en un try e indentar, le dices a Python: intenta esto, y si falla, ve al except.
Cómo capturas un error con Exception y la palabra as
La clase Exception es la clase base con la que todos los errores están tagueados [02:31]. Usar except Exception as e te permite guardar el error en la variable e y trabajar con él, ya sea imprimiéndolo o mostrando un mensaje.
Aquí aparece un detalle importante. Si el error ocurre antes de que se defina resultado, verás un segundo fallo porque esa variable nunca llegó a existir. La solución es definir un valor por defecto, como None, para que el programa no se rompa dos veces [03:26].
Con eso resuelto, puedes reemplazar el error técnico que Python muestra a los desarrolladores por un mensaje amable para el usuario, como "Esta división no está permitida, no puedes dividir por cero".
Cuándo debes ser específico con el tipo de error
Capturar todo con Exception funciona, pero esconde información valiosa. Si el usuario escribe "hola" en lugar de un número, Python lanza un ValueError con el mensaje invalid literal for int [05:04]. Ese es un error distinto al de la división.
La recomendación es capturar la excepción real que ocurre. Así evitas atrapar errores que no esperabas y no necesitas llenar tu código de múltiples try y except.
python try: a = int(input("Digita un número: ")) b = int(input("Digita otro número: ")) print(a / b) except ValueError: print("El valor que digitaste no es un número válido") except ZeroDivisionError: print("No está permitido dividir por cero")
Para descubrir qué clase de error debes capturar, imprime e junto con type(e). Eso te muestra exactamente el nombre de la excepción, por ejemplo ValueError o ZeroDivisionError, y así sabes cuál poner en tu except [06:52].
¿Cuál es la diferencia entre ValueError y ZeroDivisionError? ValueError aparece cuando conviertes un dato inválido, como texto a número. ZeroDivisionError ocurre solo cuando intentas dividir entre cero.
Con estos dos except tienes tu código protegido contra los dos errores más comunes del usuario: texto donde esperabas números y una división por cero.
Qué buenas prácticas debes seguir con try except
Controlar errores es útil, pero hay tres recomendaciones clave para no abusar de esta herramienta [09:15]:
try y except solo donde realmente esperas errores. Si lo pones en todo tu código, dejará de ser legible.Exception. Ser preciso facilita el debugging y te permite mostrar mensajes de error correctos según cada situación.Un dato práctico: si tu código estuviera dentro de una función, podrías usar un return dentro del except para detener el resto de la ejecución de forma limpia [08:34].
¿Por qué no debo capturar todos los errores con Exception? Porque ocultas la causa real del fallo y complicas encontrar el problema. Ser específico te da mensajes útiles y un debugging más rápido.
Como reto para practicar, aplica try y except al método que conecta con la News API. Cambia la API key por una inválida, captura el error y muestra un mensaje avisando que la conexión falla porque la clave no es válida. ¿Te animas a intentarlo y contarnos cómo te fue?
Mauricio Zárate
Estudiante
Enrique Alexis Lopez Araujo
Estudiante
Luis Martinez
Estudiante
Leonardo Damián Paillamilla
Estudiante
Miguel Angel Moreno C.
EstudianteMario Ayala
Estudiante
Jose Antonio Pinto Gimeno
Estudiante
Gabriel Obregón
Estudiante
Cristian Fabricio Rodriguez Romero
Estudiante
Ulises Rodríguez Candela
Estudiante
Blas Martin Baez Bobadilla
Estudiante
Victor Hugo Rodríguez López
Estudiante
Ignacio Solís Aguiluz
Estudiante
Juan David Sierra Rincon
Estudiante
Carlos Madrigal Ramos
Estudiante
Juan Nicolas JIMENEZ URIBE
Estudiante
Argenis Daniel Nieves Berroeta
Estudiante
Diego Alejandro Pérez Cardona
Estudiante
Gorka Gallardo Castany
Estudiante
Juan David Santamaria Gomez
Estudiante
Francisco Alejandro Bernal Castro
EstudianteMi solución quedaría así:
def newsapi_client(api_key, query, timeout=30, retries=3): query_string = urllib.parse.urlencode({"q": query, "apiKey": api_key}) url = f"{BASE_URL}?{query_string}" try: with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") return json.loads(data) except urllib.error.HTTPError as e: print(f"No se puede conectar con el servidor. ({e})") except Exception as e: print(f"Error: {e}") return None
Si todo sale bien en el bloque try, entonces se devolverán los resultados, caso contrario se devolverá None. Así, en la función que llame a fetch_api se podrá controlar de la siguiente manera:
news = fetch_news("newsapi", api_key=API_KEY, query="Python") if news is not None: titles = [article["title"] for article in news["articles"]] print(titles)
Crees Luis, que sería mejor entonces controlar los errores en la capa más alta, en este caso controlarlos en la llamada a fetch_news? Así evitar tener try y catch en cada método?
cual seria un antipatron de usar try exept para todo?
Un antipatrón de try-except es usarlo en exceso o de forma genérica (except Exception), ya que oculta errores inesperados y dificulta la depuración. Además, puede hacer el código menos legible y más difícil de mantener.
También cuando anidamos try-except no es buena practica y puede llevarte a dolores de cabeza porque puedes ocultar errores.
Error "401 No autorizado": api_key invalido
El código de error HTTP 401 indica que la petición (request) no ha sido ejecutada porque carece de credenciales válidas de autenticación para el recurso solicitado.
¿Como capturo este error?
Un HTTPError permite preguntar si codigo de error que buscamos (en nuestro caso, el 401). Podemos preguntar si el codigo e.code es el valor 401 y indicar de forma no generica que existe un error de identificacion.
def newsapi_client(query, api_key=API_KEY, timeout=API_TIMEOUT, **kwargs): query_string = urllib.parse.urlencode({"q": query, "apiKey": api_key, **kwargs}) url = f"{API_ENDPOINT}?{query_string}" try: with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") return json.loads(data) # Verificar que la respuesta es un JSON válido return f"NewsApi: {query}, API Key: {api_key}, Timeout: {timeout}, Additional Params: {kwargs}" except urllib.error.HTTPError as e: if e.code == 401: print("Api key invalida, por favor revisa")
def newsapi_client(api_key, query, timeout=30, retries=3): """ le decimos que comvierta la consulta (query) a un formato valido para la ulr y pues la api_key es para que al mandar la consulta la api nos reconosca luego juntamos todo para que la URL este lista para hacer la consulta a la api """ query_string = urllib.parse.urlencode({"q": query, "apiKey": api_key}) url = f"{BASE_URL}?{query_string}" try: with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") return json.loads(data) #print(f"response data is : {data[:100]}") except urllib.error.HTTPError as e: #error al no tener bien la llave para la api print(F"no se ha autenticado correctamente tu solicitud {url[:15]} ... , con error error {e}") except urllib.error.URLError as e: #error al no acceder a la api por problemas de conexion o de url print(f"no se ha podido conectar para su solicitud {url[:15]} ... , con error error {e}") return f"NewsAPI: {query} con timeout:{timeout}"
def newsapi_client(api_key, query, timeout=30, retries=3): query_string = urllib.parse.urlencode({"q": query, "apiKey": api_key}) url = f"{BASE_URL}?{query_string}" try: with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") return json.loads(data) except urllib.error.HTTPError as e: if e.code == 401: print("Error de autenticacion, servidor rechazó la solicitud") print(f"Detalle del servidor: {e.code} - {e.reason}")
La verdad lo hice con ayuda de GEMINI pero voy aprendiendo de igual manera.
Mi bloque try es el siguiente:
try: response_data = fetch_news("newsapi", api_key="DEMO", query="Python") for article in response_data["articles"]: print(article["title"]) except urllib.error.HTTPError as e: print(f"Error al acceder a la API: {e.code} - {e.reason}")
🧠✨Manejo de Errores en Python con try/except
🎯 Objetivo
➡️ Evitar que tu programa se bloquee.
➡️ Mejorar la experiencia del usuario.
➡️ Mantener el código limpio, legible y seguro.
🛠️ try/except permite detectar errores y responder con mensajes útiles en lugar de rastreos técnicos.
⚙️ ¿Qué problema soluciona try/except?
💥 Cuando algo puede fallar:
✅ Con try/except puedes:
💡 Ejemplo inicial
🧾 Caso: dividir dos números ingresados por el usuario.
A = int(input("Digita un número: "))
B = int(input("Digita otro número: "))
resultado = A / B
print(resultado)
⚠️ Problemas posibles:
Sin manejo de errores → 💣 el programa se detiene. Con try/except → 🧩 el programa responde con calma y sigue funcionando.
🧩 Implementación paso a paso
1️⃣ Identifica la línea peligrosa (puede fallar).
2️⃣ Envuélvela dentro de try.
3️⃣ Usa except para definir qué hacer si algo sale mal.
try:
A = int(input("Digita un número: "))
B = int(input("Digita otro número: "))
resultado = A / B
print(resultado)
except Exception as e:
print("Ocurrió un error:", e)
print("Tipo de error:", type(e))
🪄 Mensajes posibles:
"invalid literal for int()" → ValueError.
"division by zero" → ZeroDivisionError.
🚫 Capturar ZeroDivisionError sin atrapar todo
Sé específico 🎯 cuando sabes qué error puede ocurrir.
try:
A = int(input("Digita un número: "))
B = int(input("Digita otro número: "))
resultado = A / B
print(resultado)
except ZeroDivisionError:
print("No está permitido dividir por cero.")
👍 Beneficio: solo interceptas el error esperado. 👎 Evita capturar todos los errores con Exception sin motivo.
🔢 Validar entradas (ValueError)
🧍♂️ Si el usuario escribe “hola” en lugar de un número…
❌ int() lanza ValueError. ✅ Captúralo y guía al usuario con un mensaje claro.
try:
A = int(input("Digita un número: "))
B = int(input("Digita otro número: "))
resultado = A / B
print(resultado)
except ValueError:
print("El valor digitado no es un número válido.")
except ZeroDivisionError:
print("No está permitido dividir por cero.")
🧭 Si necesitas más detalle:
except ValueError as e:
print("Error:", e)
from dotenv import load_dotenv import os import json import urllib.request # Permite hacer ajuste y configuraciones como si se trabajara con un navegador web. import urllib.parse # Permite dar un formato adecuado a la request con la libreria de arriba. load_dotenv() API_KEY=os.getenv("API_KEY_NEWS_API") BASE_URL="https://newsapi.org/v2/everything" def news_api_client(api_key, query, timeout=30, retries=3): """Funcion que se conecta al API de news api""" # Se da formato a la url con los parametros necesarios para la consulta. query_string = urllib.parse.urlencode({"q": query, "apiKey": api_key}) url = f"{BASE_URL}?{query_string}" # Se hace el request: try: with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") data = json.loads(data) return data except urllib.error.HTTPError as e: if e.code == 401: print("Api key inválida, por favor revisa.") def guardian_client(api_key, section, from_date, timeout=30, retries=3): return f"Guardian {section} desde {from_date} con timeout {timeout}" def fetch_news(api_name, **kwargs): """ Funcion flexible para conectar con la API """ # variable que contiene variables que se comparten entre las APIs base_config = { "timeout": 30, "retries": 3, } # Ahora configuramos el resto de las variables config = { **base_config, # Con el ** copiamos los valores del diccionario anterior en este **kwargs, } api_clients = { "newapi": news_api_client, "guardian": guardian_client, } client = api_clients[api_name] return client(**config) response_data = fetch_news("newapi", api_key=API_KEY, query="Python") if response_data: for article in response_data["articles"]: print(article["title"])
Reto:
def newsapi_client(api_key, query, timeout=30, retries=3): query_string = parse.urlencode({"q": query, "apiKey": api_key}) url = f"{NEWSAPI_BASE_URL}?{query_string}" try: with request.urlopen(url, timeout=timeout) as resp: data_bytes = resp.read() return json.loads(data_bytes) except HTTPError: print("API Key NO Autorizada o error con el request HTTP") except Exception as e: print(f"Error: {e} || Type: {type(e)}")
En base al ejemplo presentado, se podría implementar una estructura while True para permitir que el programa continúe solicitando los dos números hasta obtener valores válidos. Además, sería recomendable agregar una tecla o comando de salida para que el usuario pueda finalizar la ejecución del programa de manera controlada. De esta forma, se mejoraría el manejo del bloque try-except, evitando que el programa se interrumpa constantemente y deba iniciarse nuevamente.
try: response = requests.get(url, params=params, timeout=timeout) # Petición real. response.raise_for_status() # Lanza error si la API falla (ej: clave inválida). data = ( response.json() ) # Convierte el JSON recibido en un diccionario de Python. return data.get("articles", []) # Retorna la lista de artículos. except requests.HTTPError: data = response.json() # Esto lo convierte directamente en un diccionario print("Error: Clave APIs invalidad:") print(data["message"]) # Resultado: "error" print("-" * 30) return [] except Exception as e: print(f"Error detectado: {e}") print("Tipo de error:", type(e)) print("-" * 30) return []
Yo busque hacer dos bloques de try-except, uno dentro de la función y otro por fuera.
Dentro de fetch_news
try: client = api_clients[api_name] return client(*args, **config) except HTTPError as e: print(f"Error: {e}") raise except URLError as e: print(f"{e}") raise
Fuera:
try: response_data = fetch_news( "newsapi", api_key=API_KEY_INCORRECTA, query="Python", ) for article in response_data["articles"]: print(article["title"]) except HTTPError as e: print(f"Falló la API, es inválida o no autorizada: {e.code} - {e.reason}")
def fetch_news(api_name, *args, **kwargs): try: """ Docstring for fetch_news :param api_name: Description :param args: Description :param kwargs: Description """ base_config = { "timeout": 30, "retries":3 } config = { **base_config, **kwargs } api_clients = { "newapi": newsapi_client, "guardian": guardian_client } client = api_clients[api_name] return client(*args, **config) except urllib.error.HTTPError: print(f"El {list(kwargs.keys())[0]} esta erroneo") try: response_data = fetch_news("newapi", api_key = "46484287243", query="Python") for article in response_data["articles"]: print(article["title"]) except TypeError: print(f"No hay noticias")
def news_api_client(api_key, query, timeout=30, retries=3): query_string = urllib.parse.urlencode({"q": query, "apiKey": api_key}) #print(f"Query string: {query_string}") # q=Python&apiKey=087d58a2b9524315b92c2a4911ba9926 url = f"{BASE_URL}?{query_string}" #print(f"URL: {url}") try: with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") return json.loads(data) # print(f"Response data: {data[:200]}...") return ( f"NewsAPI: {api_key}, Query: '{query}', Timeout: {timeout}s, Retries: {retries}" ) except urllib.error.HTTPError as e: print(f"No se puede conectar con el servidor. ({e})") except Exception as e: return f"Error: {e}" def fetch_news(api_name, *args, **kwargs): """Funcion flexible para obtener noticias de cualquier API con opciones dinámicas.""" print(f"Fetching news from {api_name} with args: {args} and kwargs: {kwargs}") # Aquí iría la lógica para manejar las opciones y hacer la solicitud a la API base_config = {"timeout": 30, "retries": 3} config = { **base_config, **kwargs, } # Combina base_config con opciones específicas de la llamada api_client = { "newsapi": news_api_client, "theguardian": guardian_client, } client = api_client[api_name.lower()] return client(*args, **config) # Llama al cliente con la configuración combinada try: response_data = fetch_news("newsapi", api_key=API_KEY, query="Python") for article in response_data["articles"]: print(article["title"]) except TypeError as e: print(f"No Hay noticias que mostrar") except Exception as e: print(f"Error: {e}")
# Mi respuesta al Reto: ### ... def newsapi_client(api_key, query, timeout=30, retries=3): query_string = urllib.parse.urlencode({"q": query, "apiKey": api_key}) url = f"{BASE_URL}?{query_string}" try: with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") return json.loads(data) return f"NewsAPI: {query} con timeout {timeout}" except urllib.error.HTTPError as e: print(f"No se puede conectar con el servidor. ({e})") except Exception as e: print(f"Error:{e}") return None ### ... response_data = fetch_news("new_api", api_key=API_KEY, query="Python") # print(response_data.keys()) try: for article in response_data["articles"]: print(article["title"]) except Exception: print("Intenta mas tarde")
Mi respuesta al reto.
El tipo de error mostrado en consola es urllib.error.HTTPError .
try: response_data = fetch_news("newapi", api_key=API_KEY, query="python") for article in response_data["articles"]: fecha_dt = datetime.strptime(article['publishedAt'], "%Y-%m-%dT%H:%M:%SZ") print(f"-> {article['title'][:50]} {fecha_dt:%B %d, %Y}") except urllib.error.HTTPError: print('La API key es invalida')
Mi respuesta al reto es la siguiente:
try: response_data = fetch_news("newapixx", api_key = API_KEY, query="Python") # print(response_data['articles']) for article in response_data["articles"]: print(article["title"]) except Exception as e: print(f"Parece que hubo un error, el cual es: {e}")
Aqui mi solucion al reto de la clase usando la libreria requests:
def newsapi_client(api_key, query, timeout=30, retries=3): payload = {"q": query, "apiKey": KEY} last_error = None for i in range(0, retries): try: data = requests.get(BASE_URL, params=payload, timeout=timeout) response = data.json() for article in response["articles"]: print(article["title"]) return "Conexion exitosa" except requests.ConnectionError: print("Error de conxeion") last_error = "Error de conexion (ConnectionError)" except requests.ConnectTimeout: print("Tiempo de intento de conexion excedido.") last_error = "Tiempo de conexion excedido (ConnectTimeout)" except Exception as error_inesperado: last_error = error_inesperado return f"Parece que algo salio mal.\nNumero de intentos -> {retries}\nMotivo -> {last_error}" def fetch_news(api_name, *args, **kwargs): """ Funcion flexible para conectar con la API """ base_config = {"timeout": 30, "retries": 3} config = {**base_config, **kwargs} api_clients = {"newsapi": newsapi_client, "guardian": guardian_client} client = api_clients[api_name] if client: return client(*args, **config) return f"❌ Error: La API '{api_name}' no existe o no esta configurada."
def newsapi_client(api_key, query, timeout=30, retries=3): try: query_string = urllib.parse.urlencode({"q": query, "apikey": api_key}) url = f"{BASE_URL}?{query_string}" with urllib.request.urlopen(url, timeout=timeout) as response: data = response.read().decode("utf-8") return json.loads(data) except urllib.error.HTTPError as e: print("La conexión con la API de noticias esta fallando debido a una API KEY inválida") return f"NewsAPI: {query} con un timeout {timeout}"
