100 Días de Código en Python — Día 54: Tu primer servidor web con Flask (y los decoradores que lo hacen posible)

🎯 Objetivo de aprendizaje#

Explicar con tus palabras qué hacen el cliente, el servidor y la base de datos, y en qué se diferencia un sitio web de una aplicación web.

📝 Contenido original del curso#

En los Días 41 a 44 hiciste sitios con HTML y CSS: eso es el frontend, lo que el usuario ve. Una aplicación web necesita además un backend: la parte que hace los cálculos, aplica las reglas del negocio y maneja los datos. Full stack significa dominar ambos.

• Frontend: HTML (estructura), CSS (estilo) y JavaScript (interactividad). Frameworks populares: Angular, React.
• Backend: puede escribirse en JavaScript, Java, Python, Ruby… Frameworks de Python: Flask, Django, Bottle, CherryPy, Pyramid. Los más pedidos en ofertas de empleo son Flask (mejor para principiantes y proyectos pequeños) y Django (proyectos comerciales grandes).

Los tres componentes del backend:

Cuando escribes google.com y presionas Enter, el navegador envía una solicitud (request) al servidor, que responde con archivos HTML, CSS y JavaScript. Si la página necesita datos (tus boletas en Eventbrite, tus listas de Spotify), el servidor los saca de la base de datos, los pone dentro del HTML y envía el "plato terminado". El cliente nunca entra a la cocina ni a la despensa.

📖 Ya conoces el otro lado (adaptación)#

Desde el Día 33 has sido cliente muchas veces: requests.get(url) envía una solicitud y recibe una respuesta con un código de estado (200, 404…). Hoy cambias de lado: vas a escribir el programa que recibe esas solicitudes y decide qué responder.

Días 33–53:  tu programa ──request──▶ servidor ajeno ──response──▶ tu programa
Día 54+:     navegador   ──request──▶ TU servidor   ──response──▶ navegador

🎯 Objetivo de aprendizaje#

Crear, ejecutar y detener un servidor Flask mínimo, y distinguir un framework de una biblioteca.

📝 Contenido original del curso#

Biblioteca contra framework. Con una biblioteca (como requests o Beautiful Soup), tú la llamas cuando la necesitas: requests.get(...). Con un framework, él te llama a ti: tú escribes funciones con la forma que el framework exige y él decide cuándo ejecutarlas. Solo tienes que planear: "si pasa esta situación, ¿qué código debe correr?".

Lo primero es la documentación. El Quickstart de Flask muestra una aplicación mínima. La profesora crea un proyecto hello_flask con un archivo hello.py:

from flask import Flask

app = Flask(__name__)


@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"

Cuidado con el nombre del archivo. Si llamas a tu archivo igual que una biblioteca (por ejemplo requests.py o flask.py), el import carga tu archivo en lugar de la biblioteca y aparece un error confuso como "requests no tiene el atributo get".

Instalar Flask: con la bombilla roja de PyCharm, desde la configuración del intérprete, o en la terminal con pip install Flask. Cualquier paquete de pypi.org se instala con pip.

Ejecutarlo: ejecutar hello.py "normalmente" termina con código de salida 0 y no pasa nada: definir la aplicación no la pone a funcionar. Según el Quickstart de esa época, hay que indicar a Flask qué archivo contiene la aplicación con una variable de entorno y luego ejecutar flask run:

# Mac
export FLASK_APP=hello.py
flask run

:: Windows (símbolo del sistema)
set FLASK_APP=hello.py
flask run

Aparece una dirección como http://127.0.0.1:5000: es tu sitio, servido por tu propio computador. Flask advierte que es un servidor de desarrollo y que no debe usarse en producción. En las herramientas de desarrollo de Chrome se ve que Flask envolvió tu texto en un documento HTML completo. Para detener el servidor: Ctrl + C. Si no lo detienes e intentas ejecutar otra aplicación en la misma dirección, la segunda no arrancará.

🛠️ Nota técnica (Flask 3.1, verificado): hoy la forma recomendada por la documentación es indicar la aplicación en el mismo comando, sin variables de entorno:

12

flask --app hello run            # funciona igual en Windows, Mac y Linux
flask --app hello run --debug    # con recarga automática y depurador (Día 55)

Además, si el archivo se llama app.py o wsgi.py, basta con flask run. Y si usas PowerShell (la terminal por defecto de VS Code en Windows), set FLASK_APP=... no funciona; la sintaxis es $env:FLASK_APP = "hello.py".

