Introducción a Flask, un microframework de Python

En este artículo, presentaremos Flask, un popular microframework para Python que ofrece una alternativa al gigante que es Django.

Flask está diseñado para ser ligero y flexible, permitiendo a los desarrolladores crear aplicaciones web rápida y fácilmente. En este artículo, cubriremos qué es Flask, sus características clave, los beneficios de su API simple, su flexibilidad en el soporte de extensiones de terceros, las extensiones más comunes de Flask, y cuándo es y no es una buena ocasión para usar Flask.

Conclusiones clave

¿Qué es Flask?

Flask es un microframework web escrito en Python que se utiliza para desarrollar aplicaciones web. Está construido sobre una filosofía simple de mantener las cosas simples y ligeras, proporcionando a los desarrolladores solo las herramientas más importantes necesarias para construir aplicaciones web sin complejidad innecesaria.

Está construido sobre la herramienta WSGI Werkzeug, que proporciona la funcionalidad del servidor web necesaria para manejar solicitudes y respuestas, y el motor de plantillas Jinja2, que le da a Flask la capacidad de manejar plantillas HTML, permitiendo a los desarrolladores crear aplicaciones web dinámicas.

Aquí hay algunas de las características clave de Flask que lo hacen un gran framework para trabajar:

• Tiene una API simple para crear rutas web y manejar solicitudes.
• El motor de plantillas Jinja ofrece soporte para plantillas HTML, lo que permite a los desarrolladores crear páginas web fácilmente.
• Es altamente extensible, debido a su soporte para extensiones de terceros, por lo que un desarrollador puede instalar extensiones según las necesidades de su proyecto.
• Viene con un servidor de desarrollo que facilita la prueba y depuración de aplicaciones.

En general, Flask proporciona un marco potente, flexible y, sin embargo, simple para construir aplicaciones web. Es una buena opción tanto para desarrolladores web nuevos como experimentados, y es uno de los frameworks web más populares en el ecosistema de desarrollo web de Python.

Ventajas de Flask

Ahora veamos con más detalle algunas de las ventajas de usar Flask en el desarrollo.

Simplicidad. La filosofía de diseño de Flask enfatiza la simplicidad, lo que facilita a los desarrolladores de cualquier nivel entender y utilizarlo. Esto también significa que los desarrolladores tienen una curva de aprendizaje muy mínima, ya que solo necesitan aprender algunos conceptos y APIs para comenzar a construir aplicaciones web.

Flexibilidad. La naturaleza micro de Flask, que proporciona solo las características centrales de un framework web, da a los desarrolladores el poder de personalizar y extenderlo para satisfacer sus requisitos utilizando extensiones de Flask o bibliotecas de terceros.

Documentación. La documentación de Flask es muy completa, con una buena cobertura de temas básicos a avanzados, lo que facilita mucho a los desarrolladores aprender a usar el framework.

Compatibilidad. Flask es compatible con una amplia gama de versiones de Python, lo que lo hace fácil de usar con bases de código Python existentes. También cuenta con soporte para múltiples servidores web, lo que facilita su implementación en una variedad de plataformas de alojamiento.

Desarrollo rápido. La simplicidad y flexibilidad de Flask reducen el código repetitivo necesario para configurar una aplicación, permitiendo a los desarrolladores comenzar rápidamente.

En la web, Flask se utiliza de muchas maneras interesantes. Algunos ejemplos notables son:

• PgAdmin. La interfaz de administración de Postgres funciona en una instancia de Flask, proporcionando a los desarrolladores una interfaz donde pueden gestionar sus bases de datos de Postgres.
• Twilio. Esta es una plataforma de comunicación que utiliza Flask en varias de sus APIs.
• Pinterest. Esta aplicación de compartición de fotos utiliza Flask en la pila de desarrollo web, permitiendo a su equipo crear fácilmente algunas características y integraciones personalizadas.

Cuándo usar Flask

La simplicidad y facilidad de uso de Flask lo convierten en una excelente opción para una amplia gama de proyectos web:

