Flask por Santiago Soñora
Este tutorial está diseñado para guiar a quienes desean aprender más acerca de Flask. Es ideal para un nivel medio.
Este tutorial está diseñado para guiar a quienes desean aprender más acerca de Flask. Es ideal para un nivel medio.
Flask es un microframework versátil para desarrollar aplicaciones web y APIs en Python, conocido por su simplicidad y extensibilidad. Esta guía de nivel intermedio explora funcionalidades clave como el enrutamiento con manejo de métodos HTTP y parámetros dinámicos, el uso del motor de plantillas Jinja2 para renderizar contenido HTML dinámico, el manejo de formularios y datos de petición, la organización de aplicaciones más grandes con Blueprints, la integración básica con bases de datos a través de Flask-SQLAlchemy, y la comprensión de los contextos de petición y aplicación. Permite ir más allá de las aplicaciones simples para construir servicios web más estructurados y funcionales.
Una aplicación mínima de Flask que muestra un mensaje en el navegador. A nivel intermedio, se podría mostrar renderizando una plantilla básica.
from flask import Flask, render_template_string
app = Flask(__name__)
@app.route('/')
def hello():
return render_template_string('<h1>Hola, mundo desde Flask!</h1>')
if __name__ == '__main__':
app.run(debug=True)Resultado:
Hola, mundo desde Flask! (mostrado en http://localhost:5000)Familiarizarse con estos comandos es esencial para interactuar eficientemente con Flask:
pip install Flaskpip install Flask-SQLAlchemyflask --app mi_app:app --debug run@app.route('/formulario', methods=['GET', 'POST'])@app.route('/usuario/<int:user_id>')from flask import render_template
@app.route('/perfil/<nombre>')
def mostrar_perfil(nombre):
return render_template('perfil.html', usuario=nombre)from flask import request
@app.route('/procesar-datos', methods=['POST'])
def procesar_datos():
nombre = request.form.get('nombre') # Acceso seguro a datos de formulario
return f'Nombre recibido: {nombre or "(vacío)"}'from flask import request
@app.route('/buscar')
def buscar_producto():
query = request.args.get('q') # Acceso seguro a parámetros URL
pagina = request.args.get('page', 1, type=int)
return f'Buscando "{query or "(vacío)"}" en página {pagina}'from flask import jsonify
@app.route('/api/usuario/<int:user_id>')
def get_user_api(user_id):
# Simula obtener datos de la base de datos
usuario = {'id': user_id, 'nombre': f'Usuario {user_id}'}
return jsonify(usuario)# archivo: admin/routes.py
from flask import Blueprint
admin_bp = Blueprint('admin', __name__, url_prefix='/admin')
@admin_bp.route('/')
def admin_index(): return 'Panel Admin'
# archivo: app.py (registro)
from admin.routes import admin_bp
app.register_blueprint(admin_bp)@app.errorhandler(404)
def page_not_found(error):
return render_template('404.html'), 404Comprender estos conceptos fundamentales te ayudará a dominar Flask de forma más organizada y eficiente:
Enrutamiento (Routing):
Asociar URL's específicas a funciones Python que manejan esas peticiones. Incluye el uso de diferentes métodos HTTP (`GET`, `POST`, etc.), parámetros dinámicos en la URL (con convertidores opcionales como `int`, `string`, `path`) y la creación de rutas variables.
Motor de Plantillas Jinja2:
Utilizar el potente motor de plantillas Jinja2 para generar dinámicamente el contenido HTML que se envía al navegador. Incluye la sintaxis para mostrar variables (`{{}}`), lógica de control (`{% %}`), herencia de plantillas para reutilizar estructuras (`{% extends %}`, `{% block %}`) y la inclusión de fragmentos (`{% include %}`).
Manejo de Peticiones (Request Object):
Acceder a toda la información enviada por el cliente en la petición HTTP a través del objeto global `request`. Esto incluye datos del formulario (`request.form`), parámetros de la query string (`request.args`), cuerpo JSON (`request.json`), encabezados (`request.headers`) y más.
Contextos de Flask (Request y Application):
Comprender los dos contextos principales: el Request Context (creado al recibir una petición HTTP, contiene `request`, `session`, `g`) y el Application Context (asociado a la instancia de la aplicación, contiene `current_app`, `g`). El objeto `g` es un espacio para almacenar datos durante la vida de una sola petición.
Blueprints:
Una herramienta para modularizar aplicaciones Flask en componentes más pequeños y reutilizables. Cada Blueprint puede tener sus propias rutas, manejadores de errores, plantillas y activos estáticos, y luego se registran en la instancia principal de la aplicación. Esencial para la organización en proyectos medianos a grandes.
Manejo de Errores:
Configurar manejadores de errores personalizados para capturar y responder a diferentes códigos de estado HTTP (ej: 404 Not Found, 500 Internal Server Error) o tipos de excepciones específicas, proporcionando una respuesta amigable al usuario en lugar de la página de error por defecto.
Integración con Bases de Datos (Flask-SQLAlchemy):
Introducción a cómo usar la popular extensión Flask-SQLAlchemy para integrar Flask con bases de datos relacionales (como SQLite, PostgreSQL, MySQL). Permite definir modelos de base de datos como clases Python, realizar consultas y gestionar transacciones utilizando un ORM (Object-Relational Mapper).
Extensiones de Flask:
Flask es un microframework porque no incluye muchas funcionalidades por defecto (base de datos, autenticación, formularios, etc.). Estas funcionalidades se añaden a través de extensiones (paquetes PyPI con el prefijo `Flask-`). Entender cómo encontrarlas, instalarlas y configurarlas es clave para extender Flask.
Middleware (Concepto):
Aunque Flask no tiene un sistema de middleware explícito como otros frameworks, el concepto se aplica a funciones o extensiones que pueden procesar la petición antes de que llegue a la ruta, o la respuesta antes de que se envíe al cliente (ej: autenticación, logging).
Algunos ejemplos de aplicaciones prácticas donde se utiliza Flask:
Construcción de aplicaciones web multi-página con autenticación básica:
Desarrollar sitios web con varias URL's que renderizan diferentes plantillas usando Jinja2, manejan formularios de login/registro y gestionan sesiones de usuario (usando extensiones como Flask-Login).
Creación de APIs RESTful con manejo de diferentes métodos HTTP y datos (JSON, formularios):
Implementar endpoints para operaciones CRUD utilizando los decoradores de métodos HTTP, acceder a datos enviados en formatos JSON o de formulario (`request.json`, `request.form`) y retornar respuestas JSON (`jsonify`).
Estructuración de aplicaciones Flask de tamaño medio utilizando Blueprints:
Organizar el código de una aplicación web o API en módulos lógicos (ej: usuarios, productos, autenticación) utilizando Blueprints para mejorar la modularidad, facilitar la reusabilidad y simplificar el mantenimiento.
Integración con bases de datos relacionales usando Flask-SQLAlchemy:
Conectar la aplicación a una base de datos, definir los modelos de datos como clases Python, y realizar operaciones de consulta, creación, actualización y eliminación utilizando el ORM.
Implementación de formularios web complejos con validación del lado del servidor:
Crear formularios HTML y procesar sus datos en el backend, incluyendo validación de campos y manejo de errores (a menudo con ayuda de extensiones como Flask-WTF).
Servir archivos estáticos y gestionar activos:
Configurar Flask para servir archivos CSS, JavaScript e imágenes desde una carpeta `static` y gestionar el caché de activos.
Aquí tienes algunas recomendaciones para facilitar tus inicios en Flask:
Organiza tu Aplicación con Blueprints:
No mantengas toda tu aplicación en un solo archivo. Utiliza Blueprints para dividirla en módulos lógicos (ej: `auth`, `users`, `products`). Esto mejora la organización, el mantenimiento y la reusabilidad.
Domina el Motor de Plantillas Jinja2:
Aprende a usar la sintaxis de Jinja2 para renderizar HTML dinámico, la herencia de plantillas (`{% extends %}`, `{% block %}`) para reutilizar estructuras y la inclusión de parciales (`{% include %}`) para componentes reutilizables.
Entiende los Contextos (Request y Application):
Es crucial comprender cuándo y dónde están disponibles objetos como `request`, `session`, `current_app` y `g`. Esto te ayudará a usar las extensiones correctamente y a depurar problemas relacionados con el estado de la petición/aplicación.
Usa un ORM (como Flask-SQLAlchemy) para Bases de Datos:
Evita escribir SQL crudo. Utiliza un ORM para interactuar con tu base de datos a través de objetos Python, lo que simplifica la mayoría de las operaciones de datos y hace tu código más portátil entre diferentes bases de datos.
Implementa Manejadores de Errores Personalizados:
No dejes que Flask muestre sus páginas de error por defecto. Configura manejadores para errores comunes (404, 500) usando `@app.errorhandler()` o `@blueprint.errorhandler()` para proporcionar una experiencia más amigable al usuario.
Utiliza Entornos Virtuales (¡Siempre!):
Es una práctica fundamental en Python, pero especialmente importante en desarrollo web para aislar las dependencias de tu aplicación Flask y sus extensiones, evitando conflictos con otros proyectos o el sistema.
Lee la Documentación de las Extensiones que Usas:
Flask es extensible. La fuerza de Flask radica en su ecosistema de extensiones. La documentación de cada extensión (Flask-SQLAlchemy, Flask-Login, Flask-WTF, etc.) es la fuente principal de información para configurarlas e integrarlas correctamente.
Comprende el Objeto `request` a fondo:
Saber cómo acceder a los datos de la petición (`request.args`, `request.form`, `request.json`, `request.headers`) y sus propiedades es esencial para construir APIs y manejar datos enviados por el usuario.
Si te interesa Flask, también podrías explorar estas herramientas:
Amplía tus conocimientos con estos enlaces y materiales: