Comparación de 8 frameworks web de Python — Guía por caso de uso

Al construir servicios web o APIs en Python, una de las primeras decisiones es elegir un framework. Django, FastAPI, Flask — probablemente has oído de todos, pero saber cuál se adapta a tu proyecto puede ser sorprendentemente difícil.

Este artículo compara 8 frameworks web de Python por caso de uso, dificultad, velocidad y soporte asíncrono, con ejemplos de código prácticos.

Resumen comparativo

No elijas un framework por ser popular o nuevo. Adáptalo a la escala y requisitos de tu proyecto. Para APIs, FastAPI; para sitios web completos, Django; para prototipos rápidos, Flask — estos tres cubren el 90% de los casos.

Django — El estándar full-stack

Django es el framework web más famoso de Python. Autenticación, panel de administración (Django Admin), ORM, gestión de sesiones, protección CSRF — todo lo que una app web necesita viene incluido de serie. Su filosofía «Batteries Included» significa que rara vez necesitas paquetes externos.

Instagram, Mozilla y Pinterest funcionan con Django, demostrando que escala para proyectos de alto tráfico.

from django.http import JsonResponse
from django.views import View

class UserView(View):
    def get(self, request, user_id):
        return JsonResponse({
            "user_id": user_id,
            "name": "Alice",
        })

# urls.py: path('users//', UserView.as_view())

Cuándo usar:

• Servicios web empresariales, sistemas internos
• Proyectos que necesitan panel de administración
• E-commerce, plataformas CMS
• Apps con autenticación compleja

Instalar con pip:

pip install django

FastAPI — El estándar moderno de APIs Python

FastAPI aprovecha los type hints de Python para ofrecer un framework API de alto rendimiento con validación automática, generación de documentación Swagger UI / ReDoc, y soporte nativo async/await.

Su rendimiento rivaliza con Node.js y Go, convirtiéndolo en el más rápido entre los frameworks Python. Desde 2020 ha ganado cuota de mercado rápidamente.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str
    age: int

@app.post("/users/")
async def create_user(user: User):
    return {"message": f"{user.name} (age {user.age}) created"}

# POST /users/ {"name":"Alice","age":30}
# → {"message": "Alice (age 30) created"}

Cuándo usar:

• REST API / backends GraphQL
• Servicio de modelos AI / ML
• Backends de sitios de herramientas
• Microservicios

Instalar con pip:

pip install fastapi uvicorn

Flask — El micro-framework minimalista

Flask se autodenomina «micro-framework» — el framework web Python más simple. Su núcleo es minúsculo; añades funciones según las necesitas mediante extensiones.

from flask import Flask, jsonify

app = Flask(__name__)

@app.route("/users/")
def get_user(user_id):
    return jsonify({"user_id": user_id, "name": "Alice"})

# GET /users/1 → {"user_id": 1, "name": "Alice"}

Cuándo usar:

• Prototipos y pruebas de concepto
• Aprender desarrollo web Python
• Herramientas internas pequeñas
• Servidores API simples

Instalar con pip:

pip install flask

Sanic — Velocidad nativa async

Sanic es un framework web construido desde cero para async/await. Tiene sintaxis intuitiva tipo Flask mientras funciona completamente asíncrono internamente, usando uvloop para alto throughput.

Antes de FastAPI, Sanic era la opción principal para APIs async rápidas en Python. Sigue siendo preferido cuando necesitas control de bajo nivel.

from sanic import Sanic
from sanic.response import json

app = Sanic("MyApp")

@app.get("/users/")
async def get_user(request, user_id):
    return json({"user_id": user_id, "name": "Alice"})

# GET /users/1 → {"user_id": 1, "name": "Alice"}

Cuándo usar:

• APIs de alto throughput
• Servicios de comunicación en tiempo real
• Proyectos sin dependencia de Pydantic
• Equipos experimentados con async

Instalar con pip:

pip install sanic

Quart — Flask asíncrono

Quart es un framework web async con API compatible con Flask. Su principal ventaja: puedes migrar código Flask existente a async cambiando mayormente def por async def.