• Prototipado. Su facilidad de uso y flexibilidad lo hacen una excelente opción para crear prototipos rápidamente, permitiendo a los desarrolladores construir y probar nuevas características con rapidez.
• Creación de APIs RESTful. Su propia API simple facilita la creación y manejo de solicitudes HTTP.
• Aplicaciones de comercio electrónico. Funciona bien para construir mercados en línea y plataformas de comercio electrónico.
• Finanzas. Es útil para construir aplicaciones financieras, con gestión de cuentas, procesamiento de transacciones y seguimiento de inversiones.
• IA. Ofrece una manera útil y sencilla de construir y desplegar modelos de entrenamiento de IA.

Cuándo no usar Flask

Si bien Flask es un excelente framework y tiene numerosas ventajas y grandes características, hay situaciones en las que estas características funcionan en su contra. Exploremos algunos de los proyectos que mejor se adaptan a otros tipos de frameworks.

Proyectos que requieren funcionalidad incorporada. Al ser un microframework, Flask solo proporciona los bits centrales necesarios para crear una aplicación web. Si un proyecto requiere, por ejemplo, una interfaz de administración, autenticación o un ORM, entonces Django es una opción mejor.

Proyectos con requisitos de seguridad estrictos. Como Flask es un framework flexible, debemos confiar en extensiones de terceros para implementar algún nivel de seguridad en nuestras aplicaciones. Si bien esto ciertamente funciona, es mejor confiar en un framework más probado en combate que adopta un enfoque más seguro, como Tornado o Twisted.

Proyectos que imponen algún estándar de codificación. Debido a la flexibilidad de Flask, desarrollar aplicaciones en él deja a los desarrolladores hacer aplicaciones de la manera que consideren conveniente. Sin embargo, frameworks como Django aseguran que los desarrolladores sigan una convención particular, lo que significa que los desarrolladores pueden pasar de un proyecto a otro fácilmente.

Configuración de un Entorno de Desarrollo Flask

Veamos ahora cómo comenzar con Flask, desde la configuración del entorno de desarrollo, la instalación, hasta el arranque de una aplicación mínima.

Requisitos Previos

Python debe estar instalado en la máquina de desarrollo. Aquí están instrucciones para ello (aunque podríamos tenerlo ya instalado).

Crear un Entorno Virtual

A virtual environment is an isolated Python environment where we can install packages for a given project without affecting the global Python installation. (Here’s further discussion about why virtual environments are useful.) There are different packages for creating virtual environments in Python, such as virtualenv, venv, or Conda.

En este artículo, utilizaremos virtualenv. Lo podemos instalar con el siguiente comando:

pip install virtualenv

Una vez que virtualenv ha sido instalado, podemos crear un directorio donde residirá nuestra aplicación Flask. Podemos llamar al directorio como queramos, aparte de Flask, ya que eso causaría conflictos. Llamaremos a la nuestra flask_intro:

mkdir flask_intro

A continuación, cambia a ese directorio para que podamos comenzar a usarlo:

cd flask_intro

En ese directorio, ahora creemos nuestro entorno virtual, usando el siguiente comando:

virtualenv myenv

El comando anterior crea un entorno virtual y lo llama myenv. Activémoslo para que podamos instalar Flask en él. Para activar el entorno virtual en Linux o macOS, use el siguiente comando:

. myenv/bin/activate

En Windows, use este comando:

. myenv\Scripts\activate

Una vez que nuestro entorno virtual haya sido activado, mostrará el nombre del entorno virtual en el prompt de la shell, similar al resultado a continuación:

(myenv)/~(path to your project directory)$

Dentro de nuestro entorno virtual activado, podemos proceder a instalar Flask, utilizando el siguiente comando:

pip install Flask

Una vez que Flask termine de instalarse, vamos a crear una aplicación mínima. Crearemos un módulo que contenga nuestra aplicación Flask. Por simplicidad, llamémoslo hello.py. En Linux o macOS podemos usar el siguiente comando para crear el archivo en nuestro directorio flask_intro:

touch hello.py

El comando anterior crea un archivo llamado hello.py. También podríamos usar un entorno de desarrollo para crear el archivo. Una vez creado el archivo, póngale el siguiente código y guárdelo:

# hello.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello, World!'