🛠️ Nota técnica (Python 3.14, verificado): las versiones recientes de Python ya ayudan con el error del nombre del archivo:

12

AttributeError: module 'requests' has no attribute 'get' (consider renaming '...\requests.py'
if it has the same name as a library you intended to import)

Si ves "consider renaming", ya sabes qué pasó. Borra también la carpeta __pycache__ que se haya creado junto a tu archivo.

📖 Qué significa 127.0.0.1:5000 (adaptación)#

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1 — Aplicación: cambia el mensaje de la ruta / por un saludo al salón y agrega una ruta /bye que diga "¡Hasta luego!".
• 🟡 Reto 2 — Ampliación: agrega tres rutas más (/horario, /materias, /contacto) y comprueba cuáles existen con flask --app hello routes.
• 🟠 Reto 3 — Desafío: visita una ruta que no existe. ¿Qué código de estado devuelve? Compruébalo con requests.get("http://127.0.0.1:5000/no-existe").status_code desde otro programa mientras el servidor corre.
• 🔴 Reto 4 — Pensamiento computacional: dibuja el recorrido completo de una solicitud a /horario: desde que presionas Enter en el navegador hasta que ves el texto. Marca qué parte hace el navegador, cuál hace Flask y cuál hace tu función.

🎯 Objetivo de aprendizaje#

Moverte por las carpetas y crear, ver y borrar archivos desde la terminal, de forma segura.

📝 Contenido original del curso#

Kernel y shell. Si el sistema operativo fuera un pistacho, la semilla sería el kernel (el programa que habla con el hardware) y la cáscara sería el shell (la interfaz para que los humanos hablen con el kernel). Hay shells gráficos (el Explorador de archivos, el Finder) y de línea de comandos. ¿Por qué usar la línea de comandos? Más control y, con práctica, más rapidez.

En Mac, la aplicación es Terminal (con zsh desde macOS Catalina); en Windows, el Símbolo del sistema. La terminal de PyCharm es una de esas mismas terminales dentro del editor.

La profesora insiste: rm -rf no pide confirmación ni manda nada a la papelera. "Un gran poder conlleva una gran responsabilidad": verifica en qué carpeta estás y qué vas a borrar. Para aprender más comandos, busca una "cheat sheet" de la terminal o del símbolo del sistema.

🛠️ Nota técnica: el video afirma que "en su mayor parte" los mismos comandos sirven en Windows y en Mac. Eso es cierto en PowerShell (que tiene alias como ls, pwd y rm), pero no en el Símbolo del sistema (cmd), donde pwd, ls, touch y rm no existen. Equivalencias:

🏫 Para el aula (adaptación)#

• Trabaja siempre dentro de una carpeta de práctica (por ejemplo Documentos\python_decimo). Nunca ejecutes un borrado recursivo desde C:\ ni desde tu carpeta de usuario.
• Antes de borrar, ejecuta ls (o dir) y lee lo que vas a eliminar.
• Rutas con espacios van entre comillas: cd "Mis proyectos".

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: solo con la terminal, crea sitio_salon/templates y sitio_salon/static (las necesitarás el Día 56) y un archivo sitio_salon/server.py.
• 🟡 Reto 2: muévete entre esas carpetas usando solo rutas relativas (.., nombres) y luego una absoluta. ¿Cuál es más cómoda y cuál es más segura?
• 🟠 Reto 3: crea tres archivos de prueba, bórralos uno por uno y luego borra la carpeta que los contenía. Antes de cada borrado, ejecuta el comando que lista el contenido.
• 🔴 Reto 4: escribe una "cheat sheet" de 10 comandos para tu sistema operativo y tu terminal, con un ejemplo probado de cada uno.

🎯 Objetivo de aprendizaje#

Explicar qué contiene __name__ y para qué sirve if __name__ == "__main__":.

📝 Contenido original del curso#

Flask(__name__) recibe un único dato obligatorio, el nombre de importación. Al imprimir __name__ en el archivo que se está ejecutando, aparece __main__: significa que el código se ejecuta como programa principal, no como un módulo importado por otro. En cambio, random.__name__ es "random".

Esto permite una forma común de arrancar Flask:

if __name__ == "__main__":
    app.run()

app.run() hace lo mismo que flask run, pero sin variable de entorno y usando los botones normales de Ejecutar y Detener del editor.

