Uso de kwargs para crear un cliente de APIs flexible

Clase 8 de 25 • Curso de Python Intermedio para Entornos virtuales y PEP8

Resumen

Domina cómo usar parámetros nombrados y dinámicos en Python para construir un API client flexible. Aquí verás cómo los keywords (también llamados kwargs) se reciben como diccionario, cómo combinarlos con args y cómo aplicar el doble asterisco para fusionar configuraciones y seleccionar entre News API y Guardian con una sola función.

¿Qué son keywords y por qué combinarlos con args?

Los keywords se envían con nombre y se reciben con doble asterisco: kwargs. A diferencia de args, que solo capturan valores posicionales, kwargs agrupa parámetros nombrados en un diccionario. Esto permite pasar pares key-value y trabajar con ellos de forma dinámica y clara.

kwargs es un diccionario. Permite inspeccionar keys y valores de entrada.
Key-value nombrado. Claridad al invocar funciones y reutilizarlas.
Combinación con args. Flexibilidad total con parámetros posicionales y nombrados.

Ejemplo base de impresión de keywords:

def ejemplo_keywords(**keywords):
    print(type(keywords))  # dict
    print(keywords)        # {'llave': 'valor', ...}
    print('---')

# llamada de ejemplo
# ejemplo_keywords(llave='valor', api_key='demo')

¿Cómo implementar kwargs en una función flexible?

La idea central: crear una función única que, según el nombre de la API, seleccione el API client correcto, mezcle una configuración base con parámetros dinámicos, y ejecute la llamada. El resultado es una función robusta y reutilizable.

def fetch_news(api_name, *args, **keywords):
    """
    función flexible para conectar con la API.
    """
    # configuración base común a múltiples APIs
    base_config = {
        "timeout": ...,  # por defecto
        "retries": ...,  # por defecto
    }

    # fusión de configuración: base + parámetros nombrados entrantes
    config = {**base_config, **keywords}

    # selección de cliente por nombre
    api_clients = {
        "newsAPI": news_api_client,   # referencia a cliente de News API
        "Guardian": guardian_client,  # referencia a cliente de Guardian
    }

    client = api_clients[api_name]
    return client(*args, **config)

¿Cómo funcionan los diccionarios y el doble asterisco?

**Desempaquetado con : copiar pares key-value dentro de otro diccionario.
Mezcla de configuraciones: {**base_config, **keywords} agrega y sobrescribe de forma limpia.
**Invocación con : client(*args, **config) pasa parámetros de forma explícita.

¿Qué orden de parámetros es correcto en Python?

Obligatorios primero: por ejemplo, api_name al inicio.
Luego args: parámetros posicionales variables.
**Al final kwargs: parámetros nombrados y dinámicos.

¿Cómo se selecciona el cliente por nombre?

Mapa de clientes: un diccionario api_clients con el nombre como clave.
Búsqueda directa: client = api_clients[api_name] elige el ejecutor correcto.
Una sola función: orquesta múltiples fuentes como News API y Guardian.

¿Cómo usarlo con News API y Guardian?

Con una misma función puedes enviar parámetros distintos y obtener resultados de diferentes orígenes. La clave está en pasar keywords específicos de cada servicio, manteniendo una base_config con timeout y retries.

Ejemplo con News API.
Ejemplo con Guardian con sección y fecha.
Misma función, distintos parámetros, mismo flujo.

Invocaciones ilustrativas:

# News API
fetch_news(
    "newsAPI",
    api_key="demo",
    query="noticias de Python",
)

# Guardian
fetch_news(
    "Guardian",
    api_key="Demoguardian",
    section="sports",
    from_date="2020-10-10",
)

Conceptos y habilidades que te llevas:

**kwargs como diccionario para parámetros nombrados.
**args para valores posicionales flexibles.
Key-value explícito para legibilidad y mantenimiento.
**Desempaquetado con ** para fusionar configuraciones.
Configuración base con timeout y retries reutilizable.
Selección de cliente por nombre mediante diccionario de API clients.
Orden correcto de parámetros: obligatorios, args, **kwargs.

¿Tienes dudas sobre cómo adaptar los parámetros de tu API favorita o cómo estructurar tu base_config? Deja tu pregunta y cuéntanos tu caso para ayudarte a concretarlo.

Jose Antonio Pinto Gimeno

student•

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)

Patricio Manuel Ugarte

student•

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:

Primero argumentos normales.
Después los *args.
Y por último los **kwargs.

FUENTE: El libro de Python

Francisco Ponce

student•

Aqui la pongo por si acaso

Luis Martinez

teacher•

Gracias, ese es el link!

Gabriel Obregón

student•

🧩 🌐 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:

🔍 Permiten inspeccionar claves y valores.
🧱 Aumentan la claridad al invocar funciones.
🌀 Se combinan con *args para mayor flexibilidad.

🔸 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:

Seleccione el cliente de API correcto.
Mezcle una configuración base con parámetros dinámicos.
Ejecute la llamada final.

📄 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:

{**base_config, **keywords} → mezcla configuraciones.
client(*args, **config) → pasa argumentos nombrados al ejecutar la función.

✅ 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.

Enrique Alexis Lopez Araujo

student•

¡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.

Argenis Daniel Nieves Berroeta

student••

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! 🙂

Gorka Gallardo Castany

student•

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.

*args es la CIEGA, SORDA Y UN POCO TONTA: Eso implica que el orden de los parámetros introducidos SÍ importa. Únicamente se queda con la posición de cada parámetro introducido y actúa en consecuencia (como una fila de personas).
**kwargs es la LISTA Y ORGANIZADA (tu crush) del grupo: Sabe dónde va cada cosa independientemente del orden en el que lo pongamos (siempre y cuando le pongamos su correspondiente key para indicarle a dónde va el value).

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"))

Luis Martinez

teacher•

**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.

Carlos alexis Perez

student•

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)

Luis Martinez

teacher•

Es un buen comienzo, buena suerte con los bitcoins :D

"""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)

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"))

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"))

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)

Uso de kwargs para crear un cliente de APIs flexible

Código Pythónico y Funcional

Python intermedio: prácticas profesionales con app de noticias e IA

Configuración de PEP 8 y formateo automático con Ruff en Python

Sintaxis de list, dict y set comprehensions en Python

Comprensiones anidadas para agrupar y filtrar datos en Python

Formateo de strings con f-strings en Python

Modificadores de formato avanzados en FStrings para números y fechas

Calidad y Profesionalismo del Código

Argumentos dinámicos *args en funciones Python

Uso de kwargs para crear un cliente de APIs flexible

Integración de Python con News API usando parámetros dinámicos

Control de errores en Python con try y except

Manejo de Datos y Recursos

Uso del bloque finally para liberar recursos en Python

Creación de excepciones personalizadas en Python

Anotaciones de tipo con type hints en Python

Tipado de funciones y estructuras de datos en Python

Documentación en Python con docstrings y PEP 257

Optimización y Pruebas

Entornos virtuales en Python: qué son y por qué los necesitas

Creación y gestión de entornos virtuales con venv en Python

Creación de entornos virtuales en Windows con Python

Creación de Aplicaciones de Consola

Gestión moderna de dependencias Python con UV y pyproject

Modularización de código Python con responsabilidad única

Paquetes Python: de estructura plana a código modular

Función enumerate en Python para indexar listas automáticamente

Filtrado de listas con filter en Python

Función map para calcular tiempo de lectura en Python

Conexión de OpenAI API con variables de entorno en Python