En el código anterior, importamos la clase Flask desde el módulo flask, luego creamos una instancia de Flask que llamamos app y pasamos la variable __name__.

Luego tenemos el decorador de ruta @app.route(“\”), lo que significa que la función hello_world() se activará cuando alguien visite la ruta raíz de nuestra aplicación una vez que se ejecute.

Hay varias formas en que podríamos ejecutar la aplicación, así que veamos algunas de ellas. La primera forma es proporcionarle al comando flask una serie de argumentos: --app, luego el nombre del módulo que contiene nuestra aplicación Flask, y luego run. Vea a continuación:

flask –app <the name of your module> run

Usando el ejemplo anterior para ejecutar nuestra aplicación de muestra:

flask –app hello run

Eso ejecutará nuestra aplicación en el puerto predeterminado 5000 por lo que la aplicación estará disponible en http://localhost:5000/ o en http://127.0.0.1:5000/. Si queremos que la aplicación esté disponible en un puerto diferente, podemos especificar el puerto utilizando la opción -p o --port. Por ejemplo:

flask --app hello run --port=8080

Eso ejecutará el servidor en el puerto 8080. La otra forma en que podemos ejecutar la aplicación es simplemente utilizando los comandos flask run. Sin embargo, para poder hacer eso, necesitamos indicarle a Flask el nombre del módulo que contendrá la instancia de Flask, y lo hacemos configurando la variable de entorno FLASK_APP. En nuestro caso, la aplicación de Flask está contenida en un archivo llamado hello.py. Entonces podemos configurarlo de esta manera:

export FLASK_APP=hello

Ahora que hemos configurado la variable de entorno FLASK_APP, podemos ejecutar el servidor de desarrollo de la siguiente manera:

flask run

Con ese código, ahora tenemos una aplicación web en funcionamiento. Esto demuestra la filosofía central de Flask: no necesitamos mucho código de inicio para poner las cosas en marcha. Sin embargo, la aplicación que hemos configurado arriba no es muy funcional o útil, ya que solo renderiza la cadena “¡Hola Mundo!” en nuestra página web. Para hacer algo más útil, podemos recurrir a las plantillas. Veremos cómo manejarlas a continuación.

Plantillas de Flask

Plantillas de Flask son una forma de crear páginas web dinámicas que pueden mostrar diferentes contenidos según varios factores, como datos de una base de datos o entrada del usuario. Las plantillas en Flask son una combinación de HTML y marcadores especiales llamados variables de plantilla que se reemplazan por valores reales en tiempo de ejecución.

Las plantillas se almacenan en el directorio templates. Por lo tanto, para utilizar plantillas, necesitamos importar el método render_template() desde flask. El método render_template() toma un nombre de plantilla y cualquier dato opcional que necesite pasarse a la plantilla.

Veamos un ejemplo de una función que utiliza una plantilla para renderizar una página web:

# index.py
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
    title = 'Welcome to my website!'
    message = 'This is an example of using Flask templates.'
    return render_template('index.html', title=title, message=message)

En el ejemplo anterior, tenemos una función vista — index() — que está vinculada a la URL raíz (“/”) por el decorador @app.route(). La función tiene dos variables, title y message. Finalmente, pasamos la plantilla index.html al método render_template(), junto con las variables title y message.

Para que el código anterior funcione, necesitamos tener una plantilla index.html que reside en un directorio de plantillas. Entonces, la plantilla se verá algo así:

# index.html
<!doctype html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
</body>
</html>

En el archivo index.html, los marcadores de posición {{title}} y {{ message }} se reemplazan con los valores pasados a la plantilla en el método render_template().

Las plantillas también pueden incluir lógica más compleja como sentencias if y bucles for, lo que permite generar páginas más dinámicas.

Por lo tanto, las plantillas en Flask proporcionan a los desarrolladores una opción muy potente para crear páginas web dinámicas ricas en información generada por el usuario.

Enrutamiento en Flask

La mayoría de las aplicaciones web tendrán más de una URL, por lo que necesitamos una forma de saber qué función maneja qué URL. En Flask, esta asignación se conoce como enrutamiento — el proceso de enlazar o mapear URLs a funciones de vista. Enlazar URLs a funciones de vista permite que la aplicación maneje diferentes tipos de solicitudes, como GET, POST, PUT, DELETE, y más. También permite que la aplicación maneje múltiples solicitudes de diferentes clientes.

