🌐 Modulo 1: Cos'è un Server Web?
Impariamo le basi prima di iniziare con Flask
1 di 8
45 minuti
Principiante
🖥️ Cos'è un Server Web?
Prima di iniziare con Flask, è fondamentale capire cos'è un server web e come funziona la comunicazione tra browser e server.
🤔 Definizione Semplice
Un server web è un programma che:
- Resta in ascolto su una porta (es. 5000, 8080, 80)
- Riceve richieste da un browser (o altra applicazione)
- Elabora la richiesta (legge database, processa dati, ecc.)
- Risponde inviando HTML, JSON, immagini, ecc.
💡 Analogia del Ristorante
Pensa al server web come a un ristorante:
- Cliente (Browser): fa un ordine (richiesta HTTP)
- Cameriere (Flask): prende l'ordine e lo porta in cucina
- Cuoco (La tua funzione Python): prepara il piatto (elabora i dati)
- Piatto (Risposta HTTP): viene servito al cliente
📡 Il Protocollo HTTP
HTTP (HyperText Transfer Protocol) è il "linguaggio" che browser e server usano per comunicare.
| Componente | Descrizione | Esempio |
|---|---|---|
| URL | Indirizzo della risorsa | http://localhost:5000/home |
| Metodo | Tipo di richiesta | GET, POST, PUT, DELETE |
| Headers | Metadati della richiesta | Content-Type, User-Agent |
| Body | Dati inviati (opzionale) | Form data, JSON |
| Status Code | Esito della risposta | 200 OK, 404 Not Found, 500 Error |
200 OK
201 Created
301 Moved
302 Found
404 Not Found
403 Forbidden
500 Internal Error
503 Unavailable
🛠️ Setup dell'Ambiente con PyCharm
Prima di scrivere codice, prepariamo correttamente il nostro ambiente di sviluppo.
- Apri PyCharm
- File → New Project
- Scegli una cartella (es.
flask-corso) - Seleziona New environment using Virtualenv
- Clicca su Create
Nel terminale di PyCharm (in basso), digita:
pip install flask
Vedrai l'installazione procedere. Quando finisce, Flask è pronto!
Controlla che Flask sia installato correttamente:
pip list
Dovresti vedere Flask nella lista dei pacchetti installati.
🎯 Cos'è un Virtual Environment?
Un ambiente virtuale è uno spazio isolato per il tuo progetto dove installi le librerie senza interferire con altri progetti Python sul tuo computer.
Perché è importante?
- Ogni progetto può avere versioni diverse delle stesse librerie
- Mantieni il sistema Python pulito
- Facilita la condivisione del progetto (file requirements.txt)
🚀 Il Tuo Primo Server Web
Ora creiamo il nostro primo mini server web! Sarà incredibilmente semplice ma funzionante.
In PyCharm, fai clic destro sulla cartella del progetto → New → Python File
Chiamalo app.py
Digita il seguente codice nel file app.py:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return 'Benvenuto nel mio primo server web!'
if __name__ == '__main__':
app.run(debug=True)
In PyCharm, fai clic destro su app.py → Run 'app'
Oppure usa il terminale:
python app.py
Apri il browser e vai su:
http://localhost:5000
Dovresti vedere il messaggio "Benvenuto nel mio primo server web!" 🎉
🔍 Analisi Approfondita del Codice
Ora che hai visto il codice funzionare, analizziamo riga per riga cosa succede dietro le quinte. Capire questi concetti è fondamentale per diventare un esperto di Flask!
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return 'Benvenuto nel mio primo server web!'
if __name__ == '__main__':
app.run(debug=True)
🎯 Mappa delle Righe
- Riga 1: Importa la classe Flask dal modulo flask
- Riga 3: Crea un'istanza dell'applicazione Flask
- Riga 5: Decoratore che associa la URL '/' alla funzione
- Righe 6-7: Funzione che gestisce la richiesta alla homepage
- Righe 9-10: Avvia il server solo se eseguiamo il file direttamente
from flask import Flask importa la classe Flask dal modulo flask.
💡 Differenza chiave
from flask import Flask è diverso da import flask:
- from flask import Flask: Importa SOLO la classe Flask, più efficiente
- import flask: Importa tutto il modulo, dovresti usare
flask.Flask
Analogia: Come quando compri un nuovo elettrodomestico, devi prima toglierlo dalla scatola (importarlo) prima di poterlo usare.
app = Flask(__name__) crea un'istanza della classe Flask, ovvero la nostra applicazione web.
🏠 Analogia della Casa
Immagina di costruire una casa (la tua app web):
- Flask = Il progetto architettonico
- app = Flask(__name__) = La costruzione effettiva della casa
- app = La casa finita, pronta per essere arredata (aggiungere route)
🔍 Il misterioso parametro __name__
__name__ è una variabile speciale di Python che contiene il nome del modulo corrente:
- Se eseguiamo
python app.py→__name__='__main__' - Se importiamo
app.pycome modulo →__name__='app'
Perché Flask ha bisogno di __name__?
- Per trovare risorse: Cartelle statiche (CSS, JS, immagini) e template (HTML)
- Per debugging: Sapere da quale file è partita l'applicazione
- Per configurazione: Impostazioni specifiche per l'ambiente
Cosa sono i decoratori? Sono funzioni speciali che "decorano" (modificano/estendono) altre funzioni.
🔧 Cosa fa esattamente @app.route('/')?
Il decoratore @app.route('/') fa queste cose:
- Registra la URL: Dice a Flask: "Quando qualcuno visita '/', chiama questa funzione"
- Crea un collegamento: Associa la funzione
home()al percorso '/' - Gestisce l'HTTP: Trasforma la tua funzione Python in un handler HTTP
📞 Analogia del Centralino
Immagina un centralino telefonico di un'azienda:
- @app.route('/') = "Se chiamano il numero 0 (homepage), passa la chiamata all'ufficio amministrativo"
- @app.route('/contatti') = "Se chiamano il numero 1, passa alla reception"
- @app.route('/prodotti') = "Se chiamano il numero 2, passa al reparto vendite"
- def home() = L'ufficio amministrativo che risponde alle chiamate
📝 Sintassi equivalente senza decoratori
Per capire meglio, ecco come sarebbe senza la sintassi col @:
@app.route('/')
def home():
return "Ciao"
def home():
return "Ciao"
app.add_url_rule('/', 'home', home)
Il decoratore @app.route('/') è solo una scorciatoia elegante per chiamare app.add_url_rule()!
def home(): definisce una funzione normale di Python che diventa un handler HTTP grazie al decoratore.
🎯 Cosa deve restituire una funzione Flask?
Una funzione decorata con @app.route() può restituire:
- Stringhe:
return "Ciao mondo"→ Diventa HTML - Tuple:
return "Testo", 200→ Con status code personalizzato - Response object: Per controllo avanzato
- JSON: Per API (lo vedremo più avanti)
⚡ Processo Automatico
Flask fa automaticamente queste conversioni:
- Stringa → Response:
"Ciao"→Response("Ciao", mimetype="text/html") - Status code 200: Se non specifichi, usa 200 OK
- Header HTML: Imposta il Content-Type a text/html
🔗 Il ciclo completo richiesta-risposta
if __name__ == '__main__':
app.run(debug=True)
🔒 Perché if __name__ == '__main__'?
Questa condizione impedisce che il server parta accidentalmente quando importi app.py come modulo.
🏭 Analogia della Fabbrica
Immagina una fabbrica di automobili:
- File eseguito direttamente: Sei nella fabbrica principale →
__name__ == '__main__'→ Avvia la produzione (server) - File importato: Sei in un reparto satellite →
__name__ == 'app'→ Non avviare la produzione, fornisci solo componenti
🔍 DEBUG=True - Spiegazione Approfondita
Il parametro debug=True attiva la modalità di sviluppo di Flask, che offre diverse funzionalità cruciali:
Il server si riavvia automaticamente quando modifichi il codice. Non serve fermare e riavviare manualmente!
In caso di errore, mostra una pagina dettagliata con stack trace e console Python interattiva.
Mostra informazioni dettagliate su ogni richiesta nel terminale.
Permette debugging remoto (SOLO in ambiente di sviluppo controllato!).
Il parametro debug=True NON DEVE MAI essere usato in ambiente di produzione perché:
- Espone informazioni sensibili: Stack trace, variabili, percorsi file
- Permette esecuzione codice remoto: Il debugger interattivo può essere sfruttato da malintenzionati
- Performance ridotte: Il reload continuo consuma risorse
- Sicurezza compromessa: Vulnerabilità esposta
Per produzione usa sempre: app.run(debug=False) o meglio ancora, un server WSGI come Gunicorn.
🎯 Quando usare debug=True
🛠️ Configurazioni Alternative
| Configurazione | Descrizione | Quando usarla |
|---|---|---|
debug=True |
Modalità sviluppo completa | Sviluppo locale |
debug=False |
Modalità produzione | Server pubblico |
port=8080 |
Cambia porta (default: 5000) | Se porta 5000 è occupata |
host='0.0.0.0' |
Accetta connessioni esterne | Testing su rete locale |
🧪 Prova il Debug Mode
Crea un errore nel tuo codice per vedere il debugger in azione:
@app.route('/errore')
def pagina_errore():
# Errore intenzionale: variabile non definita
return variabile_non_definita # ← NameError!
# Poi visita: http://localhost:5000/errore
# Vedrai il debugger interattivo di Flask!
💪 Esercizio Pratico
Modifica il tuo app.py per aggiungere queste funzionalità:
- Aggiungi una seconda pagina: Crea una route
/aboutche restituisca "Informazioni su di me" - Cambia porta: Fai partire il server sulla porta 8080 invece di 5000
- Personalizza lo status: Fai restituire alla homepage lo status code 201 invece di 200
- Prova debug mode: Crea una pagina che genera un errore e osserva il debugger
from flask import Flask
app = Flask(__name__)
# Homepage con status code personalizzato
@app.route('/')
def home():
return 'Benvenuto!', 201 # Status code 201 Created
# Nuova pagina about
@app.route('/about')
def about():
return 'Informazioni su di me'
# Pagina con errore per testare debug mode
@app.route('/errore')
def pagina_errore():
# Errore intenzionale per testare il debugger
return variabile_non_definita # ← NameError
if __name__ == '__main__':
# Avvia sulla porta 8080 con debug mode
app.run(debug=True, port=8080)
🎯 Testa il Tuo Codice
Dopo aver salvato il file:
- Visita
http://localhost:8080/→ Dovresti vedere "Benvenuto!" - Visita
http://localhost:8080/about→ Dovresti vedere "Informazioni su di me" - Visita
http://localhost:8080/errore→ Dovresti vedere il debugger di Flask con l'errore - Prova a modificare un messaggio e salvare → Il server dovrebbe riavviarsi automaticamente
📝 Riepilogo Modulo 1
- Cos'è un server web e come funziona il ciclo request-response
- Il protocollo HTTP e gli status code
- Come configurare PyCharm per Flask
- Creare e avviare il tuo primo server web
- La struttura base di un'applicazione Flask
- Come funzionano i decoratori in Flask
- L'importanza di
__name__edebug=True - Il ciclo completo di una richiesta HTTP
🎯 Nel Prossimo Modulo
Imparerai a creare route dinamiche, gestire parametri URL e organizzare meglio la tua applicazione con più pagine!