Introduzione a Flask, un microframework per Python

In questo articolo, presenteremo Flask, un popolare microframework per Python che offre un’alternativa al gigante che è Django.

Flask è progettato per essere leggero e flessibile, permettendo agli sviluppatori di creare applicazioni web in modo rapido ed efficiente. In questo articolo, esamineremo cosa è Flask, le sue caratteristiche chiave, i vantaggi della sua semplice API, la sua flessibilità nel supportare estensioni di terze parti, le estensioni Flask più comuni e quando è e non è opportuno utilizzare Flask.

Punti Salienti

Che cos’è Flask?

Flask è un microframework web scritto in Python utilizzato per lo sviluppo di applicazioni web. È costruito su una filosofia semplice di mantenere le cose semplici e leggere, fornendo ai sviluppatori solo gli strumenti più importanti necessari per costruire app web senza complessità inutili.

È costruito sulla parte superiore dello strumento WSGI Werkzeug, che fornisce la funzionalità del server web necessaria per gestire richieste e risposte, e l’engine di template Jinja2, che dà a Flask la capacità di gestire i template HTML, permettendo agli sviluppatori di creare applicazioni web dinamiche.

Ecco alcune delle caratteristiche chiave di Flask che lo rendono un ottimo framework con cui lavorare:

• Ha un semplice API per creare route web e gestire le richieste.
• Il motore di template Jinja offre supporto per i template HTML, consentendo agli sviluppatori di creare facilmente pagine web.
• È altamente estensibile, grazie al suo supporto per le estensioni di terze parti, quindi uno sviluppatore può installare estensioni in base alle esigenze del proprio progetto.
• Viene fornito in bundle con un server di sviluppo che facilita il test e la risoluzione dei problemi delle app.

In generale, Flask fornisce un framework potente, flessibile e allo stesso tempo semplice per la costruzione di applicazioni web. È una buona scelta sia per i nuovi sviluppatori che per quelli esperti e rappresenta uno dei framework web più popolari nell’ecosistema dello sviluppo web in Python.

Vantaggi di Flask

Ora esaminiamo più dettagliatamente alcuni dei vantaggi dell’uso di Flask nello sviluppo.

Semplicità. La filosofia di progettazione di Flask enfatizza la semplicità, il che rende semplice per gli sviluppatori di qualsiasi livello capire e utilizzare. Ciò significa anche che gli sviluppatori hanno una curva di apprendimento molto ridotta, poiché hanno solo bisogno di apprendere alcuni concetti e API per iniziare a costruire applicazioni web.

Flessibilità. La natura micro di Flask — che fornisce solo le caratteristiche principali di un framework web — consente agli sviluppatori di personalizzarlo ed estenderlo per soddisfare i loro requisiti utilizzando estensioni Flask o librerie di terze parti.

Documentazione. La documentazione di Flask è molto completa, con una buona copertura di argomenti da base ad avanzati, rendendo molto facile per gli sviluppatori imparare a utilizzare il framework.

Compatibilità. Flask è compatibile con una vasta gamma di versioni di Python, il che lo rende facile da utilizzare con i codebase Python esistenti. Supporta anche più server web, il che lo rende facile da implementare su una varietà di piattaforme di hosting.

Sviluppo rapido. La semplicità e la flessibilità di Flask riducono il codice di base necessario per impostare un’applicazione, permettendo agli sviluppatori di iniziare rapidamente.

In giro per il Web, Flask viene utilizzato in molti modi interessanti. Alcuni esempi notevoli sono:

• PgAdmin. L’interfaccia amministrativa di Postgres funziona su un’istanza di Flask, fornendo agli sviluppatori un’interfaccia dove possono gestire i loro database Postgres.
• Twilio. Si tratta di una piattaforma di comunicazione che utilizza Flask in diverse delle sue API.
• Pinterest. Questa app di condivisione di foto utilizza Flask nello stack di sviluppo web, permettendo al suo team di creare facilmente alcune funzionalità e integrazioni personalizzate.

Quando utilizzare Flask

