Certificado de Flask MVC
Domina el patrón MVC en Flask y Jinja2 para crear aplicaciones web completas con Python y HTML de forma eficiente y estructurada.
Empezar cursoFlask es un microframework web de Python que destaca por su simplicidad y flexibilidad, permitiendo a los desarrolladores crear aplicaciones web robustas siguiendo el patrón arquitectónico Model-View-Controller (MVC).
Esta aproximación estructural facilita la organización del código, mejora la mantenibilidad y promueve las mejores prácticas en el desarrollo web moderno.
Fundamentos del desarrollo web con Flask
El framework Flask se basa en la filosofía de proporcionar las herramientas esenciales para el desarrollo web sin imponer restricciones rígidas. Esta flexibilidad permite implementar el patrón MVC de manera natural, donde cada componente tiene responsabilidades claramente definidas.
La arquitectura MVC separa la lógica de negocio (Model), la presentación (View) y el control de flujo (Controller). En Flask, los controladores se implementan mediante funciones de vista que manejan las rutas HTTP, los modelos representan la estructura de datos, y las vistas se gestionan a través del motor de plantillas Jinja2.
from flask import Flask, render_template, request
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/usuarios/<int:id>')
def mostrar_usuario(id):
# Lógica del controlador
usuario = obtener_usuario(id)
return render_template('usuario.html', usuario=usuario)
Gestión de rutas y controladores
Los controladores en Flask se definen mediante decoradores que asocian URLs específicas con funciones Python. Esta aproximación permite manejar diferentes métodos HTTP (GET, POST, PUT, DELETE) de manera elegante y organizada.
Las rutas dinámicas permiten capturar parámetros de la URL y procesarlos dentro del controlador. Flask proporciona convertidores de tipos que validan automáticamente los parámetros, mejorando la robustez de la aplicación.
@app.route('/productos/<string:categoria>')
def productos_por_categoria(categoria):
productos = buscar_productos(categoria)
return render_template('productos.html', productos=productos)
@app.route('/api/datos', methods=['GET', 'POST'])
def manejar_datos():
if request.method == 'POST':
# Procesar datos del formulario
return procesar_formulario()
else:
# Mostrar formulario
return render_template('formulario.html')
Sistema de plantillas Jinja2
Jinja2 es el motor de plantillas integrado en Flask que permite generar contenido HTML dinámico de manera eficiente y segura. Su sintaxis intuitiva combina HTML estático con lógica de presentación, facilitando la creación de interfaces web complejas.
Las plantillas Jinja2 soportan herencia, inclusión de archivos, filtros personalizados y estructuras de control. Esta funcionalidad permite crear sistemas de plantillas modulares y reutilizables que se adaptan a las necesidades específicas de cada proyecto.
<!-- plantilla_base.html -->
<!DOCTYPE html>
<html>
<head>
<title>{% block titulo %}Mi Aplicación{% endblock %}</title>
</head>
<body>
{% block contenido %}{% endblock %}
</body>
</html>
<!-- pagina_usuario.html -->
{% extends "plantilla_base.html" %}
{% block titulo %}Usuario: {{ usuario.nombre }}{% endblock %}
{% block contenido %}
<h1>Perfil de {{ usuario.nombre }}</h1>
{% if usuario.activo %}
<p>Estado: Activo</p>
{% else %}
<p>Estado: Inactivo</p>
{% endif %}
{% endblock %}
Manejo de formularios y validación
El procesamiento de formularios en Flask requiere una gestión cuidadosa de los datos enviados por el cliente. WTForms es una biblioteca especializada que proporciona validación robusta, protección CSRF y generación automática de formularios HTML.
La validación de datos es fundamental para mantener la integridad y seguridad de la aplicación. WTForms ofrece validadores predefinidos y la posibilidad de crear validadores personalizados que se adapten a requisitos específicos del negocio.
from flask_wtf import FlaskForm
from wtforms import StringField, EmailField, PasswordField
from wtforms.validators import DataRequired, Email, Length
class FormularioRegistro(FlaskForm):
nombre = StringField('Nombre', validators=[
DataRequired(message='El nombre es obligatorio'),
Length(min=2, max=50)
])
email = EmailField('Email', validators=[
DataRequired(),
Email(message='Email inválido')
])
password = PasswordField('Contraseña', validators=[
DataRequired(),
Length(min=8, message='Mínimo 8 caracteres')
])
Recursos estáticos y arquitectura modular
Los archivos estáticos (CSS, JavaScript, imágenes) son componentes esenciales de cualquier aplicación web moderna. Flask proporciona un sistema integrado para servir estos recursos de manera eficiente, con soporte para versionado y optimización.
Los Blueprints permiten organizar aplicaciones Flask complejas en módulos independientes y reutilizables. Esta funcionalidad facilita el desarrollo colaborativo y mejora la estructura del código en proyectos de gran escala.
# blueprints/usuarios.py
from flask import Blueprint, render_template
usuarios_bp = Blueprint('usuarios', __name__, url_prefix='/usuarios')
@usuarios_bp.route('/')
def listar_usuarios():
return render_template('usuarios/lista.html')
@usuarios_bp.route('/<int:id>')
def detalle_usuario(id):
return render_template('usuarios/detalle.html', id=id)
# app.py
from blueprints.usuarios import usuarios_bp
app.register_blueprint(usuarios_bp)
Gestión de archivos y comunicación con el usuario
La subida de archivos es una funcionalidad común en aplicaciones web que requiere consideraciones especiales de seguridad y rendimiento. Flask proporciona herramientas integradas para manejar archivos de manera segura, incluyendo validación de tipos y tamaños.
Los flash messages ofrecen un mecanismo elegante para comunicar información temporal al usuario, como confirmaciones de acciones, errores o advertencias. Este sistema se integra perfectamente con el ciclo de petición-respuesta de Flask.
from flask import flash, redirect, url_for
from werkzeug.utils import secure_filename
@app.route('/subir-archivo', methods=['POST'])
def subir_archivo():
if 'archivo' not in request.files:
flash('No se seleccionó ningún archivo', 'error')
return redirect(url_for('formulario_subida'))
archivo = request.files['archivo']
if archivo.filename == '':
flash('Nombre de archivo vacío', 'error')
return redirect(url_for('formulario_subida'))
if archivo and archivo_permitido(archivo.filename):
nombre_seguro = secure_filename(archivo.filename)
archivo.save(os.path.join(app.config['UPLOAD_FOLDER'], nombre_seguro))
flash('Archivo subido correctamente', 'success')
return redirect(url_for('formulario_subida'))
Configuración y variables de entorno
La gestión de configuración es crucial para desarrollar aplicaciones Flask que funcionen correctamente en diferentes entornos (desarrollo, pruebas, producción). Las variables de entorno proporcionan un método seguro y flexible para almacenar configuraciones sensibles.
import os
from flask import Flask
class Config:
SECRET_KEY = os.environ.get('SECRET_KEY') or 'clave-desarrollo'
DATABASE_URL = os.environ.get('DATABASE_URL') or 'sqlite:///app.db'
UPLOAD_FOLDER = os.environ.get('UPLOAD_FOLDER') or 'uploads'
MAX_CONTENT_LENGTH = 16 * 1024 * 1024 # 16MB máximo
app = Flask(__name__)
app.config.from_object(Config)
Seguridad y autenticación
La seguridad en aplicaciones web requiere múltiples capas de protección. El hashing de contraseñas con bcrypt proporciona una base sólida para el almacenamiento seguro de credenciales de usuario, utilizando algoritmos resistentes a ataques de fuerza bruta.
Flask-Login simplifica la implementación de sistemas de autenticación, proporcionando gestión de sesiones, protección de rutas y funcionalidades de "recordar usuario". Esta extensión se integra perfectamente con el ecosistema Flask.
from flask_bcrypt import Bcrypt
from flask_login import LoginManager, UserMixin, login_required
bcrypt = Bcrypt(app)
login_manager = LoginManager(app)
class Usuario(UserMixin):
def __init__(self, id, email, password_hash):
self.id = id
self.email = email
self.password_hash = password_hash
def verificar_password(self, password):
return bcrypt.check_password_hash(self.password_hash, password)
@app.route('/perfil')
@login_required
def perfil():
return render_template('perfil.html')
Autorización y control de acceso
La autorización va más allá de la autenticación, determinando qué acciones puede realizar cada usuario autenticado. Los decoradores personalizados proporcionan una manera elegante de implementar control de acceso granular en las rutas de la aplicación.
from functools import wraps
from flask_login import current_user
def requiere_rol(rol_requerido):
def decorador(f):
@wraps(f)
def funcion_decorada(*args, **kwargs):
if not current_user.is_authenticated:
return redirect(url_for('login'))
if current_user.rol != rol_requerido:
flash('No tienes permisos para acceder a esta página', 'error')
return redirect(url_for('index'))
return f(*args, **kwargs)
return funcion_decorada
return decorador
@app.route('/admin')
@requiere_rol('administrador')
def panel_admin():
return render_template('admin.html')
Esta arquitectura MVC con Flask proporciona una base sólida para desarrollar aplicaciones web escalables y mantenibles, combinando la simplicidad de Python con las mejores prácticas del desarrollo web moderno.
Otros cursos de programación con certificado
Supera todos los retos de Flask MVC y obtén estos certificados de superación para mejorar tu currículum y tu empleabilidad.
Fundamentos de programación
Git Básico
Git Avanzado
HTML Básico
HTML Intermedio
HTML Avanzado
CSS Básico
CSS Intermedio
CSS Avanzado
JavaScript Sintaxis
JavaScript OOP Intermedio
JavaScript Asíncrono y Funcional
JavaScript DOM
TypeScript Sintaxis Básica
TypeScript OOP
TypeScript Avanzado
Python Sintaxis Básica
Python Estructuras de datos
Python OOP
Python Funcional
Tecnologías que aprenderás
Al finalizar este curso obtendrás
Certificado de superación en Flask MVC
Tras completar todas las lecciones y ejercicios del curso Flask MVC se te genera un enlace con tu certificado para que lo puedas descargar o compartir directamente en cualquier plataforma, siempre accesible.