📖 Explicación conceptual#

__name__ es una variable que Python crea automáticamente en cada módulo (cada archivo .py):

Por eso el bloque if __name__ == "__main__": es un "solo si me ejecutan directamente". Con flask run, ese bloque no se ejecuta, y no pasa nada malo: Flask arranca el servidor por su cuenta. Así el mismo archivo sirve de las dos formas.

🛠️ Nota técnica: la transcripción dice que __name__ sirve para averiguar "el nombre de la clase, función, método o descriptor actual". Funciones y clases tienen su propio atributo __name__ (print.__name__ es "print"), pero la variable __name__ que usas suelta en un archivo es el nombre del módulo. Es la que recibe Flask(__name__) para saber dónde buscar las carpetas templates y static (Día 56).

⚠️ Errores frecuentes#

🎯 Objetivo de aprendizaje#

Pasar funciones como argumentos, definir funciones anidadas y devolver una función desde otra.

📝 Contenido original del curso#

La línea @app.route("/") es un decorador. Para entenderlo, primero hay que saber tres cosas sobre las funciones de Python. La profesora usa cuatro funciones de calculadora:

def add(n1, n2):
    return n1 + n2

def subtract(n1, n2):
    return n1 - n2

def multiply(n1, n2):
    return n1 * n2

def divide(n1, n2):
    return n1 / n2

1. Se pueden pasar como argumento (son "objetos de primera clase", igual que un entero o un texto):

def calculate(calc_function, n1, n2):
    return calc_function(n1, n2)

result = calculate(multiply, 2, 3)
print(result)   # 6   (con add sería 5)

2. Se pueden anidar: una función definida dentro de otra solo existe dentro de ella. Llamarla desde fuera da NameError.

def outer_function():
    print("I'm outer")

    def nested_function():
        print("I'm inner")

    nested_function()

outer_function()   # I'm outer / I'm inner

3. Se pueden devolver sin ejecutarlas (sin paréntesis), guardarlas en una variable y llamarlas después:

def outer_function():
    print("I'm outer")

    def nested_function():
        print("I'm inner")

    return nested_function

inner_function = outer_function()   # imprime "I'm outer"
inner_function()                    # imprime "I'm inner"

La profesora recomienda recorrer este código paso a paso en Python Tutor, que dibuja cómo la variable inner_function termina apuntando a nested_function.

📖 La clave: con paréntesis o sin paréntesis (adaptación)#

Ya lo usaste sin notarlo: en Turtle, screen.onkey(key="Up", fun=snake.up) (Día 20) y en Tkinter, Button(command=calcular) (Día 27). Pasabas la función sin paréntesis para que otro la llamara después. Eso es exactamente lo que hace Flask con tus rutas.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: agrega una función power(n1, n2) y úsala con calculate.
• 🟡 Reto 2: crea un diccionario operaciones = {"+": add, "-": subtract, ...} y úsalo para calcular a partir de un símbolo que escribe el usuario (como la calculadora del Día 10).
• 🟠 Reto 3: escribe aplicar_a_todos(funcion, lista) que devuelva una lista con funcion(x) para cada elemento. Pruébala con abs, str y una función propia.
• 🔴 Reto 4: escribe crear_multiplicador(n) que devuelva una función que multiplica por n. Con ella crea doble y triple. Explica por qué doble "recuerda" el 2.

🎯 Objetivo de aprendizaje#

Escribir un decorador, aplicarlo con @ y explicar qué hace @app.route.

📝 Contenido original del curso#

Un decorador es una función que envuelve a otra para darle funcionalidad adicional (antes, después o modificándola) sin cambiar su código. Usa las cuatro ideas de la sección 4: recibe una función, define otra adentro, la llama y la devuelve sin paréntesis.

import time


def delay_decorator(function):
    def wrapper_function():
        time.sleep(2)
        # hacer algo antes
        function()
        function()
        # hacer algo después
    return wrapper_function


@delay_decorator
def say_hello():
    print("Hello")


def say_greeting():
    print("How are you?")


say_hello()   # espera 2 s e imprime "Hello" dos veces

El problema que resuelve: si quisieras un retraso en say_hello, say_bye y say_greeting, tendrías que copiar time.sleep(2) en las tres. Con el decorador, lo escribes una vez y lo aplicas donde quieras.

@ es azúcar sintáctico. Estas dos formas son equivalentes:

@delay_decorator
def say_hello():
    print("Hello")