La semplicità e la facilità d’uso di Flask lo rendono un’ottima scelta per una vasta gamma di progetti web:

• Prototipazione. La sua facilità d’uso e flessibilità lo rendono un’ottima scelta per creare rapidamente prototipi, permettendo agli sviluppatori di costruire e testare nuove funzionalità velocemente.
• Creazione di API RESTful. La sua semplice API lo rende facile da utilizzare per creare e gestire le richieste HTTP.
• App ecommerce. Funziona bene per la costruzione di mercati online e piattaforme ecommerce.
• Finanza. È utile per la creazione di applicazioni finanziarie, con gestione degli account, elaborazione delle transazioni e monitoraggio degli investimenti.
• AI. Offre un modo utile e semplice per costruire e distribuire modelli di addestramento AI.

Quando non usare Flask

Mentre Flask è un ottimo framework e ha un numero di vantaggi e caratteristiche notevoli, ci sono situazioni in cui queste caratteristiche lavorano contro di esso. Esploriamo alcuni dei progetti che si adattano meglio ad altri tipi di framework.

Progetti che richiedono funzionalità integrate. Essendo un microframework, Flask fornisce solo i componenti essenziali necessari per creare un’applicazione web. Se un progetto richiede, ad esempio, un’interfaccia amministrativa, autenticazione o un ORM, allora Django è un’opzione migliore.

Progetti con requisiti di sicurezza rigorosi. Poiché Flask è un framework flessibile, dobbiamo fare affidamento su estensioni di terze parti per implementare un certo livello di sicurezza nelle nostre app. Anche se questo certamente funziona, è meglio fare affidamento su un framework più collaudato in battaglia che adotta un approccio più sicuro, come Tornado o Twisted.

Progetti che impongono uno standard di codifica. A causa della flessibilità di Flask, lo sviluppo di applicazioni su di esso lascia agli sviluppatori la libertà di creare app in qualsiasi modo preferiscano. Tuttavia, framework come Django garantiscono che gli sviluppatori seguano una particolare convenzione, il che significa che gli sviluppatori possono passare facilmente da un progetto all’altro.

Configurazione di un ambiente di sviluppo Flask

Ora esaminiamo come iniziare con Flask, dall’impostazione dell’ambiente di sviluppo, all’installazione, fino alla creazione di un’applicazione minima.

Prerequisiti

Python deve essere installato sulla macchina di sviluppo. Ecco le istruzioni per farlo (anche se potremmo già averlo installato).

Creare un Ambiente Virtuale

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.

In questo articolo, utilizzeremo virtualenv. Possiamo installarlo con il seguente comando:

pip install virtualenv

Una volta installato virtualenv, possiamo creare una directory in cui risiederà la nostra applicazione Flask. Possiamo chiamare la directory come preferiamo, a parte Flask, poiché causerebbe conflitti. Chiameremo la nostra flask_intro:

mkdir flask_intro

Successivamente, cambiamo in quella directory in modo da poter iniziare a utilizzarla:

cd flask_intro

In quella directory, ora creiamo il nostro ambiente virtuale, utilizzando il seguente comando:

virtualenv myenv

Il comando sopra crea un ambiente virtuale e lo chiama myenv. Attiviamolo in modo da poter installare Flask in esso. Per attivare l’ambiente virtuale su Linux o macOS, utilizza il seguente comando:

. myenv/bin/activate

Su Windows, utilizza questo comando:

. myenv\Scripts\activate

Una volta attivato il nostro ambiente virtuale, mostrerà il nome dell’ambiente virtuale nella promemoria della shell, simile all’output qui sotto:

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

Nel nostro ambiente virtuale attivato, possiamo procedere all’installazione di Flask utilizzando il seguente comando:

pip install Flask

Una volta completata l’installazione di Flask, procediamo a creare un’applicazione minima. Creeremo un modulo che ospiterà la nostra applicazione Flask. Per semplicità, chiamiamolo hello.py. Su Linux o macOS possiamo utilizzare il seguente comando per creare il file nella nostra directory flask_intro:

touch hello.py

