Dominar las API de Python: Una Guía Completa para Construir y Utilizar APIs en Python

Las API, o interfaces de programación de aplicaciones, son realmente los héroes del desarrollo moderno de software. Permiten que distintos sistemas de software se comuniquen entre sí, haciendo posible la integración de servicios y la creación de aplicaciones. Dominar las API es una habilidad importante para cualquiera que quiera trabajar con datos en Python, especialmente si eres desarrollador. Puede que te sorprendan las puertas que se abren, porque cuando aprendas esta habilidad, podrás crear aplicaciones web, conectarte a servicios externos o incluso utilizar datos en tiempo real en proyectos de aprendizaje automático.

En esta guía, exploraremos el mundo de las API, aprenderemos a utilizarlas en Python, a construir la tuya propia con FastAPI y a manejar los retos más comunes que seguro que surgen. Al final de este tutorial, tendrás una sólida comprensión de cómo utilizar las API en tus proyectos, haciendo que tu proceso de desarrollo sea más eficiente y tus aplicaciones más potentes. Si alguna vez te sientes atascado con toda la información, prueba nuestro curso Introducción a las API en Python, que repasa cada parte en detalle.

¿Qué es una API?

Una API es como un puente entre diferentes aplicaciones de software. Permite que estas aplicaciones se comuniquen y compartan información entre sí.

Imagina una API como camarero en un restaurante. Le dices al camarero lo que quieres (tu pedido), y él comunica tu petición a la cocina. La cocina prepara tu comida y el camarero te la trae. Del mismo modo, envías una solicitud a una API, y ésta procesa tu solicitud y luego devuelve los resultados.

Para hacer esto más concreto, consideremos algunos usos reales: Por ejemplo, podrías utilizar una API pública para recuperar datos financieros para un análisis bursátil o para acceder a datos meteorológicos en tiempo real para un modelo de predicción climática. Como te estarás dando cuenta, las API son especialmente importantes para trabajar con grandes conjuntos de datos y/o cuando tienes necesidades de datos en tiempo real; de lo contrario, puede que no tengas problemas con la integración.

Cómo funciona una API de Python. Imagen de Napkin.AI

Utilizar APIs en Python

Utilizar APIs en Python es una forma potente de interactuar con servicios externos, recuperar datos e integrar diversas funcionalidades en tus aplicaciones. Python hace que trabajar con las API sea sencillo y eficaz, principalmente a través de la biblioteca depeticiones , que te permite enviar peticiones HTTP para interactuar con las API.

Introducción a las API en Python

En Python, interactuar con las API es un proceso sencillo gracias a la biblioteca requests. Esta biblioteca simplifica el proceso de enviar peticiones HTTP, permitiéndote comunicarte con APIs y recuperar o enviar datos.

Hacer peticiones a la API en Python

Antes de que puedas empezar a hacer peticiones a la API en Python, necesitarás la bibliotecarequests. Puedes instalarlo utilizando este comando:

pip install requests

Aspectos básicos de las solicitudes API

Unamos nuestro ejemplo conceptual del restaurante con lo que ocurre realmente en Python. Éste es el desglose simplificado:

1. Encuentra el lugar adecuado: Identifica el punto final de la API, que es la dirección web específica a la que enviarás tu solicitud.

2. Haz tu pedido: Utiliza la biblioteca requests de Python para enviar la solicitud a la API. Especificarás qué tipo de acción quieres realizar (como obtener datos o enviarlos).

3. Consigue tu comida: La API te devolverá una respuesta, que puedes procesar para extraer la información que necesitas.

Peticiones GET

Una petición GET es el tipo más común de petición HTTP que se utiliza para recuperar datos de un servidor, similar a pedir información; cuando escribes una URL en tu navegador y pulsas intro, estás enviando esencialmente una petición GET a ese servidor, especificando el recurso deseado, que el servidor procesa para encontrar y preparar los datos solicitados antes de devolverlos en un formato como JSON o XML.

import requestsresponse = requests.get('https://api.example.com/data')data = response.json()print(data)

En este ejemplo, estamos enviando una solicitud GET a una API ficticia e imprimiendo la respuesta JSON. Las peticiones GET se utilizan habitualmente para obtener datos sin modificarlos.

Peticiones POST