Para configurar rutas en Flask, utilizamos el decorador() decorador. El decorador enlaza una URL a una función de vista, de modo que cuando un usuario visita una URL que existe en nuestra aplicación, Flask activa la función de vista asociada para manejar la solicitud.

Veamos un ejemplo:

# hello.py
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/about")
def about():
    return "This is the about page"

En el ejemplo anterior, definimos una URL sobre (/about). Cuando la aplicación recibe una solicitud para la URL about, Flask llama a la función about(), que devuelve la cadena “Esta es la página de información”.

Hasta ahora, aunque estos ejemplos devuelven diferentes páginas, todos simplemente utilizan la solicitud HTTP GET. Para poder manejar cualquier solicitud específica, podemos especificar el método HTTP como un argumento opcional para el decorador route().

Veamos un ejemplo de una solicitud PUT:

from flask import Flask, request

app = Flask(__name__)

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # obtener los datos del usuario del cuerpo de la solicitud
    data = request.get_json()
    # hacer algo con los datos del usuario, como actualizar al usuario en la base de datos
    # ...
    # devolver una respuesta indicando éxito o fracaso
    return {'message': f'User {user_id} updated successfully'}, 200

En este ejemplo, definimos una ruta que maneja una solicitud PUT para actualizar los detalles de un usuario dado su user_id. Utilizamos <int:user_id> en la ruta para indicar que el ID del usuario debe ser un entero.

En la función update_user(), obtenemos los datos del usuario del cuerpo de la solicitud utilizando el método request.get_json(). Hacemos algo con los datos del usuario, como actualizar al usuario en la base de datos, y luego devolvemos una respuesta indicando éxito o fracaso junto con un código de estado HTTP (un 200 en este caso para mostrar éxito).

En general, el enrutamiento permite que Flask pueda manejar diferentes tipos de solicitudes y permita que nuestra aplicación maneje y actúe sobre los datos de manera diferente, dependiendo de la URL que visite un usuario.

Formularios y Validación en Flask

Además de mostrar datos para los usuarios, las plantillas de Flask también pueden tomar entrada de los usuarios para un procesamiento o almacenamiento adicional. Para eso, Flask proporciona soporte integrado para procesar formularios HTML y manejar la entrada del usuario. Los formularios de Flask se basan en la biblioteca WTForms, que proporciona una manera flexible y poderosa de manejar los datos del formulario y realizar validaciones. Sin embargo, la biblioteca no es parte de la instalación estándar de Flask, por lo que necesitamos instalarlo usando el siguiente comando:

pip install WTForms

Una vez que hemos instalado WTForms, para utilizar formularios en Flask necesitamos definir una clase de formulario que heredará de flask_wtf.FlaskForm. La clase contendrá los campos que estarán en el formulario y cualquier regla de validación que deba aplicarse a ellos.

Veamos un ejemplo de un formulario de inicio de sesión:

# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, Length

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired(), Length(min=6)])
    submit = SubmitField('Log In')

En el ejemplo anterior, definimos un formulario de inicio de sesión con dos campos: email y password, y un botón de envío. También tenemos un argumento validators que se utiliza para especificar reglas de validación para cada campo. Por ejemplo, en este caso requerimos que el campo email contenga una dirección de correo electrónico válida y que el campo password contenga una contraseña de no menos de seis caracteres.

Una vez que hemos definido la clase del formulario, podemos usarla en la función de vista de inicio de sesión para renderizar el formulario y procesar los datos del formulario enviados por el usuario. Veamos un ejemplo de la función de vista:

# views.py
from flask import render_template, request
from .forms import LoginForm

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        email = form.email.data
        password = form.password.data
        # hacer algo con los datos del formulario
    return render_template('login.html', form=form)

En el ejemplo anterior, tenemos una vista login que acepta dos métodos HTTP (GET y POST), por lo que cuando los usuarios acceden a la URL desde un navegador, el LoginForm se renderiza como un formulario HTML utilizando el método render_template, y cuando un usuario envía el formulario, verificamos si el formulario es válido utilizando el método validate_on_submit. Si el formulario es válido, accedemos al correo electrónico y la contraseña.