Il comando sopra crea un file chiamato hello.py. Potremmo anche utilizzare un ambiente di sviluppo per creare il file. Una volta creato il file, inserisci il codice seguente e salvalo:

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

Nel codice sopra, importiamo la classe Flask dal modulo flask, quindi creiamo un’istanza di Flask che chiamiamo app e passiamo la variabile __name__.

Quindi abbiamo il decoratore di route @app.route(“\”), il che significa che la funzione hello_world() verrà attivata quando qualcuno visita la route root della nostra applicazione una volta eseguita.

Ci sono vari modi in cui potremmo eseguire l’applicazione, quindi diamo un’occhiata ad alcuni di essi. Il primo modo è fornire al comando flask un numero di argomenti: --app, quindi il nome del modulo che contiene la nostra applicazione Flask, e poi run. Vedere sotto:

flask –app <the name of your module> run

Utilizzando l’esempio sopra per eseguire la nostra applicazione di esempio:

flask –app hello run

Ciò farà girare il nostro applicazione sul porto predefinito 5000 quindi l’applicazione sarà disponibile su http://localhost:5000/ o su http://127.0.0.1:5000/. Se vogliamo che l’applicazione sia disponibile su un altro porto, possiamo specificare il porto utilizzando l’opzione -p o --port. Ad esempio:

flask --app hello run --port=8080

Questo farà girare il server sul porto 8080. Un altro modo in cui possiamo eseguire l’applicazione è semplicemente utilizzando i comandi flask run. Tuttavia, per poterlo fare, dobbiamo dire a Flask il nome del modulo che conterrà l’istanza di Flask, e lo facciamo impostando la variabile di ambiente FLASK_APP. Quindi nel nostro caso, l’applicazione Flask è contenuta in un file chiamato hello.py. Quindi possiamo impostarlo in questo modo:

export FLASK_APP=hello

Ora che abbiamo impostato la variabile di ambiente FLASK_APP, possiamo eseguire il server di sviluppo in questo modo:

flask run

Con quel codice, ora abbiamo un’applicazione web in esecuzione. Questo dimostra la filosofia di base di Flask: non abbiamo bisogno di molto codice di modello per far funzionare le cose. Tuttavia, l’applicazione che abbiamo configurato sopra non è molto funzionale o utile, poiché visualizza solo la stringa “Hello World!” sul nostro sito web. Per fare qualcosa di più utile, possiamo rivolgerci ai template. Esamineremo come gestirli successivamente.

Template Flask

Template Flask sono un modo per creare pagine web dinamiche che possono visualizzare contenuti diversi in base a vari fattori, come dati da un database o input utente. I template in Flask sono una combinazione di HTML e di speciali segnaposto chiamati variabili del template che vengono sostituiti con i valori effettivi in fase di runtime.

I template sono memorizzati nella directory templates. Pertanto, per utilizzare i template, è necessario importare il metodo render_template() da flask. Il metodo render_template() accetta un nome di template e eventuali dati opzionali che devono essere passati al template.

Vediamo un esempio di funzione che utilizza un template per rendere una pagina 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)

Nell’esempio sopra, abbiamo una funzione vista — index() — che è associata all’URL radice (“/”) dal decoratore @app.route(). La funzione ha due variabili, title e message. Infine, passiamo il template index.html al render_template(), insieme alle variabili title e message.

Per far funzionare il codice sopra, abbiamo bisogno di avere un template index.html residente in una directory templates. Quindi il template sarà simile a questo:

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

Nel file index.html, i segnaposto {{title}} e {{ message }} vengono sostituiti con i valori passati al template nel metodo render_template().

I template possono anche includere logica più complessa come le istruzioni if e i cicli for, che consentono la generazione di pagine più dinamiche.

Quindi i template in Flask offrono ai developer una opzione molto potente per creare pagine web dinamiche ricche di informazioni generate dall’utente.

Flask Routing

