Flask Python: qué es, cómo instalarlo y tu primer Hola Mundo

Si estás dando tus primeros pasos en el desarrollo web con Python y ya tienes tu entorno listo para desarrollar en Flask, este es el siguiente paso natural: crear tu primera aplicación funcional. Flask es uno de los frameworks más ligeros y flexibles del ecosistema Python, y por esa razón se ha convertido en el punto de entrada favorito de muchos desarrolladores.

Cuando comencé con frameworks en Python, descubrí que Flask es el candidato perfecto para iniciar: su estructura minimalista te deja concentrarte en entender la lógica del servidor sin distraerte con capas o módulos innecesarios que aún no necesitas.

Flask es un microframework web para Python, ideal para crear aplicaciones web del lado del servidor. Al ser un microframework, trae únicamente lo mínimo necesario para funcionar, lo que te permite ir descubriendo cómo trabaja cada parte del framework sin confundirte con archivos o carpetas que no has generado tú mismo. Esto contrasta con frameworks más robustos como Django, que al crear un proyecto nuevo ya incluye una estructura de directorios extensa con múltiples archivos preconfigurados.

Qué es Flask y por qué es ideal para empezar con Python

Flask es un microframework web para Python. El término "micro" no significa que sea limitado o poco potente, sino que incluye solo lo esencial para poner una app en marcha: un servidor web interno (Werkzeug) y un sistema de rutas. Todo lo demás —autenticación, ORM, formularios— lo añades tú según lo necesites, a través de extensiones del ecosistema Flask.

Esta filosofía lo convierte en una herramienta perfecta para aprender cómo funciona realmente una aplicación web, porque cada pieza que aparece en tu proyecto es una pieza que tú pusiste conscientemente.

Qué significa que Flask sea un "microframework"

Ser microframework implica que Flask no impone una estructura rígida sobre tu proyecto. Tú decides cómo organizar tu código, qué librerías usar y cómo escalar tu aplicación con el tiempo. Esa libertad es precisamente lo que lo vuelve tan atractivo para quienes inician: aprendes de verdad cómo se conectan las partes de una aplicación web, en lugar de seguir una convención opaca que no entiendes del todo.

Diferencias entre Flask y Django

Cuando probé Django por primera vez, me impresionó su robustez, pero también la cantidad de carpetas y archivos que genera al crear un proyecto desde cero.

Con Flask, en cambio, puedes tener una aplicación completamente funcional en apenas unas líneas de código. Eso lo hace ideal para entender desde adentro cómo funciona una aplicación web: el ciclo de vida de una petición HTTP, cómo se definen las rutas, cómo se genera la respuesta. Con Django muchas de esas cosas ocurren "por arte de magia"; con Flask, las ves suceder.

Instalar Flask y preparar el entorno de desarrollo

Antes de escribir código, vamos a preparar el entorno para nuestra primera app. Primero crea una carpeta en el Escritorio o donde prefieras alojar el proyecto —por ejemplo, primera_app— y luego abre la terminal (en Linux/Mac) o el CMD (en Windows) y navega a ese directorio con el comando cd.

Como editor de código puedes usar Visual Studio Code, aunque para este ejercicio inicial incluso el bloc de notas es suficiente. Ahora, entra a la carpeta que creaste:

Antes de escribir código, es una buena práctica configurar un entorno virtual para aislar las dependencias del proyecto y evitar conflictos con otras instalaciones de Python en tu sistema.

Crear un entorno virtual en Python para Flask

En tu terminal o consola ejecuta:

$ python -m venv venv
$ source venv/bin/activate  # En Linux/Mac
$ venv\Scripts\activate     # En Windows

Verás que el nombre del entorno aparece entre paréntesis al inicio del prompt —por ejemplo, (venv)—, lo que indica que está activo correctamente. Esto aísla las dependencias del proyecto y evita errores futuros.

Instalar Flask con pip

Con el entorno virtual activo, instala Flask ejecutando:

$ pip install Flask

Una vez que termine la instalación, ya puedes usar Flask en tu proyecto. Puedes verificar que se instaló correctamente con pip show Flask, que te mostrará la versión instalada.

Crear tu primer "Hola Mundo" con Flask