Mientras que las peticiones GET recuperan datos, las peticiones POST envían instrucciones a un servidor. Suelen utilizarse para crear nuevos recursos (como añadir un usuario) o actualizar los existentes (como editar un perfil).

Imagina que estás rellenando un formulario online para registrarte en un servicio. Cuando haces clic en enviar, básicamente estás enviando una solicitud POST con tu información. He aquí un ejemplo simplificado:

# Data to send (like user information)data = {'name': 'John Doe', 'email': 'john.doe@example.com'}# Send the data to the API (replace the URL with the actual API endpoint)response = requests.post('https://api.example.com/users', json=data)# Check if the request was successful (usually a status code of 201 for creation)if response.status_code == 201:    print("User created successfully!")else:    print("Error:", response.status_code)

Este ejemplo envía un diccionario con información del usuario como datos JSON a la API. A continuación, comprobamos el código de estado de la respuesta para ver si el usuario se ha creado correctamente.

Tratamiento de las respuestas

Cuando realizas una solicitud a la API, el servidor envía una respuesta que incluye dos datos clave:

• Código de estado: Un número que indica el éxito o el fracaso de la solicitud. Por ejemplo, 200 suele significar éxito, mientras que 404 significa que no se encontró el recurso.
• Datos: La información que has solicitado suele estar en formato JSON. Aquí es donde reside el contenido valioso.

Aquí tienes un ejemplo en Python:

response = requests.get('https://api.example.com/data')if response.status_code == 200:    data = response.json()    print(data)   else:    print(f"Request failed with status code {response.status_code}")   

Comprender los códigos de estado de la API de Python

Los códigos de estado de la API son respuestas estandarizadas que los servidores devuelven para indicar el resultado de la solicitud de un cliente. Estos códigos ayudan a los desarrolladores a saber si una solicitud se ha realizado correctamente, si se ha producido un error o si es necesario realizar alguna otra acción.

Códigos de estado comunes

• 200 OK: Este código de estado indica que la solicitud se ha realizado correctamente. Por ejemplo, cuando haces una petición GET para recuperar datos de una API, una respuesta 200 OK significa que los datos se han obtenido correctamente.  

• 404 No encontrado: Este código se devuelve cuando el servidor no puede encontrar el recurso solicitado. Por ejemplo, si intentas acceder a un punto final que no existe, recibirás un error 404 Not Found.

• 500 Error interno del servidor: Este código indica que algo ha ido mal en el servidor. Es un mensaje de error genérico que puede producirse por diversas causas, como fallos en el código del servidor o problemas con la base de datos.

Manejo de diferentes códigos de estado

Manejar eficazmente los códigos de estado de la API en tus aplicaciones Python garantiza que tu código se comporte de forma predecible y pueda gestionar los errores con elegancia. Si la respuesta es 200, procede a procesar los datos devueltos. Cuando te encuentres con un error 404, comprueba si la URL del punto final es correcta y, si es necesario, implementa una lógica alternativa o informa al usuario de que el recurso no está disponible. Para los errores 500, considera reintentar la petición tras un breve retraso o registrar el error para una investigación posterior. Sin embargo, evita reintentos excesivos para no sobrecargar el servidor.

Construir APIs de Python

Construir API con Python te permite crear interfaces de aplicación potentes y eficaces. La sencillez de Python y sus sólidas bibliotecas lo convierten en una opción excelente para el desarrollo de API.

Introducción a FastAPI

Ahora que sabes cómo utilizar las API, vamos a explorar cómo podemos construir la nuestra. FastAPI es un marco web moderno y rápido (de alto rendimiento) para construir APIs con Python. Como su nombre indica, está diseñado para ser fácil de usar. Una cosa que me gusta de FastAPI es que también genera automáticamente documentación interactiva.

Configurar FastAPI

Para empezar, necesitarás tener instalado Python y su gestor de paquetes, pip. A continuación, instala FastAPI y Uvicorn, un servidor ASGI de alto rendimiento:

pip install fastapi uvicorn

Nota al margen: Si tienes problemas con la configuración de Python o pip, consulta nuestro tutorial: Cómo actualizar Python y Pip en Windows, MacOS y Linux.

Crear una API sencilla

Construyamos una API sencilla que devuelva un simple saludo:

from fastapi import FastAPIapp = FastAPI()@app.get("/")def read_root():    return {"Hello": "World"}