La maggior parte delle applicazioni web avrà più di un URL, quindi abbiamo bisogno di un modo per sapere quale funzione gestisce quale URL. In Flask, questa mappatura è conosciuta come routing — il processo di associazione o mappatura di URL a funzioni di vista. L’associazione di URL a funzioni di vista permette all’applicazione di gestire diversi tipi di richieste, come GET, POST, PUT, DELETE, e altro ancora. Consente inoltre all’applicazione di gestire più richieste da diversi client.

Per impostare le rotte in Flask, utilizziamo il route() decoratore. Il decoratore associa un URL a una funzione di vista — quindi quando un utente visita un URL che esiste nella nostra applicazione, Flask attiva la funzione di vista associata per gestire la richiesta.

Vediamo un esempio:

# hello.py
from flask import Flask, render_template

app = Flask(__name__)

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

Nell’esempio sopra, definiamo un URL su “about” (/about). Quando l’applicazione riceve una richiesta per l’URL “about”, Flask chiama la funzione about(), che restituisce la stringa “Questa è la pagina su”.

Finora, anche se questi esempi restituiscono pagine diverse, tutti utilizzano solo la richiesta HTTP GET. Per poter gestire qualsiasi richiesta specifica, possiamo specificare il metodo HTTP come argomento opzionale per il decoratore route().

Vediamo un esempio di richiesta PUT:

from flask import Flask, request

app = Flask(__name__)

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # ottenere i dati dell'utente dal body della richiesta
    data = request.get_json()
    # fare qualcosa con i dati dell'utente, come aggiornare l'utente nel database
    # ...
    # restituire una risposta che indica successo o fallimento
    return {'message': f'User {user_id} updated successfully'}, 200

In questo esempio, definiamo un percorso che gestisce una richiesta PUT per aggiornare i dettagli dell’utente dato il loro user_id. Usiamo <int:user_id> nel percorso per indicare che l’ID utente deve essere un numero intero.

Nella funzione update_user(), otteniamo i dati dell’utente dal body della richiesta utilizzando il metodo request.get_json(). Facciamo qualcosa con i dati dell’utente, come aggiornare l’utente nel database, e poi restituiamo una risposta che indica successo o fallimento insieme a un codice di stato HTTP (un 200 in questo caso per mostrare successo).

In generale, il routing permette a Flask di gestire diversi tipi di richieste e permette al nostro applicativo di gestire e agire sui dati in modo diverso, a seconda dell’URL che un utente visita.

Form e Validazione in Flask

Oltre a mostrare dati agli utenti, i template Flask possono anche ricevere input dagli utenti per ulteriore elaborazione o archiviazione. A tal fine, Flask offre supporto integrato per elaborare i form HTML e gestire l’input utente. I form Flask si basano sulla libreria WTForms, che offre un modo flessibile e potente per gestire i dati del form e eseguire validazioni. Tuttavia, la libreria non fa parte dell’installazione standard di Flask, quindi abbiamo bisogno di installarla utilizzando il seguente comando:

pip install WTForms

Una volta installato WTForms, per utilizzare i moduli in Flask dobbiamo definire una classe modulo che erediterà da `flask_wtf.FlaskForm`. La classe conterrà i campi che saranno presenti nel modulo e qualsiasi regola di validazione che dovrebbe essere applicata a loro.

Vediamo un esempio di modulo di accesso:

# 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')

Nell’esempio sopra, definiamo un modulo di accesso con due campi — `email` e `password` — e un pulsante di invio. Abbiamo anche un argomento `validators` che viene utilizzato per specificare regole di validazione per ogni campo. Ad esempio, in questo caso richiediamo che il campo `email` contenga un indirizzo email valido e il campo `password` contenga una password di almeno sei caratteri.

Una volta definita la classe modulo, possiamo utilizzarla nella funzione di visualizzazione di accesso per rendere il modulo e elaborare i dati del modulo inviati dall’utente. Vediamo un esempio della funzione di visualizzazione:

# 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
        # fare qualcosa con i dati del modulo
    return render_template('login.html', form=form)