Es momento de crear el "Hola Mundo" con Flask: implementar lo mínimo necesario para ver algo en el navegador y entender cómo responde el servidor a una petición.

Estructura mínima de un proyecto Flask

Por ahora, la estructura del proyecto es deliberadamente simple:

/primera_app
└── main.py

Crea el archivo main.py dentro de la carpeta del proyecto y escribe el siguiente código:

main.py

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world() -> str:
    return 'Hello Flask!'

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

Ese bloque de código es una aplicación web completamente funcional basada en Flask. Aquí es donde el término "microframework" cobra todo su sentido: con apenas unas pocas líneas ya tienes un servidor web operativo que responde peticiones HTTP. Al acceder a la raíz del sitio, Flask ejecutará la función hello_world() y devolverá el texto 'Hello Flask!' al navegador.

Explicación línea por línea del código

• from flask import Flask: importamos la clase base del framework. Es el núcleo de toda aplicación Flask.
• app = Flask(__name__): creamos una instancia de la aplicación. El argumento __name__ le indica a Flask el nombre del módulo actual, lo cual es necesario para localizar recursos como plantillas o archivos estáticos.
• @app.route('/'): este decorador asocia la función hello_world() a la ruta raíz ('/'). Cada vez que alguien haga una petición GET a esa URL, Flask ejecutará esa función.
• return 'Hello Flask!': la respuesta que verá el usuario en el navegador.
• app.run(): lanza el servidor local de desarrollo basado en Werkzeug, que escucha en http://127.0.0.1:5000 por defecto.

Ejecutar la aplicación Flask y ver el resultado

Levanta el servidor de desarrollo ejecutando en tu terminal:

$ python main.py

En la terminal verás una salida similar a esta:

 * Serving Flask app 'main'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000

Abre tu navegador y accede a:

http://127.0.0.1:5000

Verás el mensaje:

Hello Flask!

en pantalla. La dirección 127.0.0.1 es el loopback de tu propia máquina (equivalente a localhost), y 5000 es el puerto por defecto que usa Flask.

Analicemos con más detalle las partes clave del código. Mediante:

from flask import Flask
app = Flask(__name__)

Importamos la clase Flask y creamos una instancia llamada app. Desde esa instancia se pueden realizar múltiples configuraciones a nivel de proyecto: conexión a base de datos, envío de emails, sistema de rutas, entre otras. Por ahora, la usamos únicamente para definir una ruta:

@app.route('/')

Este decorador es la forma en que Flask conecta una URL con una función Python. En este ejemplo, la ruta '/' queda asignada a la función de vista hello_world(). Cuando un usuario accede a esa URL, Flask ejecuta la función y devuelve su resultado como respuesta HTTP.

Finalmente, la aplicación se lanza con:

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

El condicional if __name__ == '__main__': verifica si el módulo actual es el programa principal en ejecución —y no un módulo importado desde otro archivo—. Si se cumple, se inicia el servidor web interno de Flask (Werkzeug). Esto es una convención de Python que evita que el servidor se levante accidentalmente al importar el módulo desde otro script.

Por cierto, si quieres devolver contenido HTML en lugar de texto plano, simplemente cambia el valor de retorno:

main.py

@app.route('/')
def hello_world():
    return '<h1>Hello World!</h1>'

Flask interpretará esa cadena como HTML y el navegador la renderizará correctamente.

Activar el modo debug en Flask

El modo debug es una herramienta imprescindible durante el desarrollo. Con él activo, Flask muestra errores detallados directamente en el navegador y en la consola, lo que te permite identificar y corregir problemas de forma rápida y eficiente. Además —y esto es igual de valioso— el servidor se recarga automáticamente cada vez que guardas cambios en el código fuente, sin necesidad de detenerlo y volver a levantarlo manualmente.

Con tu aplicación Flask creada, activa el modo debug pasando debug=True a app.run():

if __name__ == '__main__':
    app.run(debug=True)

Con esto, el servidor se recargará automáticamente ante cada cambio. También puedes activar el debug desde un archivo de configuración externo, que es lo recomendado cuando la aplicación crece, para mantener el código bien organizado.

