Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 39 de 47 · Un proyecto real ✦ WebMCP implementado

Python no nació para la web: de scripts a servidor

10 min de lectura 3 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).

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 webEn PHPEn Python
Leer lo que manda el navegador$_GET, $_POST, php://inputNada de serie: lo parsea el framework
Cookies y sesiones$_COOKIE, session_start(), $_SESSIONNada de serie: cookies firmadas o una BD, a cargo del framework
Elegir qué código atiende cada URLEl servidor mapea la URL a un fichero (/tareas.php) o un index.php con .htaccessNada de serie: el framework enruta con decoradores
Abrir el puerto y hablar HTTPnginx o Apache + php-fpmUn servidor aparte (uvicorn, gunicorn)
Responderheader(), http_response_code(), echoEl framework (return de un diccionario, un objeto de respuesta)
Qué pasa con cada peticiónUn proceso nuevo y limpio por peticiónUn 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
<?php
declare(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');
echo json_encode($salida);
Pythonmain.py
import json

tareas = [
    {"titulo": "Comprar pan", "hecha": False},
    {"titulo": "Llamar al banco", "hecha": True},
]


def lista_tareas(solo_pendientes):
    # En PHP: $soloPendientes = isset($_GET['pendientes']);  (ya viene rellenado)
    salida = [t for t in tareas if not 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},
]


def inicio():
    return 200, "app de tareas"


def lista():
    return 200, json.dumps(tareas)


RUTAS = {"/": inicio, "/tareas": lista}


def atiende(ruta):
    funcion = RUTAS.get(ruta)
    if funcion is None:
        return 404, "No encontrada"
    return funcion()


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:

Pythonmain.py
def crea_tarea(cuerpo):
    # En PHP: $titulo = trim($_POST['titulo'] ?? '');
    titulo = str(cuerpo.get("titulo", "")).strip()
    if not titulo:
        return 422, "titulo obligatorio"
    return 201, {"titulo": titulo, "hecha": False}


print(crea_tarea({"titulo": " Comprar pan "}))
print(crea_tarea({"titulo": "  "}))
print(crea_tarea({}))

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.

Pythonmain.py
def app(environ, start_response):
    if environ["PATH_INFO"] == "/":
        start_response("200 OK", [("Content-Type", "text/plain")])
        return [b"app de tareas"]
    start_response("404 Not Found", [("Content-Type", "text/plain")])
    return [b"No encontrada"]


def llama(ruta):
    estado = []

    def start_response(linea, cabeceras):
        estado.append(linea)

    entorno = {"REQUEST_METHOD": "GET", "PATH_INFO": ruta}
    cuerpo = b"".join(app(entorno, start_response))
    return estado[0], cuerpo.decode()


print(llama("/"))
print(llama("/nada"))

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.

Pythonmain.py
import asyncio


async def app(scope, receive, send):
    if scope["path"] == "/":
        estado, cuerpo = 200, b"app de tareas"
    else:
        estado, cuerpo = 404, b"No encontrada"
    await send({"type": "http.response.start", "status": estado, "headers": [(b"content-type", b"text/plain")]})
    await send({"type": "http.response.body", "body": cuerpo})


async def llama(ruta):
    mensajes = []

    async def receive():
        return {"type": "http.request", "body": b""}

    async def send(mensaje):
        mensajes.append(mensaje)

    await app({"type": "http", "method": "GET", "path": ruta}, receive, send)
    return mensajes


for ruta in ["/", "/nada"]:
    print(ruta, asyncio.run(llama(ruta)))
AspectoWSGIASGI
La aplicación es…def app(environ, start_response)async def app(scope, receive, send)
EstiloSíncrono: una petición bloquea su hilo hasta terminarAsíncrono: muchas conexiones a la vez en un bucle de eventos
WebSockets y conexiones largasNoSí
FrameworksFlask, Django (modo clásico)FastAPI, Starlette, Django (modo ASGI)
Servidoresgunicorn, uWSGIuvicorn, 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:

FrameworkQué esParecido en PHPContrato
Django«Baterías incluidas»: ORM, panel de administración, usuarios, sesiones, formulariosLaravel o SymfonyWSGI y ASGI
FlaskMicro-framework: rutas y poco más, el resto lo eligesSlimWSGI
FastAPIPara APIs: rutas con tipos, validación automática y documentación generadaSlim + validación + OpenAPI, todo juntoASGI

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.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Añade una ruta

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

Resumen

Lo que te llevas de esta lección

  1. 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.
  2. 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».
  3. 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).
  4. 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).
  5. 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.