from quart import Quart, jsonify

app = Quart(__name__)

@app.route("/users/")
async def get_user(user_id):
    return await jsonify({"user_id": user_id, "name": "Alice"})

# GET /users/1 → {"user_id": 1, "name": "Alice"}

Cuándo usar:

• Migrar proyecto Flask a async
• Mantener ecosistema Flask con async
• WebSocket con sintaxis Flask

Instalar con pip:

pip install quart

Tornado — El veterano async

Tornado fue lanzado en 2009 por FriendFeed y fue pionero del desarrollo web asíncrono en Python. Tiene su propio bucle de I/O, anterior a la estandarización de asyncio, y destaca en conexiones de larga duración.

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write({"message": "Hello Tornado"})

app = tornado.web.Application([
    (r"/", MainHandler),
])
app.listen(8888)
tornado.ioloop.IOLoop.current().start()

Cuándo usar:

• Servicios en tiempo real con Long Polling / WebSocket
• Mantenimiento de sistemas Tornado existentes
• Control fino de I/O async

Instalar con pip:

pip install tornado

Pyramid — Arquitectura escalable y flexible

La filosofía de Pyramid es «empezar pequeño, terminar grande.» Puede ser tan simple como Flask para apps pequeñas y escalar a la complejidad de Django, ocupando el punto medio.

from pyramid.config import Configurator
from pyramid.response import Response
import json

def hello(request):
    return Response(
        json.dumps({"message": "Hello Pyramid"}),
        content_type="application/json"
    )

with Configurator() as config:
    config.add_route("home", "/")
    config.add_view(hello, route_name="home")
    app = config.make_wsgi_app()

Cuándo usar:

• Apps de escala media donde Django es excesivo y Flask insuficiente
• Elección libre de ORM o motor de plantillas
• Proyectos a largo plazo con crecimiento incremental

Instalar con pip:

pip install pyramid

Falcon — El framework REST más rápido

Falcon es un framework solo para REST API que elimina todo lo no esencial. Al enfocarse puramente en procesamiento HTTP, logra tiempos de respuesta de primer nivel. LinkedIn y Rackspace lo usan en producción.

import falcon
import json

class UserResource:
    def on_get(self, req, resp, user_id):
        resp.content_type = falcon.MEDIA_JSON
        resp.text = json.dumps(
            {"user_id": int(user_id), "name": "Alice"}
        )

app = falcon.App()
app.add_route("/users/{user_id}", UserResource())

Cuándo usar:

• APIs donde el tiempo de respuesta es crítico
• Gateways API de microservicios ligeros
• Minimizar overhead del framework

Instalar con pip:

pip install falcon

Guía de selección + patrones de producción

En la práctica, el framework adecuado depende de la escala y propósito de tu proyecto.

Errores comunes de principiantes:

• Empezar con Django y abandonar — Demasiado que aprender. Construye algo con Flask o FastAPI primero
• Construir apps grandes en Flask — La arquitectura se rompe. Considera migrar a Django
• Usar FastAPI/Sanic sin entender async — Llamar bibliotecas síncronas bloquea el event loop
• Elegir por moda — Los frameworks son herramientas. Adáptalos a requisitos, no tendencias

El denominador común: sobre-ingeniería. Un proyecto pequeño no necesita el stack completo de Django, y una API simple no necesita el control de bajo nivel de Tornado. Empieza simple.

Resumen

Los frameworks web de Python son fáciles de elegir cuando conoces tu caso de uso.

• APIs (general) → FastAPI
• Sitios web grandes → Django
• Prototipos / aprendizaje → Flask
• API async de alta velocidad → Sanic
• Flask → async → Quart
• Tiempo real / larga duración → Tornado
• Escala media flexible → Pyramid
• API máx. rendimiento → Falcon

En caso de duda: FastAPI para APIs, Django para sitios web, Flask para proyectos pequeños. Estos tres cubren la gran mayoría de casos. No pierdas tiempo eligiendo — la forma más rápida de aprender es empezar a construir.