Nell’esempio sopra, abbiamo una vista `login` che accetta due metodi HTTP (GET e POST), quindi quando gli utenti accedono all’URL da un browser il `LoginForm` viene reso come modulo HTML utilizzando il metodo `render_template` e quando un utente invia il modulo controlliamo se il modulo è valido utilizzando il metodo `validate_on_submit`. Se il modulo è valido, accediamo all’email e alla password.

Il modulo `login.html` potrebbe essere simile a questo:

# 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>

Il modello sopra indicato renderà i campi email e password, insieme ai loro etichette, e un pulsante di invio con il testo “Login”. Il campo form.csrf_token è incluso per prevenire attacchi di falsificazione delle richieste tra siti (CSRF). I cicli {% for %} vengono utilizzati per visualizzare eventuali errori di validazione che potrebbero verificarsi.

Utilizzando i moduli Flask, abbiamo un potente modo di gestire l’input dell’utente e saremo in grado di validare i dati che inseriscono.

Estensioni Flask

Come abbiamo visto, Flask è un microframework che include solo le parti più importanti necessarie per creare un’applicazione web. Tuttavia, se abbiamo bisogno di aggiungere funzionalità che non sono offerte di serie da Flask, dobbiamo aggiungere pacchetti all’installazione. Le estensioni Flask sono il modo in cui forniamo questa funzionalità aggiuntiva. Possiamo semplicemente installare il pacchetto di cui abbiamo bisogno. Ci sono molte estensioni create dalla comunità Flask.

Ecco alcune delle più popolari:

• Flask-SQLAlchemy: fornisce l’integrazione con l’ambiente di sviluppo SQLAlchemy che facilita l’interazione con i database.
• Flask-Login: fornisce l’autenticazione degli utenti e la gestione delle sessioni a Flask.
• Flask-Mail: fornisce un’interfaccia semplice per inviare email da Flask.

Ci sono centinaia di estensioni create dalla comunità Flask per gestire diverse funzionalità. L’uso delle estensioni è generalmente semplice. Innanzitutto, dobbiamo installare l’estensione che vogliamo utilizzando pip.

Vediamo un esempio di utilizzo di Flask-SQLAlchemy. Innanzitutto, dobbiamo installarlo:

pip install flask-sqlalchemy

Successivo, dobbiamo configurarlo. Ad esempio:

# 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

Nell’esempio sopra, abbiamo un modello User con un campo username e email. Configuriamo anche SQLALCHEMY_DATABASE_URI, indicando che stiamo utilizzando un database SQLite localizzato in example.db. Con questo impostato, ora abbiamo accesso all’oggetto db che ci permette di interagire con il database. Ad esempio, potremmo creare un nuovo utente e aggiungerlo al database, in questo modo:

#views.py 
from app import db, User

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

Con le estensioni di Flask, il nostro applicazione è in grado di avere più funzionalità di quante ne avrebbe normalmente con l’implementazione core di Flask.

Conclusione

In questo articolo, abbiamo introdotto Flask, un framework web leggero e flessibile per Python. Abbiamo discusso i vantaggi dell’uso di Flask per lo sviluppo web, inclusa la sua semplicità, flessibilità e facilità d’uso. Abbiamo anche trattato come configurare un ambiente di sviluppo, creare route, utilizzare modelli, gestire form e utilizzare estensioni come Flask-SQLAlchemy.

Per riassumere, Flask è un’ottima scelta per costruire applicazioni web di qualsiasi dimensione, da piccoli progetti personali a grandi applicazioni commerciali. È facile da imparare e utilizzare, ma offre anche funzionalità avanzate attraverso le sue numerose estensioni.

Se sei interessato a saperne di più su Flask, ecco alcune risorse aggiuntive:

• Documentazione di Flask
• Flask Mega-Tutorial, di Miguel Grinberg
• Sviluppo Web con Flask, di Miguel Grinberg
• A simple Flask app tutorial
• Esercitazioni su Flask di Real Python

Se vuoi approfondire Django e Flask e le loro migliori applicazioni, consulta Sviluppo Web con Python utilizzando Django e Flask.

Domande Frequenti su Flask, il Framework Python