def say_greeting():
    print("How are you?")

decorated_function = delay_decorator(say_greeting)
decorated_function()

La primera es más fácil de leer: al ver la función, ves de inmediato qué "filtro" tiene encima.

De vuelta a Flask: @app.route("/") es un decorador que le dice a Flask "cuando alguien pida la ruta /, ejecuta esta función". Si agregas

@app.route("/bye")
def say_bye():
    return "Bye"

visitar /bye ejecuta say_bye. Es el framework quien decide qué función llamar, según la ruta.

📝 Ejercicio original del curso: el decorador que mide el tiempo#

(Reconstruido a partir del final de la lección 393: "un ejercicio de codificación para crear sus propias funciones de decorador… medirá la cantidad de tiempo que tarda una función en ejecutarse". El enunciado completo no está entre los archivos suministrados.)

Crea un decorador que, al aplicarse a una función, la ejecute e imprima cuánto tiempo tardó.

🔍 Antes de programar#

• ¿Qué necesitas medir? El momento antes y el momento después de llamar a la función.
• ¿Dónde va esa medición: en el decorador o en el wrapper? (Pista: ¿cuál se ejecuta cada vez que llamas a la función?)
• ¿Cómo sabes el nombre de la función que estás midiendo? (Pista: las funciones tienen el atributo __name__.)

Una posible estructura, para que la completes:

import time

def speed_calc_decorator(function):
    def wrapper():
        inicio = ...
        function()
        fin = ...
        print(f"{function.__name__} tardó {...:.3f} segundos")
    return wrapper


@speed_calc_decorator
def fast_function():
    for i in range(1_000_000):
        i * i


@speed_calc_decorator
def slow_function():
    for i in range(10_000_000):
        i * i


fast_function()
slow_function()

💡 Para medir tiempos cortos, time.perf_counter() es más preciso que time.time().

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1 — Aplicación: un decorador @repetir_tres que ejecute la función tres veces.
• 🟡 Reto 2 — Ampliación: un decorador @anunciar que imprima "Empezando…" antes y "Listo." después.
• 🟠 Reto 3 — Desafío: aplica dos decoradores a la misma función (@anunciar y @speed_calc_decorator). Cambia el orden. ¿Cambia lo que se imprime? Explica por qué.
• 🔴 Reto 4 — Pensamiento computacional: en el Día 52 el bot necesitaba reintentar un clic cuando fallaba. Diseña (en papel o en código) un decorador @reintentar que vuelva a ejecutar una función si lanza una excepción, hasta 3 veces. ¿Qué pasa si la función necesita argumentos? (Lo resolverás el Día 55 con *args y **kwargs.)

Problema#

El salón necesita una "cartelera" en la red local: una página con el horario, los anuncios y un saludo, que el representante pueda actualizar editando un archivo Python.

Contexto#

Hasta ahora tus páginas eran archivos HTML que se abrían con doble clic. Un servidor puede calcular la respuesta en el momento: la fecha de hoy, el día de la semana, el anuncio vigente.

Objetivo#

Una aplicación Flask con varias rutas que devuelvan HTML generado con Python, y un decorador propio aplicado a las rutas.

Requisitos funcionales#

1. Ruta / con un saludo y la fecha de hoy (módulo datetime, Día 32).
2. Ruta /horario con las clases de hoy según el día de la semana (un diccionario {"lunes": [...], ...}).
3. Ruta /anuncio con un anuncio elegido al azar de una lista.
4. Un decorador @registrar_visita que, cada vez que se visite una ruta, imprima en la terminal la hora y el nombre de la función.
5. El servidor se puede arrancar con flask --app server run y con el botón Ejecutar.

Restricciones técnicas#

• Nombre del archivo: server.py (no flask.py).
• Rutas definidas con @app.route.
• app.run() dentro de if __name__ == "__main__":.

Planificación#

1. Comprender. 2. Entradas: la ruta que pide el navegador y la fecha del sistema. 3. Procesos: elegir la función según la ruta, calcular, construir el HTML. 4. Salidas: texto HTML. 5. Dividir: una función por ruta y un decorador. 6. Diseñar el diccionario del horario. 7. Implementar. 8. Probar. 9. Corregir. 10. Mejorar.

Construcción paso a paso#

