CÓMO INTERACTUAR CON SERVICIOS WEB EN PYTHON
Introducción a los servicios web con Python
Los servicios web son fundamentales en el desarrollo moderno, permitiendo la comunicación entre aplicaciones a través de interfaces bien definidas. Una API (Application Programming Interface) actúa como un intermediario que facilita la transferencia de datos entre sistemas. En este tutorial, exploraremos cómo interactuar con servicios web usando Python, específicamente utilizando la biblioteca requests, una herramienta poderosa y fácil de usar para realizar solicitudes HTTP. Cubriremos los métodos HTTP más comunes, como GET, POST, PUT, PATCH y DELETE, y usaremos la API de Fake Store como ejemplo práctico para demostrar cómo consumir datos, enviar información, actualizar recursos y eliminar datos. Este contenido está diseñado para desarrolladores principiantes y aquellos que desean fortalecer sus habilidades en el manejo de APIs con Python.
Las APIs son esenciales para obtener datos dinámicos de servidores remotos. Cuando visitas un sitio web, tu navegador realiza una solicitud al servidor, que responde con el contenido solicitado. De manera similar, las APIs permiten a los desarrolladores realizar solicitudes HTTP para obtener datos en formato JSON, que luego pueden procesarse en aplicaciones. En este artículo, aprenderás a realizar solicitudes HTTP, manejar respuestas, trabajar con parámetros de consulta y gestionar diferentes tipos de operaciones en una API REST.
Métodos HTTP y códigos de estado
Los métodos HTTP son comandos que indican a una API qué acción realizar sobre un recurso. Los métodos más utilizados en APIs REST incluyen:
- GET: Recupera datos existentes.
- POST: Crea nuevos datos.
- PUT: Actualiza completamente un recurso existente.
- PATCH: Actualiza parcialmente un recurso.
- DELETE: Elimina un recurso.
Cada solicitud HTTP genera una respuesta con un código de estado HTTP que indica el resultado de la operación. Estos códigos se agrupan en categorías según su propósito:
- 1xx: Respuestas informativas (poco comunes en APIs REST).
- 2xx: Operaciones exitosas (por ejemplo, 200 para éxito).
- 3xx: Redirecciones (como 301 para redirección permanente).
- 4xx: Errores del cliente (por ejemplo, 404 para recurso no encontrado).
- 5xx: Errores del servidor (como 500 para error interno).
Por ejemplo, un código 200 indica que la solicitud fue procesada correctamente, mientras que un 404 significa que el recurso solicitado no existe. Para obtener más información sobre códigos de estado, consulta la documentación de MDN Web Docs.
Endpoints de una API
Un endpoint de API es una URL pública que una aplicación cliente utiliza para acceder a recursos o datos en un servidor. En este tutorial, utilizaremos la API de Fake Store, disponible en https://fakestoreapi.com. Esta API proporciona varios endpoints para interactuar con productos, incluyendo:
- GET /products: Obtiene una lista de todos los productos.
- GET /products?limit=x: Limita la lista a x productos.
- GET /products/<product_id>: Obtiene un producto específico por su ID.
- POST /products: Crea un nuevo producto.
- PUT /products/<product_id>: Actualiza completamente un producto.
- PATCH /products/<product_id>: Actualiza parcialmente un producto.
- DELETE /products/<product_id>: Elimina un producto.
Cada endpoint realiza una acción específica según el método HTTP utilizado. Antes de comenzar, necesitamos instalar la biblioteca requests, que es ampliamente utilizada para interactuar con servicios web en Python. Para instalarla, ejecuta el siguiente comando en tu terminal:
pip install requests
Con la biblioteca instalada, estamos listos para realizar solicitudes HTTP.
Realizar una solicitud GET
El método GET es el más común para recuperar datos de una API. Es una operación de solo lectura, lo que significa que no modifica los datos en el servidor. Vamos a realizar una solicitud GET al endpoint /products para obtener una lista de productos.
import requests
BASE_URL = 'https://fakestoreapi.com'
response = requests.get(f"{BASE_URL}/products")
print(response.json())
Este script utiliza el método requests.get() para enviar una solicitud GET al endpoint /products. La respuesta es un objeto JSON que contiene una lista de productos. Cada producto es un diccionario con atributos como id, title, price, description, category, image y rating. El método .json() convierte la respuesta en un formato que Python puede interpretar, como una lista de diccionarios.
Para verificar el éxito de la solicitud, podemos inspeccionar el código de estado:
print(response.status_code)
# Salida: 200
Un código de estado 200 confirma que la solicitud fue exitosa. Si deseamos limitar la cantidad de productos devueltos, podemos usar el parámetro de consulta limit. Por ejemplo, para obtener solo tres productos:
import requests
BASE_URL = 'https://fakestoreapi.com'
query_params = {
"limit": 3
}
response = requests.get(f"{BASE_URL}/products", params=query_params)
print(response.json())
Aquí, el parámetro params en requests.get() acepta un diccionario con los parámetros de consulta. En este caso, limit=3 restringe la respuesta a los primeros tres productos. Este enfoque es útil cuando trabajamos con APIs que devuelven grandes cantidades de datos y queremos reducir la carga de datos procesada.
Para obtener un producto específico, usamos el endpoint /products/<product_id>. Por ejemplo, para recuperar el producto con ID 18:
import requests
BASE_URL = 'https://fakestoreapi.com'
response = requests.get(f"{BASE_URL}/products/18")
print(response.json())
La respuesta contiene un solo diccionario con los detalles del producto, como su título, precio y categoría. Este método es ideal para acceder a recursos individuales.
Realizar una solicitud POST
El método POST se utiliza para enviar nuevos datos a una API, creando un nuevo recurso en el servidor. En la API de Fake Store, un producto nuevo debe incluir los atributos title, price, description, image y category. Vamos a crear un nuevo producto:
import requests
BASE_URL = 'https://fakestoreapi.com'
new_product = {
"title": "test product",
"price": 13.5,
"description": "lorem ipsum set",
"image": "https://i.pravatar.cc",
"category": "electronic"
}
response = requests.post(f"{BASE_URL}/products", json=new_product)
print(response.json())
En este ejemplo, usamos requests.post() y pasamos los datos del producto en el parámetro json. Esto configura automáticamente el encabezado Content-Type a application/json, indicando que los datos enviados están en formato JSON. La respuesta incluye el nuevo producto con un id asignado por el servidor, como 21.
Si no usamos el parámetro json, debemos serializar los datos manualmente y especificar el encabezado:
import requests
import json
BASE_URL = 'https://fakestoreapi.com'
new_product = {
"title": "test product",
"price": 13.5,
"description": "lorem ipsum set",
"image": "https://i.pravatar.cc",
"category": "electronic"
}
headers = {
"Content-Type": "application/json"
}
response = requests.post(f"{BASE_URL}/products", data=json.dumps(new_product), headers=headers)
print(response.json())
Aquí, usamos json.dumps() para convertir el diccionario en una cadena JSON y establecemos el encabezado Content-Type manualmente. Ambos enfoques producen el mismo resultado, pero el primero es más limpio y recomendado para enviar datos en JSON.
Realizar una solicitud PUT
El método PUT reemplaza completamente un recurso existente con nuevos datos. Supongamos que queremos actualizar el producto con ID 21 creado anteriormente, cambiando su título y categoría:
import requests
BASE_URL = 'https://fakestoreapi.com'
updated_product = {
"title": "updated_product",
"category": "clothing"
}
response = requests.put(f"{BASE_URL}/products/21", json=updated_product)
print(response.json())
La solicitud PUT al endpoint /products/21 reemplaza todos los datos del producto con los proporcionados en updated_product. La respuesta refleja el recurso actualizado, incluyendo solo los campos enviados. Esto significa que cualquier campo no incluido en la solicitud se perderá, ya que PUT sobrescribe el recurso por completo.
Realizar una solicitud PATCH
A diferencia de PUT, el método PATCH actualiza parcialmente un recurso, modificando solo los campos especificados. Esto es útil cuando queremos cambiar un solo atributo, como la categoría del producto:
import requests
BASE_URL = 'https://fakestoreapi.com'
updated_product = {
"category": "electronic"
}
response = requests.patch(f"{BASE_URL}/products/21", json=updated_product)
print(response.json())
En este caso, requests.patch() actualiza solo la categoría del producto con ID 21, dejando los demás campos intactos. La respuesta muestra el producto con la categoría actualizada, mientras que el título y otros atributos permanecen sin cambios. Este método es ideal para actualizaciones parciales de recursos.
Realizar una solicitud DELETE
El método DELETE elimina un recurso de la API. Para eliminar el producto con ID 21:
import requests
BASE_URL = 'https://fakestoreapi.com'
response = requests.delete(f"{BASE_URL}/products/21")
print(response.json())
La solicitud DELETE al endpoint /products/21 elimina el producto especificado. La respuesta generalmente confirma la eliminación, aunque el contenido exacto depende de la implementación de la API.
Manejo de errores y mejores prácticas
Cuando trabajas con APIs, es crucial manejar errores para garantizar que tu aplicación sea robusta. Los códigos de estado 4xx y 5xx indican problemas en la solicitud o el servidor. Puedes manejar estos errores usando bloques try-except:
import requests
BASE_URL = 'https://fakestoreapi.com'
try:
response = requests.get(f"{BASE_URL}/products/invalid")
response.raise_for_status() # Lanza una excepción para códigos 4xx/5xx
print(response.json())
except requests.exceptions.HTTPError as err:
print(f"Error HTTP: {err}")
except requests.exceptions.RequestException as err:
print(f"Error en la solicitud: {err}")
En este ejemplo, intentamos acceder a un endpoint inválido (/products/invalid). El método raise_for_status() verifica si la respuesta contiene un código de error y lanza una excepción si es necesario. Esto permite manejar errores como 404 (no encontrado) o 500 (error del servidor) de manera elegante.
Otra buena práctica es validar los datos antes de enviar solicitudes POST o PUT. Por ejemplo, asegúrate de que los campos requeridos estén presentes y tengan el formato correcto. También es recomendable usar variables de entorno para almacenar URLs base o claves de API, en lugar de codificarlas directamente en el script.
import os
import requests
BASE_URL = os.getenv('API_BASE_URL', 'https://fakestoreapi.com')
response = requests.get(f"{BASE_URL}/products")
print(response.json())
Esto hace que el código sea más seguro y fácil de mantener, especialmente en entornos de producción.
Conclusiones
Interactuar con servicios web usando Python y la biblioteca requests es una habilidad esencial para desarrolladores que trabajan con APIs REST. En este tutorial, exploramos cómo realizar solicitudes HTTP como GET, POST, PUT, PATCH y DELETE utilizando la API de Fake Store como ejemplo. Aprendimos a recuperar datos, crear nuevos recursos, actualizar información existente y eliminar recursos, todo mientras manejamos códigos de estado y parámetros de consulta. También discutimos la importancia de manejar errores y seguir mejores prácticas para escribir código robusto. Con estas herramientas, estás preparado para consumir APIs en tus proyectos y aprovechar los servicios web para crear aplicaciones dinámicas y escalables.