Importante: nunca actives el modo debug en un entorno de producción. El modo debug expone información interna de la aplicación que puede representar un riesgo de seguridad.

Errores comunes al iniciar con Flask y cómo solucionarlos

"Port 5000 already in use"

El puerto 5000 ya está siendo usado por otro proceso. Puedes cambiar el puerto directamente desde app.run():

app.run(debug=True, port=5001)

O bien detener el proceso que ocupa ese puerto antes de lanzar Flask.

Flask no muestra la página en el navegador

Verifica que estés en la carpeta correcta del proyecto y que el entorno virtual esté activo antes de ejecutar python main.py. Si la terminal no muestra el mensaje Running on http://127.0.0.1:5000, es probable que el servidor no haya arrancado correctamente; revisa los mensajes de error en la consola.

"An attempt was made to access a socket in a way forbidden by its access permissions"

Es un error de permisos del sistema operativo que impide levantar el servidor en la IP o puerto especificado. Puedes resolverlo cambiando el host o el puerto en app.run():

app.run(debug=True, host="0.0.0.0", port=5050)

Usar host="0.0.0.0" hace que el servidor escuche en todas las interfaces de red disponibles, lo que también es útil si quieres acceder a la app desde otro dispositivo en tu red local.

Recomendaciones para principiantes con Flask

• Usa siempre entornos virtuales. Mantiene las dependencias de cada proyecto aisladas y evita conflictos entre versiones de paquetes.
• Nunca uses el servidor de desarrollo en producción. El servidor integrado de Flask (Werkzeug) está pensado exclusivamente para desarrollo local. Para producción usa servidores WSGI como Gunicorn o uWSGI.
• Lee los mensajes de la terminal. Flask da pistas muy útiles sobre lo que está pasando. Antes de buscar en Google, lee el traceback completo; casi siempre la respuesta está ahí.
• Activa el modo debug solo en desarrollo. Nunca lo dejes activo en un servidor de producción.

Conclusión y próximos pasos

En este tutorial vimos cómo instalar Flask, crear un entorno virtual, escribir una aplicación mínima y levantarla en el servidor de desarrollo local. También entendimos línea por línea qué hace cada parte del código y cómo activar el modo debug para facilitar el desarrollo.

Personalmente, lo que más me gustó de Flask al empezar es que te permite aprender desde la base, sin configuraciones excesivas ni magia oculta. Cada línea de código tiene un propósito claro y visible.

El siguiente paso natural es explorar:

• Cómo manejar rutas adicionales en Flask.

Flask es el punto de partida ideal para crecer hacia proyectos reales en Python.

Preguntas frecuentes sobre Flask

• ¿Qué es Flask y para qué sirve?
  • Es un microframework de Python para crear aplicaciones web del lado del servidor de forma simple, flexible y extensible. Puedes usarlo desde un proyecto personal pequeño hasta una API en producción.
• ¿Cómo crear un "Hola Mundo" con Flask paso a paso?
  • Instala Flask con pip install Flask, crea main.py, define la ruta '/' con @app.route('/') y ejecuta python main.py. Luego abre http://127.0.0.1:5000 en el navegador.
• ¿Por qué Flask se llama microframework?
  • Porque ofrece solo lo mínimo para funcionar —un sistema de rutas y un servidor web interno— sin imponer estructura ni dependencias adicionales. Tú agregas lo que necesitas.
• ¿Cómo devolver HTML en lugar de texto en Flask?
  • Cambia el return de la función de vista a una cadena HTML, por ejemplo: return '<h1>Hola Mundo</h1>'. Flask lo enviará como respuesta HTML al navegador.
• ¿Qué diferencia hay entre Flask y Django?
  • Flask te deja construir desde cero con total libertad; Django provee una estructura completa y convenciones establecidas, pensado para proyectos grandes con muchos módulos. Para aprender, Flask es más transparente; para proyectos con muchas funcionalidades out-of-the-box, Django puede ser más conveniente.
• ¿A qué dirección accedo cuando levanto Flask?
  • Por defecto Flask escucha en http://127.0.0.1:5000. La IP 127.0.0.1 corresponde a tu propia máquina (localhost) y el puerto 5000 es el que Flask asigna automáticamente al servidor de desarrollo.