Para lanzar esta API, ejecuta el siguiente comando:

uvicorn main:app --reload

Este comando inicia el servidor Uvicorn, sirviendo tu API en http://127.0.0.1:8000. Si accedes a esta URL en tu navegador, obtendrás la respuesta {"Hello": "World"}.

Funciones avanzadas de FastAPI

FastAPI no sólo sirve para crear API sencillas con rapidez; también ofrece una serie de funciones avanzadas que lo hacen adecuado para aplicaciones complejas y de alto rendimiento. Éstas son algunas de las capacidades clave: 

Parámetros de consulta

En FastAPI, añadir y manejar parámetros de consulta es sencillo, gracias a que se basa en las sugerencias de tipo de Python. Los parámetros de consulta forman parte de la URL y se utilizan para pasar datos opcionales al punto final de la API, a menudo para filtrar o modificar los datos devueltos.

Añadir parámetros de consulta

Para añadir un parámetro de consulta en FastAPI, sólo tienes que definirlo como argumento de función en tu función de operación de ruta. Si un parámetro es opcional, puedes asignarle un valor por defecto, como None. Por ejemplo, supongamos que tienes un punto final que recupera elementos de una base de datos. Quieres permitir a los usuarios filtrar elementos mediante una consulta de búsqueda:

app = FastAPI()@app.get("/items/")def read_items(q: str = None):    if q:        return {"items": ["Item 1", "Item 2", "Item 3"], "query": q}    return {"items": ["Item 1", "Item 2", "Item 3"]}

En este ejemplo, q es un parámetro de consulta opcional. Si proporcionamos un valor para q, filtra los resultados basándose en esa consulta. Si no se proporciona q, el punto final devuelve todos los elementos.

Manejo de los parámetros de consulta

FastAPI gestiona automáticamente los parámetros de consulta, incluyendo la validación y conversión de tipos. Por ejemplo, si especificas un parámetro de consulta como un número entero, FastAPI validará que la entrada es efectivamente un número entero. Si la entrada no coincide con el tipo esperado, FastAPI devuelve un mensaje de error claro.

Aquí tienes un ejemplo con un parámetro de consulta obligatorio y validación de tipo:

@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None):    return {"item_id": item_id, "query": q}

En este caso, item_id es un parámetro de ruta, y q es un parámetro de consulta opcional. FastAPI se asegurará de que item_id es un número entero y procesará el parámetro de consulta q si se proporciona.

Manejo de diferentes métodos HTTP

Implementar diferentes métodos HTTP como GET, POST, PUT y DELETE es sencillo y refleja cómo se definen las rutas en otros frameworks. Cada método está vinculado a un tipo de operación concreto, como recuperar datos (GET), crear datos nuevos (POST), actualizar datos existentes (PUT) o borrar datos (DELETE).

Método GET

El método GET se utiliza para recuperar datos del servidor. En FastAPI, defines un punto final GET así:

@app.get("/items/")def get_items():    return {"items": ["Item 1", "Item 2", "Item 3"]}

Método POST

El método POST se utiliza para crear nuevos datos. Puedes definir un punto final POST y recibir datos en el cuerpo de la solicitud:

@app.post("/items/")def create_item(item: dict):    return {"item": item}

Método PUT

El método PUT se utiliza para actualizar los datos existentes. Suele requerir tanto un identificador como los nuevos datos:

@app.put("/items/{item_id}")def update_item(item_id: int, item: dict):    return {"item_id": item_id, "updated_item": item}

Método DELETE

El método DELETE se utiliza para eliminar datos. En FastAPI, un punto final DELETE se define como sigue:

@app.delete("/items/{item_id}")def delete_item(item_id: int):    return {"message": f"Item {item_id} deleted"}

Autenticación y seguridad

FastAPI ofrece varios mecanismos para implementar la autenticación y la seguridad:

• Autenticación básica HTTP: Es un método sencillo, pero generalmente no se recomienda para entornos de producción por motivos de seguridad.
• Claves API: Una opción más segura que implica generar claves únicas para los clientes.
• OAuth 2.0: Una norma compleja pero robusta para la autorización, utilizada habitualmente para las integraciones de terceros.
• Tokens Web JSON (JWT): Un enfoque popular para representar reclamaciones de forma segura entre dos partes.