Lección 39 de 47 · Un proyecto real✦ WebMCP implementado
Python no nació para la web: de scripts a servidor
10 min de lectura3 retos
Si vienes de PHP, es fácil pensar que Python «hace web» igual que PHP. No es así: PHP nació para la web y Python no. En esta lección ves qué te da PHP sin que lo pidas ($_GET, $_POST, sesiones, un proceso por petición), por qué Python no lo trae, qué hay que añadir (un servidor y un framework) y la historia de WSGI y ASGI, que es lo que los une.
¿De dónde vienen los nombres?
WSGI = Web Server Gateway Interface (interfaz de pasarela del servidor web)
El acuerdo de 2003 (PEP 333, actualizado en la PEP 3333) sobre cómo un servidor llama a una aplicación web en Python.
ASGI = Asynchronous Server Gateway Interface (la misma idea, pero asíncrona)
El sucesor de WSGI: igual de simple, pero con async/await, para que una conexión pueda quedarse abierta (WebSockets) y no bloquee a las demás.
environ = inglés environment (entorno)
El diccionario con los datos de la petición que WSGI le pasa a tu aplicación. Es el $_SERVER de PHP, en un parámetro.
scope = inglés scope (ámbito, alcance)
El diccionario equivalente en ASGI: tipo de conexión, método, ruta, cabeceras. Describe «de qué va esta petición».
http.server = módulo http + server (servidor)
Un servidor HTTP sencillo de la biblioteca estándar. Sirve para probar, pero su documentación avisa de que no se use en producción.
En 4 ideas
1/4
PHP nació para la web: Apache o nginx entregan cada petición a PHP, que rellena $_GET, $_POST y las sesiones, ejecuta tu script y se olvida de todo. Python no nació para la web: es un lenguaje general (scripts, ciencia de datos, machine learning).
Por eso Python no trae de serie lo que en PHP es automático: ni $_GET/$_POST, ni sesiones, ni enrutado por URL, ni un servidor listo para producción. Hay que añadirlos.
Lo que añades son dos piezas: un framework (FastAPI, Flask, Django) que da rutas, validación y sesiones, y un servidor (uvicorn, gunicorn) que abre el puerto y habla HTTP. En PHP, esas dos piezas son «PHP» y «nginx + php-fpm».
WSGI y ASGI son el contrato entre servidor y aplicación: la aplicación es solo una función que el servidor llama. WSGI es síncrono; ASGI es asíncrono y lo usa FastAPI.
1 · Lo que PHP te da sin pedirlo
Piensa en PHP como un restaurante montado para servir: tiene la puerta, los camareros, la cocina y la carta. Tú solo escribes la receta (index.php). Cuando un cliente llega, nginx (el portero) se lo pasa a php-fpm, que arranca tu script de cero, le deja los datos de la petición ya preparados, lo ejecuta de arriba abajo, devuelve la respuesta y olvida todo. Siguiente cliente.
Lo que necesita una web
En PHP
En Python
Leer lo que manda el navegador
$_GET, $_POST, php://input
Nada de serie: lo parsea el framework
Cookies y sesiones
$_COOKIE, session_start(), $_SESSION
Nada de serie: cookies firmadas o una BD, a cargo del framework
Elegir qué código atiende cada URL
El servidor mapea la URL a un fichero (/tareas.php) o un index.php con .htaccess
Nada de serie: el framework enruta con decoradores
Abrir el puerto y hablar HTTP
nginx o Apache + php-fpm
Un servidor aparte (uvicorn, gunicorn)
Responder
header(), http_response_code(), echo
El framework (return de un diccionario, un objeto de respuesta)
Qué pasa con cada petición
Un proceso nuevo y limpio por petición
Un proceso que no muere: tu app se carga una vez y atiende miles
Mira la misma lógica a los dos lados. En PHP, $_GET ya existe cuando empieza tu script. En Python, una función normal solo recibe lo que tú le pases: nadie rellena nada por ti.
PHP 8.5index.php
<?phpdeclare(strict_types=1);
$tareas = [
['titulo' => 'Comprar pan', 'hecha' => false],
['titulo' => 'Llamar al banco', 'hecha' => true],
];
// $_GET lo rellena PHP antes de empezar tu script; tú solo lees.$soloPendientes = isset($_GET['pendientes']);
$salida = $soloPendientes ? array_values(array_filter($tareas, fn (array$t): bool => !$t['hecha'])) : $tareas;
header('Content-Type: application/json');
echojson_encode($salida);
Pythonmain.py
import json
tareas = [
{"titulo": "Comprar pan", "hecha": False},
{"titulo": "Llamar al banco", "hecha": True},
]
deflista_tareas(solo_pendientes):
# En PHP: $soloPendientes = isset($_GET['pendientes']); (ya viene rellenado)
salida = [t for t in tareas ifnot t["hecha"]] if solo_pendientes else tareas
# En PHP: header('Content-Type: application/json'); echo json_encode($salida);return json.dumps(salida)
if __name__ == "__main__":
print(lista_tareas(True))
La función de Python sirve, pero no sabe nada de HTTP: nadie la llama cuando llega una petición y nadie le pasa solo_pendientes. Esa parte (la que en PHP hacen nginx, php-fpm y el propio lenguaje) hay que montarla tú.
2 · Python es de propósito general
Cada lenguaje nace para algo. PHP empezó en 1995 como unas herramientas para mantener la página personal de su autor (de ahí Personal Home Page): su trabajo era generar páginas web, y ha crecido alrededor de eso. Python salió en 1991 sin ninguna web a la vista: se pensó para escribir scripts y programas legibles, de cualquier tipo.
Scripts y automatización: renombrar ficheros, leer un CSV, hablar con una API.
Ciencia de datos y machine learning: NumPy, pandas, PyTorch (las ves en el módulo 03 y en el ecosistema).
Herramientas de consola, juegos, aplicaciones de escritorio, redes…
Web: una de las muchas cosas, y se hace con bibliotecas, no con el lenguaje.
Por eso la biblioteca estándar, que es enorme, tiene json, sqlite3, csv o unittest, pero no tiene un $_GET ni un sistema de rutas ni de sesiones. Lo más cercano es http.server, que sirve para probar. En una consola, python -m http.server sirve los ficheros de la carpeta, y es el php -S localhost:8000 de Python:
$ python -m http.server 8000
¿Por qué? · En PHP no existe
¿Por qué Python no trae el servidor y las sesiones de serie, como PHP? En PHP no existe
Porque meter todo eso en el lenguaje lo ataría a una sola manera de hacer web. PHP la eligió desde el principio: un proceso por petición, sin memoria entre una y otra. Es sencillo, pero cada petición vuelve a cargar tu código.
Python deja libre esa decisión: hay frameworks pequeños (Flask), enormes (Django) o modernos con tipos (FastAPI), y servidores síncronos o asíncronos. Tú eliges la pieza que encaja. A cambio, tienes que elegir y montar, y por eso el primer «Hola, mundo» de la web en Python tiene más piezas que el de PHP.
3 · Qué te falta: enrutar a mano
Para entender qué hace un framework, haz de framework un momento. La parte más básica es el enrutado: dada una ruta (/tareas), decidir qué función la atiende. En PHP lo decide nginx con la ruta del fichero. En Python es, en el fondo, un diccionario de rutas a funciones:
Pythonmain.py
import json
tareas = [
{"id": 1, "titulo": "Comprar pan", "hecha": False},
{"id": 2, "titulo": "Llamar al banco", "hecha": True},
]
definicio():
return200, "app de tareas"deflista():
return200, json.dumps(tareas)
RUTAS = {"/": inicio, "/tareas": lista}
defatiende(ruta):
funcion = RUTAS.get(ruta)
if funcion isNone:
return404, "No encontrada"returnfuncion()
for ruta in ["/", "/tareas", "/nada"]:
estado, cuerpo = atiende(ruta)
print(estado, cuerpo)
Eso es un framework en miniatura. Uno de verdad añade lo que se complica enseguida: rutas con variables (/tareas/7), métodos (GET y POST), leer el cuerpo en JSON y validarlo, cookies, sesiones, errores bien formados y documentación automática. Mira cuántas decisiones caben en un cuerpo de petición:
Aquí hace falta ese if a mano para cada campo. Ahora imagina 30 campos y 20 rutas: de ahí la validación automática de FastAPI de la lección siguiente.
4 · WSGI y ASGI: el contrato entre servidor y aplicación
Falta una pregunta: si el servidor y el framework son programas distintos, ¿cómo se hablan? Al principio cada framework traía su propio servidor y eran incompatibles. En 2003 la comunidad firmó un acuerdo, el WSGI (PEP 3333): «una aplicación web es una función con dos parámetros; el servidor la llama». Así cualquier servidor puede ejecutar cualquier aplicación.
Lo que acabas de escribir en llama es el trabajo de un servidor: construir environ, llamar a la aplicación y recoger la respuesta. Un servidor de verdad (gunicorn, por ejemplo) hace lo mismo pero además abre el puerto, entiende HTTP y gestiona muchos clientes a la vez.
WSGI tiene un límite: la función espera a terminar para devolver la respuesta. Mientras tanto, ese hilo no hace otra cosa. No cabe una conexión que se queda abierta (un chat con WebSockets) ni se aprovecha bien la espera de una BD. Con la llegada de async/await apareció ASGI: la misma idea, pero la función es async y la conversación con el servidor son mensajes.
Síncrono: una petición bloquea su hilo hasta terminar
Asíncrono: muchas conexiones a la vez en un bucle de eventos
WebSockets y conexiones largas
No
Sí
Frameworks
Flask, Django (modo clásico)
FastAPI, Starlette, Django (modo ASGI)
Servidores
gunicorn, uWSGI
uvicorn, hypercorn, daphne
¿Por qué? · En PHP no existe
¿Por qué existe un contrato aparte (WSGI/ASGI)? En PHP no existe
En PHP no hace falta: la forma de llamar a tu código la fija el propio PHP (el CGI y php-fpm vienen con el lenguaje) y todos los frameworks (Laravel, Symfony) empiezan en index.php.
En Python, servidor y framework son programas de distintos autores. Con un contrato común puedes cambiar de uno sin tocar el otro: la misma aplicación FastAPI corre en uvicorn o en hypercorn sin cambiar una línea, como cambiar de nginx a Caddy sin tocar PHP.
5 · Qué framework y qué servidor se usan
Hay tres frameworks que oirás nombrar siempre. Los comparo con los que ya conoces:
Framework
Qué es
Parecido en PHP
Contrato
Django
«Baterías incluidas»: ORM, panel de administración, usuarios, sesiones, formularios
Laravel o Symfony
WSGI y ASGI
Flask
Micro-framework: rutas y poco más, el resto lo eliges
Slim
WSGI
FastAPI
Para APIs: rutas con tipos, validación automática y documentación generada
Slim + validación + OpenAPI, todo junto
ASGI
La pregunta que te vas a hacer
Vale, pero… ¿cuál elijo y dónde lo aprendo?
Para una API como la app de tareas, FastAPI. Para una web con panel de administración y usuarios ya hechos, Django. Para algo muy pequeño, Flask. El servidor que se pone delante cambia poco: uvicorn para los frameworks ASGI (lo ves en la lección siguiente) y gunicorn para los WSGI.
FastAPI: el framework del curso, con su tutorial en español.
El programa tiene un enrutador a mano con un diccionario de rutas y solo conoce /. Añade la ruta /tareas (con la función lista que ya existe) para que imprima 200 Hay 2 tareas en vez de 404 No encontrada.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. El diccionario RUTAS va de ruta a función: añade "/tareas": lista (sin paréntesis: guardas la función, no la llamas).
Reto 2 de 3 · ✓ Resuelto
Enruta por método y ruta
Escribe enruta(metodo, ruta, rutas). rutas es un diccionario {(metodo, ruta): funcion}. Devuelve una tupla (estado, cuerpo): (200, <lo que devuelva la función>) si existe esa pareja; (405, "Método no permitido") si la ruta existe pero con otro método; (404, "No encontrada") si la ruta no existe. Es lo que hace nginx más el switch ($_SERVER['REQUEST_METHOD']) de un index.php.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Busca la clave con rutas.get((metodo, ruta)). Si no está, mira si la ruta aparece con otro método: any(r == ruta for _, r in rutas) recorre las claves de la forma (metodo, ruta).
Reto 3 de 3 · ✓ Resuelto
Valida el cuerpo de la petición
Escribe valida_cuerpo(cuerpo): recibe el diccionario que llega en el cuerpo de un POST /tareas y devuelve{"titulo": ..., "prioridad": ...}. El titulo es obligatorio, debe ser un texto y se devuelve sin espacios sobrantes. La prioridad es opcional (por defecto 1), debe ser un entero entre 1 y 3. Cualquier otra clave se ignora. Si algo no cumple, lanza ValueError. Es el trabajo que FastAPI hace por ti con pydantic.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Con cuerpo.get("titulo") no falla si falta. Comprueba isinstance(titulo, str) y que titulo.strip() no esté vacío; para la prioridad usa cuerpo.get("prioridad", 1), isinstance(..., int) y 1 <= prioridad <= 3.
Resumen
Lo que te llevas de esta lección
PHP nació para la web y Python no: PHP trae $_GET, $_POST, sesiones y un proceso por petición; Python es un lenguaje general y no trae nada de eso.
Para servir una API en Python hay que montar dos piezas: un framework (FastAPI) y un servidor (uvicorn). En PHP son «PHP» y «nginx + php-fpm».
Un framework, en el fondo, es un enrutador (ruta → función) con validación, sesiones y errores ya resueltos; tú lo harías a mano con un diccionario (como RUTAS).
WSGI (síncrono) y ASGI (asíncrono) son el contrato: la aplicación es una función que el servidor llama con los datos de la petición (environ o scope).
En Python la aplicación es un proceso siempre encendido que atiende muchas peticiones; en PHP cada petición arranca el script de cero.
Para recordarlo: «PHP trae la cocina; en Python montas la tuya»
FFramework rutas, validación, sesiones (FastAPI)
SServidor abre el puerto y habla HTTP (uvicorn)
CContrato ASGI: la app es una función
Para la web en Python necesitas Framework + Servidor y un Contrato que los une. «FSC»: en PHP las tres cosas vienen en el mismo paquete.