Continuando con el desarrollo web con Python, ahora vamos a explorar FastAPI, un framework web moderno y de alto rendimiento para construir APIs con Python 3.7+ (aprovechando las características de tipo de Python). FastAPI se ha ganado rápidamente popularidad por su velocidad, facilidad de uso y las características que ofrece para el desarrollo de APIs robustas.

FastAPI: Framework Web de Alto Rendimiento para APIs

FastAPI se basa en los estándares de Python para el hinting de tipos (type hints), lo que le permite ofrecer varias ventajas, incluyendo validación de datos automática, serialización y documentación interactiva.

Características Clave de FastAPI:

• Alto Rendimiento: FastAPI está construido sobre Starlette para la parte web y Pydantic para la validación de datos. Starlette es un microframework ASGI (Asynchronous Server Gateway Interface) de alto rendimiento, y Pydantic proporciona una validación de datos robusta y eficiente basada en los type hints de Python. Esto hace que FastAPI sea extremadamente rápido, comparable a frameworks como Node.js y Go.
• Fácil de Usar y Aprender: La sintaxis de FastAPI está diseñada para ser intuitiva y concisa. El uso de type hints simplifica la definición de la estructura de las APIs y la validación de datos.
• Validación de Datos Automática: Gracias a Pydantic y los type hints, FastAPI realiza la validación de los datos de las peticiones automáticamente. Si los datos no cumplen con los tipos o las validaciones definidas, se generan errores claros y útiles.
• Serialización Automática de Datos: FastAPI se encarga de convertir los datos de Python a formatos como JSON para las respuestas de la API de forma automática.
• Documentación Interactiva Automática: FastAPI genera automáticamente documentación interactiva para tus APIs utilizando Swagger UI y ReDoc. Esto se basa en los type hints y las descripciones que añades a tu código, lo que facilita la exploración y el uso de tu API por parte de los desarrolladores.
• Soporte para Asincronía: FastAPI es inherentemente asíncrono gracias a Starlette y la sintaxis async/await de Python. Esto permite manejar muchas peticiones concurrentes de manera eficiente, lo que es crucial para APIs de alto rendimiento.
• Soporte para WebSockets: FastAPI también facilita la implementación de WebSockets para comunicaciones bidireccionales en tiempo real.
• Seguridad: FastAPI proporciona herramientas y guías para implementar mecanismos de seguridad como autenticación y autorización.
• Basado en Estándares Abiertos: FastAPI se basa en estándares abiertos para APIs como OpenAPI (anteriormente Swagger) y JSON Schema.

Un Ejemplo Sencillo de FastAPI:

Aquí tienes un ejemplo básico de una API con FastAPI:

from fastapi import FastAPI
from pydantic import BaseModel

# Crear una instancia de la aplicación FastAPI
app = FastAPI()

# Definir un modelo de datos con Pydantic
class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

# Definir una ruta GET
@app.get("/")
async def read_root():
    return {"Hello": "World"}

# Definir una ruta GET con un parámetro de path
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Definir una ruta POST que espera un cuerpo JSON
@app.post("/items/")
async def create_item(item: Item):
    return item

# Para ejecutar la aplicación, generalmente se usa Uvicorn (un servidor ASGI)
# uvicorn main:app --reload

Explicación del Ejemplo:

1. from fastapi import FastAPI: Importa la clase FastAPI.
2. from pydantic import BaseModel: Importa BaseModel de Pydantic para definir modelos de datos con type hints.
3. app = FastAPI(): Crea una instancia de la aplicación FastAPI.
4. class Item(BaseModel): ...: Define un modelo de datos Item utilizando Pydantic. Los type hints (str, float, bool = None) definen la estructura esperada de los datos y permiten la validación automática.
5. @app.get("/"): Define una ruta GET para la raíz (/). La función read_root es asíncrona (async def).
6. @app.get("/items/{item_id}"): Define una ruta GET con un parámetro de path item_id, que está tipado como entero (int). También tiene un parámetro de query opcional q (de tipo str con valor por defecto None). FastAPI se encarga de validar el tipo de item_id.
7. @app.post("/items/"): Define una ruta POST que espera un cuerpo JSON que coincida con la estructura del modelo Item. FastAPI validará el cuerpo de la petición y lo convertirá automáticamente en una instancia de la clase Item.
8. uvicorn main:app --reload: Este es un comando típico para ejecutar la aplicación FastAPI utilizando Uvicorn, un servidor ASGI rápido. main es el nombre del archivo Python (sin la extensión .py), y app es el nombre de la instancia de FastAPI que creaste. La opción --reload permite que el servidor se reinicie automáticamente al detectar cambios en el código.

Para ejecutar esta aplicación:

1. Guarda el código en un archivo llamado, por ejemplo, main.py.
2. Asegúrate de tener instalado FastAPI y Uvicorn: pip install fastapi uvicorn.
3. Abre tu terminal o símbolo del sistema, navega hasta el directorio donde guardaste el archivo y ejecuta: uvicorn main:app --reload.
4. Verás un mensaje indicando que el servidor Uvicorn se está ejecutando (generalmente en http://127.0.0.1:8000/).
5. Abre tu navegador web y ve a http://127.0.0.1:8000/ para ver la respuesta JSON {"Hello": "World"}.
6. Ve a http://127.0.0.1:8000/items/5?q=somequery para ver la respuesta {"item_id": 5, "q": "somequery"}.
7. Puedes interactuar con la ruta POST /items/ enviando un cuerpo JSON como {"name": "Example Item", "price": 10.5, "is_offer": true} utilizando una herramienta como curl o Postman.
8. Lo más impresionante es que FastAPI genera automáticamente documentación interactiva en http://127.0.0.1:8000/docs (Swagger UI) y http://127.0.0.1:8000/redoc (ReDoc) basada en tu código.

Cuándo Elegir FastAPI:

• Para construir APIs de alto rendimiento.
• Cuando la validación de datos y la serialización son cruciales.
• Cuando se requiere documentación automática de la API (OpenAPI).
• Para aprovechar las características de tipo de Python para un desarrollo más robusto y fácil de mantener.
• Para proyectos que se benefician del soporte asíncrono.
• Para construir microservicios y APIs modernas.

FastAPI se ha convertido en una opción muy popular para el desarrollo de APIs en Python debido a su combinación de rendimiento, facilidad de uso y excelentes características para la productividad del desarrollador.