• Versión 1: la ruta / con un texto fijo.
• Versión 2: la fecha de hoy en la ruta /.
• Versión 3: las rutas /horario y /anuncio.
• Versión 4: el decorador @registrar_visita (escríbelo primero en un archivo aparte, sin Flask, y pruébalo con funciones normales).
• Versión final: aplica el decorador a las rutas.

⚠️ Aviso para la versión final: al aplicar tu decorador a dos o más rutas aparecerá un error nuevo (AssertionError: View function mapping is overwriting an existing endpoint function: wrapper). Es esperado: lo entenderás y lo resolverás el Día 55 (sección 4). Mientras tanto, aplícalo a una sola ruta. (Si pruebas a poner @registrar_visita encima de @app.route(...), el error desaparece… pero las visitas dejan de registrarse, porque Flask guardó la función original antes de que tu decorador la envolviera. Compruébalo y explica por qué.)

Pruebas#

🧪 Prueba y depuración#

from flask import Flask
app = Flask("__name__")

@app.route("/")
def inicio():
    return "Hola"

@app.route("/")
def horario():
    return "Horario"

if __name__ == "__main__":
    app.run

Encuentra tres problemas (ninguno produce un mensaje de error, lo que los hace más traicioneros):

• "__name__" entre comillas: debe ser la variable. Con el texto, Flask no sabe dónde está tu archivo y busca las carpetas templates y static en la carpeta desde donde ejecutas (verificado); el Día 56 eso rompe las plantillas.
• Dos funciones en la misma ruta /: Flask atiende con la primera y horario() nunca se ejecuta (verificado).
• app.run sin paréntesis: nombra la función pero no la llama; el programa termina sin arrancar el servidor.

⭐ Extensión del proyecto#

• Ruta /cumpleanos que diga quién cumple años hoy (datos ficticios en un diccionario).
• Leer los anuncios de un archivo anuncios.txt para que el representante no tenga que tocar el código.

Situación#

Tu grupo va a mantener varios programas del bloque de automatización (Días 45 a 53) y quiere funciones "comodín" reutilizables para medir, registrar y proteger funciones.

Requisitos#

1. Un módulo herramientas.py con al menos tres decoradores sin argumentos (por ejemplo: @cronometrar, @registrar que escriba en registro.txt la fecha y el nombre de la función, y @silenciar_errores que atrape cualquier excepción, la escriba en el registro y no detenga el programa).
2. Un archivo demo.py que importe el módulo y lo use con al menos cuatro funciones.
3. En herramientas.py, un bloque if __name__ == "__main__": con pruebas que solo se ejecuten al correr ese archivo directamente.

Decisiones que debes tomar (y justificar)#

• ¿Es buena idea @silenciar_errores? ¿En qué casos es peligroso esconder un error?
• ¿En qué orden aplicarías @cronometrar y @registrar sobre la misma función?

Casos de prueba#

• Importar herramientas desde demo.py no ejecuta las pruebas internas.
• Una función decorada con @silenciar_errores que hace 1 / 0 deja una línea en registro.txt y el programa continúa.

Conceptuales#

1. Con la analogía del restaurante, ¿qué parte es el cliente, cuál el servidor y cuál la base de datos?
2. ¿En qué se diferencia una biblioteca de un framework? Da un ejemplo de cada uno.
3. ¿Por qué no debes llamar a tu archivo flask.py?
4. ¿Qué vale __name__ cuando ejecutas un archivo directamente? ¿Y cuando se importa?
5. ¿Qué hace un decorador? ¿Qué significa que @ sea "azúcar sintáctico"?

Análisis de código#

def outer():
    print("A")
    def inner():
        print("B")
    print("C")
    return inner

f = outer()
f()
f()

¿Qué imprime y en qué orden?

Predicción#

def decorador(funcion):
    def wrapper():
        print("antes")
        funcion()
        print("después")
    return wrapper

@decorador
def saludar():
    print("hola")

print("inicio")
saludar()

Depuración#

def mi_decorador(funcion):
    def wrapper():
        funcion()
    return wrapper()

@mi_decorador
def hola():
    print("Hola")

hola()

¿Qué se imprime, qué error aparece y en qué línea está el problema?

Modificación#

Cambia delay_decorator para que el número de segundos de espera se imprima antes de esperar ("Esperando 2 segundos…").

Creación#

Desde la terminal (sin usar el Explorador de archivos), crea una carpeta mi_api, un archivo app.py con una ruta /ping que responda "pong" y ejecútalo solo con flask run. ¿Por qué aquí no necesitas --app?