Contenido del curso
Jose Antonio Pinto Gimeno
Ignacio Solís Aguiluz
Andres Herney Salcedo Lopez
Luis Pelicó
Francisco Ponce
Luis Martinez
Joseph Poveda Flores
Gabriel Obregón
Patricio Manuel Ugarte
Argenis Daniel Nieves Berroeta
Gorka Gallardo Castany
Luis Martinez
Enrique Alexis Lopez Araujo
María Elena Correa Cano
Cristian Fabricio Rodriguez Romero
Cristian Fabricio Rodriguez Romero
Ulises Rodríguez Candela
David perez
José Eduardo Vinagre de Dios
Richard Delfin Berna Capo
Oswaldo Yagual
Carlos Madrigal Ramos
Carlos alexis Perez
Luis Martinez
Aqui esta mi función real para obtener las noticias de python:
Primero declaro las importaciones necesarias:
from pprint import pprint import requests
Despues defino las constantes:
API_KEY = "tu api key aquí" API_ENDPOINT = "https://newsapi.org/v2/everything" API_TIMEOUT = 30
Y por ultimo la definición de la función y la llamada:
"""Llamada real a la API NewsAPI con kwargs y requests""" def get_news_from_newsapi(query, api_key=API_KEY, **kwargs): url = API_ENDPOINT params = { "q": query, "apiKey": api_key, **kwargs, } return requests.get(url, params=params) response = get_news_from_newsapi( "Python", language=DEFAULT_LANGUAGE, timeout=API_TIMEOUT ) response_data = response.json() pprint(response_data)
Buenísimo, muchísimas gracias por compartir tu versión. 😃
No se si sea al unico que le pase pero como no se de apis estoy re perdido y me toco por otros metodos entender el tema
Yo igual.
Aqui la pongo por si acaso
Gracias, ese es el link!
Gracias
🧩 🌐 Parámetros nombrados y dinámicos en Python
🧠 IDEA CENTRAL
Usa *args y **kwargs para crear funciones flexibles, capaces de: 🔸 Aceptar cualquier cantidad de parámetros.
🔸 Fusionar configuraciones.
🔸 Conectarse a múltiples APIs (News API, The Guardian, etc.) con una sola función.
🔹 1. Qué son los keywords (**kwargs)
📘 Definición: Son parámetros nombrados que se reciben como diccionario. Cada elemento tiene una clave y un valor.
📍 Sintaxis:
def ejemplo_keywords(**keywords):
print(type(keywords)) # dict
print(keywords)
🧩 Ventajas:
🔸 2. Diferencias entre args y kwargs
🎯 *args → captura valores posicionales (sin nombre).
🎯 **kwargs → captura parámetros nombrados (clave=valor).
🧠 Juntos permiten crear funciones universales y adaptables.
🔧 3. Función flexible con kwargs
💡 Objetivo: Tener una única función que:
📄 Ejemplo:
def fetch_news(api_name, *args, **keywords):
base_config = {
"timeout": ..., # por defecto
"retries": ..., # por defecto
}
config = {**base_config, **keywords}
api_clients = {
"newsAPI": news_api_client,
"Guardian": guardian_client,
}
client = api_clients[api_name]
return client(*args, **config)
⚙️ 4. Cómo funciona el doble asterisco (**)
✨ Uso clave: Desempaquetar o fusionar diccionarios.
🧩 Ejemplos:
✅ Resultado: Código más limpio, sin sobrescribir manualmente parámetros.
🧭 5. Orden correcto de parámetros
🧱 Regla de oro en Python:
1️⃣ Parámetros obligatorios
2️⃣ *args → posicionales variables
3️⃣ **kwargs → nombrados y dinámicos
🧩 Ejemplo:
def fetch_news(api_name, *args, **kwargs):
...
🔍 6. Selección dinámica del cliente
🔧 Cómo funciona:
Se define un diccionario con los clientes de API: api_clients = {
"newsAPI": news_api_client,
"Guardian": guardian_client,
}
El parámetro api_name selecciona el cliente correcto: client = api_clients[api_name]
💡 Permite conectar múltiples servicios con una sola función.
Mezclando *args y **kwargs
Una vez entendemos el uso de *args y **kwargs, podemos complicar las cosas un poco más. Es posible mezclar argumentos normales con *args y **kwargs dentro de la misma función. Lo único que necesitas saber es que debes definir la función en el siguiente orden:
FUENTE: El libro de Python
Hola
La única parte que se me complico entender fueron las ultimas dos lineas.
client = api_clients[api_name] client(*args, **config)
Por que me puse a investigar sobre funciones y logre entender.
Aquí va la explicación para quienes como yo se perdieron un poco,
En Python, es diferente escribir el nombre de la función y escribir el nombre con paréntesis:
guardian_client() Ejecuta la función y da el resultado
guardian_client Hace referencia a la funcion misma (el codigo)
Con:
client = api_clients[api_name]
Le indicamos a la variable client que se convierta en un apodo o referencia temporal para la función elegida.
Luego con:
client(*args, **config)
Ejecutamos como si escribiéramos directamente el nombre de la función con los argumentos que le estamos pasando, por ejemplo:
guardian_client(...)
Si les pasa como yo, y no entienden algo, no se desanimen, paren un momento e investiguen lo que no entiendan. Precisamente así afianzamos conocimientos y salimos de dudas.
Éxito! 🙂
Se me ha dificultado un poco esta clase debido a que no entendía bien el uso de *args en todo esto, lo cual me llevó a caer en confusiones que complicaron mi entendimiento.
Al final llegué a la siguiente conclusión:
*args y **kwargs son dos tuberías paralelas; hacen cosas similares PERO su forma de actuar es diferente.
Piensa en **kwargs como un cartero en pleno reparto: El cartero tiene una carta para "Juan Pérez, Av. X, Edificio 24, Apto 2-A". Lo que hace es ir directo al edificio, buscar el buzón "2-A" y comprobar que pone "Juan Pérez". En ese momento, asigna la carta a su buzón exacto. No le importa si esa carta estaba arriba o abajo en su saca, la entrega por la dirección.
Por eso, si probáis a eliminar *args de la definición de la función (y del return), veréis que el código sigue funcionando sin problemas con los ejemplos que hemos visto.
¿Pero por qué debemos poner *args de todas formas? La respuesta es sencilla: flexibilidad. Porque en un futuro podemos estar trabajando con una API sencilla (o antigua) que solo acepte parámetros por posición y no por nombre (como una que solo pida API_KEY y Query en orden estricto). Al dejar *args, nuestra función estará preparada para aceptar esos datos ordenados si hiciera falta.
A continuacion pongo mi solucion al ejercicio propuesto por el teacher 🙂
He de decir que me ha costado bastante llegar hasta aqui, pero con paciencia (y leyendo la documentacion de request, sobre todo) se consigue NO HE USADO NewsApi por que han cambiado sus politicas y se ha vuelto un dolor de huevos tener acceso a la API. En el ejemplo he usado OpenLibrary (Para **kwargs) y PokeApi (Para *args)
import requests def cliente_pokemon(*args, retries=3, timeout=30, **kwargs) -> str: last_error = "Error inesperado" if not args: return "¡Error! Necesito el nombre del Pokémon en *args" pokemon = args[0] # El primer argumento es EL Bicho url = f"https://pokeapi.co/api/v2/pokemon/{pokemon}" for i in range(0, retries): try: print(f"Intento {i + 1} de conexion") response = requests.get(url, timeout=timeout) if response.status_code == 200: data = response.json() return f"✅ Capturado: {data['name'].upper()} (ID: {data['id']}) - Altura: {data['height']}" elif response.status_code == 404: return "❌ Pokemon no encontrado" except requests.Timeout: print("⚠️ Timeout... reintentando") last_error = "Timeout" except requests.ConnectionError: print("⚠️ Error de conexión... reintentando") last_error = "Error de Conexión" return f"Upss... Parece que algo ha salido mal.\nNumero de intentos -> {retries}\nMotivo -> {last_error}" def book_client(**kwargs) -> str: url = "https://openlibrary.org/search.json" timeout_val = kwargs.pop("timeout", 5) retries = kwargs.pop("retries", 3) print(f"📚 Buscando en Open Library...") print(f"🔎 Filtros de búsqueda: {kwargs}") for i in range(retries): try: print(f"Intento {i + 1} de conexion") response = requests.get(url, params=kwargs, timeout=timeout_val) if response.status_code == 200: data = response.json() num_found = data.get("numFound", 0) if num_found == 0: return "❌ No se encontraron libros." first_book = data["docs"][0] titulo = first_book.get("title", "Sin título") autor = first_book.get("author_name", ["Desconocido"])[0] year = first_book.get("first_publish_year", "N/A") return ( f"✅ENCONTRADO ({num_found} total): '{titulo}' de {autor} ({year})" ) else: print(f"❌Error API: {response.status_code}\nReintentando...") except requests.Timeout: print("⏱️ Error: La busqueda tarda demasiado.\nReintentando...") return "❌ Ha ocurrido un error inesperado..." def fetch_api(api_name, *args, **kwargs): base_config = {"retries": 3, "timeout": 30} config = { **base_config, **kwargs, } # Recuerda: El orden importa, si pusieramos primero **kwargs y luego **base_config, la configuracion por defecto podria sustiruir a la configuracion personalizada api_clients = {"pokemon": cliente_pokemon, "book": book_client} client = api_clients.get( api_name ) # Mejor usar get, por que si intentamos acceder mediante el nombre de la key y resulta que no existe hace kabooomm if client: return client(*args, **config) return f"❌ Error: La API '{api_name}' no existe o no esta configurada." if __name__ == "__main__": print(fetch_api("pokemon", "torchic")) # mi pokemon favorito jsjs print("=" * 10) print(fetch_api("book", title="harry potter"))
**kwargs en Python permite pasar un número variable de argumentos con nombre (clave-valor) a una función, los cuales se reciben dentro de la función como un diccionario.
*args en Python permite que una función acepte un número variable de argumentos posicionales (sin nombre), los cuales se agrupan automáticamente en una tupla dentro de la función; el asterisco (*) es crucial, no el nombre args, que es solo una convención para "argumentos"
Buen ejemplo! sigue practicando.
¡Claro! Aquí tienes un ejemplo en Python usando **kwargs para crear un cliente de APIs flexible, siguiendo lo visto en la clase "Uso de kwargs para crear un cliente de APIs flexible":
def fetch_news(api_name, **kwargs): """ Función flexible para conectar con la API. """ base_config = {"timeout": 10, "retries": 3} # Combina la configuración base con los kwargs config = {**base_config, **kwargs} api_clients = { "NewsAPI": "NewsAPI_client_instance", # Simulación "Guardian": "Guardian_client_instance" # Simulación } client = api_clients.get(api_name) if client: print(f"Conectando a {api_name} con configuración: {config}") # Aquí iría la lógica real para llamar al cliente con la configuración return f"Resultado de {client} con {config}" else: return "API no reconocida" # Ejemplo de uso print(fetch_news("NewsAPI", query="Python", language="es", country="co")) print(fetch_news("Guardian", section="technology", from_date="2023-01-01"))
Este código simula cómo **kwargs te permite pasar parámetros dinámicos (como query, language, section) que se fusionan con una configuración base y se usan para interactuar con diferentes APIs, como se explicó en la clase.
import requests API_KEY = "MI_API_KEY" API_ENDPOINT = "https://newsapi.org/v2/everything" API_TIMEOUT = 30 def buscar_noticias(**kwargs): """ Función para buscar noticias usando NewsAPI """ # en el diccionario de params solo se incluye lo estrictamente necesario para la consulta, no la configuración general params = { "apiKey": API_KEY, **kwargs, # Agrega los parámetros específicos de la búsqueda } # params=params es donde se le pasa mi diccionario de parámetros a la función requests.get, que se encargará de convertirlo en una cadena de consulta adecuada para la URL # Timeout es propio de get, por eso no se agrega en el diccionario de params try: respuesta = requests.get(API_ENDPOINT, params=params, timeout=API_TIMEOUT) # Este método levanta una excepción si el status code es de error (4xx o 5xx) respuesta.raise_for_status() return respuesta.json() # Devuelve la respuesta como un diccionario de Python except requests.exceptions.RequestException as e: # Aquí manejamos el error print(f"Error en la petición: {e}") return None # Uso de la función noticias = buscar_noticias(q="QA", language="es") if noticias: print("Éxito al obtener las noticias") else: print("Falló la obtención de noticias")
import requests
API_KEY = "b558b3fba31c4e018490bb95140e30f2"
API_ENDPOINT = "https://newsapi.org/v2/everything"
API_TIMEOUT = 30
def buscar_noticias(**kwargs):
"""
Función para buscar noticias usando NewsAPI
"""
# en el diccionario de params solo se incluye lo estrictamente necesario para la consulta, no la configuración general
params = {
"apiKey": API_KEY,
**kwargs, # Agrega los parámetros específicos de la búsqueda
}
# params=params es donde se le pasa mi diccionario de parámetros a la función requests.get, que se encargará de convertirlo en una cadena de consulta adecuada para la URL
# Timeout es propio de get, por eso no se agrega en el diccionario de params
try:
respuesta = requests.get(API_ENDPOINT, params=params, timeout=API_TIMEOUT)
# Este método levanta una excepción si el status code es de error (4xx o 5xx)
respuesta.raise_for_status()
return respuesta.json() # Devuelve la respuesta como un diccionario de Python
except requests.exceptions.RequestException as e:
# Aquí manejamos el error
print(f"Error en la petición: {e}")
return None
# Uso de la función
noticias = buscar_noticias(q="QA", language="es")
if noticias:
print("Éxito al obtener las noticias")
else:
print("Falló la obtención de noticias")
recuerda que las API_KEYS siempre deben ocultarse y nunca publicarse, ya que pueden ser utilizadas por terceros.
from dotenv import load_dotenv import os import requests load_dotenv() def news_api_client(api_key, query, timeout=30, retries=3): url = f"https://newsapi.org/v2/everything?q={query}&pageSize=5&apiKey={api_key}" request = requests.get(url, timeout=timeout) titles = [article['title'] for article in request.json()["articles"]] print("\n".join(titles)) 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] client(**config) # Prueba para news api news_api_key = os.getenv("API_KEY_NEWS_API") fetch_news('newapi', api_key=news_api_key, query="Artificial Intelligence")
Trae muchisima info pero aqui esta:
def newsapi_client(api_key, query, total_results, timeout=30, retries=3): response = requests.get( f"https://newsapi.org/v2/everything?q={query}&apiKey={api_key}&pageSize={total_results}" ) # print(response.status_code) # print(response.text) data = response.json() return data
import requests
url = "https://jsonplaceholder.typicode.com/posts"
respuesta = requests.get(url)
datos = respuesta.json()
for noticia in datos:
print(f"Título: {noticia['title']}")
print(f"Descripción: {noticia['body']}")
print(f"noticia numero: {noticia['id']}")
print("-" * 50)
import os import requests from dotenv import load_dotenv
API_TIMEOUT_DEFAULT = int(os.getenv("API_TIMEOUT_DEFAULT", 30)) MAX_RETRIES_DEFAULT = int(os.getenv("MAX_RETRIES_DEFAULT", 3)) DEFAULT_LANGUAGE = "es" # PEP 8: Uso de comillas dobles para cadenas de texto url_template = os.getenv("URL_TEMPLATE") api_key_news_api = os.getenv("API_KEY_NEWS_API")
def newsapi_client( api_key, query, timeout=API_TIMEOUT_DEFAULT, retries=MAX_RETRIES_DEFAULT ): print( f"Conectando a NewsAPI con api_key={api_key}, query={query}, timeout={timeout}, retries={retries}" ) response = requests.get(url_template.format(query, api_key), timeout=timeout) if response.status_code != 200: raise Exception(f"Error al conectar con NewsAPI: {response.status_code}") print(response.json()) return response.json()
Resumén rápido:
*args = Tupla/Array **kwargs = Diccionario
import requests def newsapi_client(api_key, query, timeout=30, retries=3): url= "https://newsapi.org/v2/everything" params= { "q": query, "apikey": api_key, } responde= requests.get(url, params(), timeout()) return response.json() def fetch_news(api_name, *args, **kwargs): base_config = { "timeout": 30, "retries": 3, } config = { **base_config, **kwargs } api_clients = { "Newsapi": newsapi_client, } client = api_clients[api_name] return client(*args, **config)
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}") base_config = {"timeout": 30, "retries": 3, "language": "es"} config = { **base_config, **kwargs, } api_client = { "newsapi": news_api_client, "theguardian": guardian_client, } client = api_client[api_name.lower()] return client(*args, **config) # Definimos los clientes que usarán la librería 'requests' def newsApi_client(*args, **config): url = args[0] try: response = requests.get( url, params={ "q": config.get("query"), "language": config.get("language"), "apiKey": "087d58a2b9524315b92c2a4911ba9926", }, timeout=config.get("timeout"), ) # Lanza una excepción si el código no es 2xx (éxito) response.raise_for_status() return response.json() except requests.exceptions.HTTPError as errh: return {"error": f"Error HTTP: {errh}", "status": response.status_code} except requests.exceptions.ConnectionError: return {"error": "Error de conexión: Revisa tu internet."} except requests.exceptions.Timeout: return {"error": "Error de tiempo de espera: El servidor tardó mucho."} except Exception as e: return {"error": f"Ocurrió un error inesperado: {e}"} # 2. función original (el orquestador) def fetch_news(api_name, *args, **kwargs): base_config = {"timeout": 30, "retries": 3, "language": "es"} config = {**base_config, **kwargs} api_client = {"newsapi": newsApi_client} # llamamos a la función cliente client = api_client[api_name.lower()] return client(*args, **config) # Peticion resultado = fetch_news( "newsapi", "https://newsapi.org/v2/everything", query="IA", timeout=10 ) print("Resultado de la petición a NewsAPI:") print(resultado)
creo, y espero, haberlo hecho bienxd
decidi hacerlo con otra api para complicarme un poco mas la vida
from pprint import pprint import requests API_URL = "https://api.coingecko.com/api/v3/coins/markets" API_TIME = 30 def get_price_api( vs_currency="usd", **kwargs): url = API_URL params = { "vs_currency": vs_currency, **kwargs, } response = requests.get(API_URL, params=params, timeout=API_TIME) response.raise_for_status() return response.json() response_data = get_price_api( ids="bitcoin", order="market_cap_desc", per_page=10, page=1, sparkline=False ) pprint(response_data)
Es un buen comienzo, buena suerte con los bitcoins :D