El formulario login.html podría tener un aspecto similar a esto:

# login.html
<h1>Login</h1>
<form method="POST">
  {{ form.csrf_token }}
  <div>
    {{ form.email.label }} {{ form.email() }}
    {% for error in form.email.errors %}
    <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  <div>
    {{ form.password.label }} {{ form.password() }}
    {% for error in form.password.errors %}
      <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  {{ form.submit() }}
</form>

El template anterior renderizará los campos email y password, junto con sus etiquetas, y un botón de envío con el texto “Login”. El campo form.csrf_token se incluye para prevenir ataques de falsificación de solicitud entre sitios (CSRF). Los bucles {% for %} se utilizan para mostrar cualquier error de validación que pueda ocurrir.

Al utilizar formularios de Flask, tenemos una poderosa manera de manejar la entrada del usuario, y podremos validar los datos que ingresen.

Extensiones de Flask

Como hemos visto, Flask es un microframework que solo incluye las partes más importantes necesarias para crear una aplicación web. Sin embargo, si necesitamos agregar funcionalidad que no se ofrece de forma predeterminada en Flask, necesitamos agregar paquetes a la instalación. Las extensiones de Flask son la manera en que proporcionamos esta funcionalidad adicional. Podemos simplemente instalar el paquete que necesitamos. Hay muchas extensiones hechas por la comunidad de Flask.

Aquí hay algunas de las más populares:

• Flask-SQLAlchemy: proporciona integración con el toolkit SQLAlchemy que facilita la interacción con bases de datos.
• Flask-Login: proporciona autenticación de usuarios y administración de sesiones para Flask.
• Flask-Mail: proporciona una interfaz simple para enviar correos electrónicos desde Flask.

Hay cientos de extensiones hechas por la comunidad de Flask para manejar diferentes funcionalidades. Usar las extensiones es generalmente sencillo. Primero, necesitamos instalar la extensión que queremos usando pip.

Veamos un ejemplo de uso de Flask-SQLAlchemy. Primero, necesitamos instalarlo:

pip install flask-sqlalchemy

A continuación, necesitamos configurarlo. Por ejemplo:

# sqlalchemy_example.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return '<User %r>' % self.username

En el ejemplo anterior, tenemos un modelo User con un campo username y email. También configuramos SQLALCHEMY_DATABASE_URI, indicando que estamos utilizando una base de datos SQLite ubicada en example.db. Con eso establecido, ahora tenemos acceso al objeto db que nos permite interactuar con la base de datos. Por ejemplo, podríamos crear un nuevo usuario y agregarlo a la base de datos, de la siguiente manera:

#views.py 
from app import db, User

user = User(username='john', email='[email protected]')
db.session.add(user)
db.session.commit()

Con las extensiones de Flask, nuestra aplicación puede tener más funcionalidades de las que normalmente tendría con la implementación principal de Flask.

Conclusión

En este artículo, presentamos Flask, un marco de trabajo web ligero y flexible para Python. Discutimos las ventajas de usar Flask para el desarrollo web, incluyendo su simplicidad, flexibilidad y facilidad de uso. También cubrimos cómo configurar un entorno de desarrollo, crear rutas, usar plantillas, manejar formularios y usar extensiones como Flask-SQLAlchemy.

Para resumir, Flask es una excelente opción para construir aplicaciones web de cualquier tamaño, desde pequeños proyectos personales hasta aplicaciones comerciales a gran escala. Es fácil de aprender y usar, pero también ofrece características avanzadas a través de sus muchas extensiones.

Si estás interesado en aprender más sobre Flask, aquí hay algunos recursos adicionales:

• Documentación de Flask
• Flask Mega-Tutorial, por Miguel Grinberg
• Desarrollo Web con Flask, por Miguel Grinberg
• A simple Flask app tutorial
• Tutoriales de Flask en Real Python

Si deseas aprender más sobre Django y Flask y sus mejores casos de uso, revisa Desarrollo Web en Python con Django y Flask.

FAQs sobre Flask, el Framework de Python