Un framework web de Python es una biblioteca que se encarga de las partes repetitivas de crear un sitio web o una API (rutas, peticiones, plantillas, bases de datos, seguridad) para que te concentres en tus propias funciones.
¿Estás buscando el mejor framework web de Python? Las tres más populares son Django (completo), Flask (pequeño y flexible) y FastAPI (moderno y pensado para APIs). Esta guía los compara con código que funciona, para que elijas el adecuado para tu próximo proyecto.
Si ya conoces los fundamentos de Python, un framework web es el siguiente paso natural: convierte tus scripts en algo que la gente puede usar desde un navegador.
¿Qué Hace un Framework Web?
Sin un framework tendrías que leer peticiones HTTP en bruto, decidir qué función atiende cada URL, construir la respuesta, hablar con una base de datos, protegerte de ataques y manejar formularios e inicios de sesión por tu cuenta. Un framework te da piezas probadas para las tareas comunes:
- Rutas: relacionan una URL como
/hellocon la función de Python que la atiende. - Peticiones y respuestas: leen parámetros de la URL, datos de formularios y JSON, y devuelven HTML o JSON.
- Plantillas: generan páginas HTML a partir de datos.
- Acceso a bases de datos: guardan y cargan datos, a menudo mediante un ORM. Mira la guía de SQLAlchemy.
- Seguridad: protecciones contra ataques web comunes como CSRF, XSS e inyección SQL.
- Extras: autenticación, paneles de administración, validación, herramientas de pruebas y ayuda para el despliegue.
Los frameworks se diferencian sobre todo en cuántas de estas piezas incluyen y cuánto deciden por ti.
Los Tres Grandes de un Vistazo
| Django | Flask | FastAPI | |
|---|---|---|---|
| Estilo | “Baterías incluidas” | Micro-framework | Framework moderno para APIs |
| Ideal para | Sitios completos, sitios de contenido, apps con inicio de sesión y administración | Apps pequeñas, prototipos, configuraciones a medida | APIs JSON, microservicios, trabajo asíncrono |
| Capa de base de datos | ORM y migraciones integrados | Tú eliges (p. ej. SQLAlchemy) | Tú eliges (p. ej. SQLAlchemy) |
| Panel de administración | Integrado | Mediante extensiones | No incluido |
| Validación de datos | Formularios y serializadores | Manual o extensiones | Automática, a partir de las anotaciones de tipo |
| Documentación automática de la API | No (complementos) | No (complementos) | Sí, integrada (/docs) |
| Soporte asíncrono | Sí (ASGI) | Limitado (WSGI) | Nativo (ASGI) |
| Curva de aprendizaje | Más pronunciada, hay más que aprender | Suave | Suave si conoces las anotaciones de tipo |
Ninguno es “el mejor”. Están hechos para trabajos distintos.
El Mismo Endpoint en los Tres
Para ver la diferencia de estilo, este es el mismo endpoint pequeño en cada framework. Responde a GET /hello?name=Ana con un mensaje JSON. Ejecuté los tres ejemplos antes de ponerlos aquí.
Flask
from flask import Flask, jsonify, request
app = Flask(__name__)
@app.get("/hello")
def hello():
name = request.args.get("name", "world")
return jsonify(message=f"Hello, {name}!")
Guárdalo como flask_app.py y ejecútalo:
flask --app flask_app run
Abre http://127.0.0.1:5000/hello?name=Ana y obtienes:
{"message": "Hello, Ana!"}
Flask te da rutas y manejo de peticiones, y nada más. Tú agregas lo que necesites. Para un recorrido completo, lee Python Flask: Guía Completa para Crear y Desplegar Aplicaciones Web.
FastAPI
from fastapi import FastAPI
app = FastAPI()
@app.get("/hello")
def hello(name: str = "world"):
return {"message": f"Hello, {name}!"}
@app.get("/items/{item_id}")
def read_item(item_id: int):
return {"item_id": item_id}
Ejecútalo con el servidor de desarrollo (instálalo con pip install "fastapi[standard]"):
fastapi dev fastapi_app.py
La petición /hello?name=Ana devuelve el mismo JSON. FastAPI además hace dos cosas por ti:
- Validación a partir de las anotaciones de tipo. Como
item_id: intestá declarado como entero,/items/5funciona, mientras que/items/abcdevuelve un error422que explica que la entrada debe ser un entero válido. No escribiste código de validación. - Documentación automática. Abre
http://127.0.0.1:8000/docspara ver una página interactiva de la API generada a partir de tu código.
Django
Django normalmente se usa como un proyecto de varios archivos, pero puede ejecutarse desde un solo archivo, lo que hace justa la comparación:
import sys
from django.conf import settings
from django.core.management import execute_from_command_line
from django.http import JsonResponse
from django.urls import path
settings.configure(
DEBUG=True,
SECRET_KEY="dev-only-change-me",
ROOT_URLCONF=__name__,
ALLOWED_HOSTS=["*"],
)
def hello(request):
name = request.GET.get("name", "world")
return JsonResponse({"message": f"Hello, {name}!"})
urlpatterns = [path("hello/", hello)]
if __name__ == "__main__":
execute_from_command_line(sys.argv)
Guárdalo como django_app.py y ejecuta:
python django_app.py runserver
Luego abre http://127.0.0.1:8000/hello/?name=Ana. Ese único archivo es solo para aprender. Los valores de SECRET_KEY y ALLOWED_HOSTS son marcadores de posición, y un proyecto real debe leer sus secretos desde el entorno en lugar de escribirlos en el código. Mira el archivo .env en proyectos de Python.
Un proyecto real de Django empieza con dos comandos:
django-admin startproject mysite
python manage.py startapp blog
Eso crea una estructura con settings.py, urls.py, wsgi.py, asgi.py y una carpeta de app con models.py, views.py, admin.py y una carpeta de migraciones. La estructura es más para aprender al inicio, pero da a todos los proyectos de Django la misma forma.
Django: la Opción Completa
Django sigue la idea de “baterías incluidas”. Desde el primer momento obtienes:
- Un ORM para trabajar con la base de datos mediante clases de Python, más migraciones para cambiar el esquema de forma segura.
- Un panel de administración generado a partir de tus modelos, para gestionar contenido sin escribir un backoffice.
- Autenticación de usuarios, sesiones y permisos.
- Formularios y validación.
- Un lenguaje de plantillas para páginas HTML.
- Protecciones de seguridad activadas de forma predeterminada, incluida la protección CSRF y el escape automático de HTML en las plantillas.
Elige Django cuando estés creando un sitio web completo o una app con cuentas, base de datos y administración, como un blog, un sitio de membresías, una tienda o una herramienta interna, y quieras una estructura probada en lugar de diseñar la tuya.
El compromiso: más conceptos que aprender al inicio y una estructura de proyecto que puede sentirse pesada para una app muy pequeña.
Flask: Pequeño y Flexible
Flask es un micro-framework. Te da lo esencial (rutas, peticiones, plantillas con Jinja) y te deja elegir el resto: la biblioteca de base de datos, el sistema de inicio de sesión, la herramienta de formularios. Un gran ecosistema de extensiones cubre los huecos cuando los necesitas.
Elige Flask cuando quieras aprender cómo funcionan las apps web, crear una herramienta pequeña o un prototipo, o necesites control total sobre las piezas que usas. También encaja bien en sitios pequeños que no necesitan un panel de administración.
El compromiso: tomas más decisiones tú mismo y eres responsable de agregar cosas como la autenticación y la protección de formularios. La flexibilidad de Flask es excelente en manos de alguien que sabe qué agregar, y arriesgada si te saltas las partes de seguridad.
FastAPI: Moderno y Pensado para APIs
FastAPI está diseñado para crear APIs. Usa las anotaciones de tipo de Python para validar la entrada, convierte los datos automáticamente y genera documentación interactiva a partir del mismo código. Funciona sobre ASGI, por lo que soporta código async de forma nativa, algo útil en apps que esperan muchas llamadas de red a la vez.
Elige FastAPI cuando estés creando una API JSON para una app móvil o un front end de JavaScript, un microservicio, o un servicio que se conecta con modelos de aprendizaje automático u otro trabajo asíncrono.
El compromiso: está enfocado en APIs. No incluye panel de administración, capa de base de datos ni sistema de inicio de sesión, así que los armas tú mismo. Puede servir páginas HTML, pero no es lo que mejor hace.
WSGI vs ASGI en un Minuto
Verás estos dos términos al desplegar.
- WSGI es el estándar más antiguo para conectar apps web de Python con servidores. Atiende una petición por worker a la vez. Flask es un framework WSGI, y Django también lo soporta.
- ASGI es el estándar más nuevo que agrega soporte asíncrono. FastAPI está construido sobre él, y Django también lo soporta.
En producción ejecutas tu app detrás de un servidor de aplicaciones: Gunicorn es común para apps WSGI y Uvicorn para apps ASGI, normalmente detrás de un servidor web como Nginx. Ahí es donde entran Docker y un VPS. Poner Cloudflare por delante agrega caché y protección básica.
Otros Frameworks Web de Python que Vale la Pena Conocer
Los tres grandes cubren la mayoría de los proyectos, pero hay otros que puedes encontrar:
- Pyramid: flexible y escalable, entre Flask y Django en tamaño.
- Tornado: un framework y servidor asíncrono más antiguo, usado a menudo para conexiones de larga duración.
- Sanic: un framework asíncrono enfocado en la velocidad.
- Litestar: un framework asíncrono más nuevo con un conjunto de funciones similar al de FastAPI.
- Bottle: un micro-framework diminuto de un solo archivo.
Aprende primero uno de los tres grandes. Los conceptos (rutas, peticiones, plantillas, bases de datos) se transfieren a todos los demás.
Cómo Elegir
| Tu situación | Un buen punto de partida |
|---|---|
| Eres nuevo en el desarrollo web y quieres aprender los fundamentos | Flask |
| Creas un sitio completo con usuarios, contenido y administración | Django |
| Creas una API para una app móvil o un front end de JavaScript | FastAPI |
| Haces un prototipo rápido o una herramienta interna | Flask o FastAPI |
| Manejas muchas peticiones de red concurrentes | FastAPI |
| Quieres las funciones y convenciones más integradas | Django |
| Necesitas una API para un flujo de ciencia de datos o ML | FastAPI |
Dos notas honestas sobre la decisión:
- La velocidad rara vez decide. FastAPI suele ser más rápido con muchas peticiones simultáneas limitadas por E/S, pero en la mayoría de los sitios la base de datos y la forma en que la consultas importan mucho más que el framework. Si una página es lenta, revisa primero tus consultas SQL.
- Puedes cambiar después. La lógica de negocio escrita en Python puro se mueve entre frameworks con mucha más facilidad de la que imaginas. Elige uno, publica algo y aprende de ello.
La Seguridad Es Parte de la Elección
Los tres pueden usarse para crear aplicaciones seguras, pero parten de lugares distintos. Django incluye muchas protecciones activadas. Con Flask y FastAPI las agregas tú: cifrado de contraseñas, protección CSRF para formularios, validación de entradas y manejo cuidadoso de los secretos. Uses lo que uses:
- Usa el ORM o consultas parametrizadas para que la entrada del usuario nunca se pegue en el SQL. Mira la inyección SQL.
- Mantén los secretos como el
SECRET_KEYde Django, las claves de API y las contraseñas de bases de datos fuera de tu código, en un archivo .env que no se suba a Git. - Ofrece autenticación de dos factores o passkeys para las cuentas que importan.
- Nunca ejecutes con
DEBUG=Trueen producción. - Mantén actualizados el framework y tus paquetes.
Tus Primeros Pasos
- Prepara un entorno limpio. Crea un entorno virtual o usa el más rápido administrador uv.
- Instala un framework con
pip install flask,pip install djangoopip install "fastapi[standard]". - Crea el endpoint hello de esta guía y ejecútalo.
- Agrega una base de datos. Prueba SQLAlchemy con Flask o FastAPI, o el ORM de Django. Si quieres una base de datos real, ejecuta MySQL en Docker.
- Crea un proyecto pequeño de principio a fin, como una lista de tareas o una app de notas, y despliégalo.
Para ideas sobre qué más puede hacer Python, mira Python para Todo: 10 Bibliotecas que Todo Principiante Debe Conocer.
Preguntas Frecuentes
¿Qué framework web de Python debe aprender primero un principiante?
Flask es el lugar más fácil para empezar porque es pequeño y te muestra cómo funcionan las apps web. Si tu meta es un sitio completo con usuarios y panel de administración, Django también es un buen primer framework, con más que aprender al inicio.
¿Es mejor Django o Flask?
Ninguno es mejor en general. Django es mejor cuando quieres funciones integradas como un ORM, panel de administración y autenticación. Flask es mejor cuando quieres una app pequeña y flexible y prefieres elegir tus propias herramientas.
¿FastAPI es mejor que Flask?
Para crear APIs, muchos desarrolladores prefieren FastAPI por su validación y documentación automáticas y su soporte asíncrono. Flask sigue siendo una gran opción para apps web pequeñas y para aprender. Resuelven problemas parecidos pero distintos.
¿Puedo crear un sitio web completo con FastAPI?
Puedes servir páginas HTML con él, pero FastAPI está diseñado en torno a las APIs. Para un sitio con mucho contenido, inicios de sesión y administración, Django suele ahorrar más tiempo.
¿Python es bueno para el desarrollo web?
Sí. Python se usa mucho para sitios web y APIs, tiene frameworks maduros y es fácil de leer. Además se conecta bien con el análisis de datos y el aprendizaje automático.
¿También necesito aprender JavaScript?
Para páginas interactivas en el navegador, sí. Un framework de Python se ejecuta en el servidor y JavaScript en el navegador. Puedes crear sitios útiles renderizados en el servidor solo con Python y agregar JavaScript cuando necesites interactividad.
¿Cómo despliego una app web de Python?
Ejecútala con un servidor de aplicaciones de producción (Gunicorn para WSGI, Uvicorn para ASGI), ponla detrás de Nginx o un servidor web similar y alójala en un VPS, una plataforma de contenedores o un hosting administrado. Empieza con la guía de VPS.
Conclusión
Django, Flask y FastAPI son todos excelentes, y el adecuado depende de lo que estés creando. Elige Django para sitios completos con cuentas y administración, Flask para apps pequeñas y para aprender los fundamentos, y FastAPI para APIs modernas con validación y documentación automáticas.
No pases semanas comparando. Instala uno, crea el endpoint pequeño de esta guía y luego crea algo real. Las habilidades que ganes (rutas, peticiones, bases de datos, seguridad, despliegue) se transfieren a cualquier otro framework que aprendas después.
