Come si passa da tanti piccoli programmi Python a un software utilizzabile? In questo capitolo progettiamo MEGI GESTIONALE STEM, un’applicazione desktop che registra misure ambientali, le conserva in SQLite, le esporta in CSV/JSON e le analizza con statistiche. È un progetto di sintesi di tutto il percorso Python.
Destinatari: classe seconda, Liceo scientifico – Scienze applicate. Prerequisiti: B1.01–B1.09: Python, condizioni e cicli, funzioni, strutture dati, file, SQLite, classi e Tkinter. Ambiente: Python 3.11+; libreria standard; PyInstaller soltanto per il confezionamento Windows.
Competenze: analizzare requisiti, progettare moduli, convalidare dati, utilizzare file e DBMS, controllare il codice con test riproducibili, costruire una GUI e distinguere software sorgente da programma distribuito.
1. Il problema reale
Un gruppo di studenti osserva temperatura, umidità relativa e pressione durante un esperimento in serra. Le misure devono rimanere disponibili dopo la chiusura del programma, essere individuabili per nome o annotazioni e poter essere trasferite in formati aperti.
2. Analisi dei requisiti
Un requisito funzionale descrive ciò che il sistema deve fare; un requisito non funzionale descrive un vincolo sulla sua qualità o sul suo ambiente. Un requisito verificabile permette di formulare un test con un risultato atteso.
| Requisito | Comportamento verificabile |
|---|---|
| Inserimento | Una rilevazione valida produce un nuovo ID. |
| Persistenza | Dopo la chiusura e una nuova apertura, i dati sono ancora presenti. |
| Ricerca | Il testo viene cercato in esperimento e note. |
| Importazione | Un file invalido non deve inserire record parziali. |
| GUI | L’utente riceve un messaggio in caso di input errato. |
| Distribuzione | Si può generare un eseguibile Windows da collaudare su Windows. |
3. Dall’analisi alla progettazione
La progettazione trasforma i requisiti in entità, funzioni, moduli e interfacce. Si scelgono prima le responsabilità e solo dopo i dettagli grafici: in tal modo un errore nel database si può individuare indipendentemente dai widget.
4. Architettura modulare
Il gestionale adotta una separazione semplice tra vista/controller grafico, servizi, repository SQL, modello e conversione dei file. Non è necessario introdurre un framework complesso per comprendere il principio della separazione delle responsabilità.
run.py
|
v
megestionale/gui.py ---> service.py ---> database.py ---> SQLite
| ^
v |
model.py scambio.py
CSV/JSON
Le frecce rappresentano dipendenze logiche, non scambio automatico con Internet. scambio.py importa record attraverso il repository. Il modello valida i dati anche quando non si usa la GUI.
5. Organizzazione dei file
La cartella distribuita contiene dodici file, inclusi i documenti e i dati dimostrativi. I moduli importabili si trovano nella cartella megestionale:
MEGISTONE_B1_10_Progetto_Python_STEM/
├── run.py
├── README.md
├── PROGETTAZIONE.md
├── build_windows.bat
├── megestionale/
│ ├── __init__.py
│ ├── model.py
│ ├── database.py
│ ├── service.py
│ ├── scambio.py
│ └── gui.py
├── tests/
│ └── test_gestionale.py
└── esempi/
└── rilevazioni_demo.csv
Per avviare il progetto non serve modificare il codice: si esegue run.py dalla cartella estratta. Il database operativo viene creato in una cartella scrivibile dell’utente, non dentro lo ZIP.
6. Modello dei dati: una rilevazione scientifica
Una rilevazione rappresenta una osservazione ambientale associata a un esperimento e a un istante. È una entità con proprietà e vincoli:
| Attributo | Tipo nel programma | Regola |
|---|---|---|
id |
int | None |
Identificatore positivo assegnato da SQLite. |
esperimento |
str |
Non vuoto; massimo 120 caratteri. |
istante |
str |
Data ISO 8601 interpretabile da datetime.fromisoformat. |
temperatura |
float |
Valore finito in °C. |
umidita |
float |
Da 0 a 100%, inclusi gli estremi. |
pressione |
float |
Maggiore di zero, in hPa. |
note |
str |
Facoltative; massimo 1000 caratteri. |
La data è memorizzata come stringa ISO 8601. L’applicazione non implementa automaticamente conversioni tra fusi orari: per confronti rigorosi fra località servirebbero timestamp con informazione di fuso e una convenzione comune.
7. Dataclass, oggetti e incapsulamento
Una dataclass genera automaticamente metodi comuni come l’inizializzazione. Con frozen=True gli attributi dell’istanza non sono riassegnabili dopo la costruzione; non equivale alla protezione di ogni possibile struttura mutabile, ma qui i campi sono numeri e stringhe.
from dataclasses import dataclass
@dataclass(frozen=True)
class MisuraEsempio:
temperatura: float
umidita: float
misura = MisuraEsempio(22.5, 48.0)
print(misura.temperatura) # 22.5
Nel progetto reale la classe si chiama Rilevazione, si trova in model.py ed esegue la validazione in __post_init__. Questa funzione riceve i valori appena inizializzati e può sollevare ValueError se non rispettano le invarianti.
8. Validazione degli input ed eccezioni
Una GUI restituisce inizialmente stringhe. Prima di creare una rilevazione, converti() interpreta i campi numerici; accetta sia 20.5 sia 20,5. La classe Rilevazione controlla poi che le grandezze siano finite e rispettino le regole.
from megestionale.service import converti
r = converti('Serra', '2026-11-18T10:00:00',
'20,5', '45,2', '1012,3')
print(r.temperatura) # 20.5
Perché è necessario math.isfinite()? La conversione float("nan") non fallisce, ma NaN non è una misura valida da memorizzare. Anche l’infinito non è una rilevazione reale. Gli errori vengono segnalati con eccezioni e trasformati dalla GUI in messaggi per l’utente.
Le regole minime di inserimento non certificano la plausibilità: un sensore guasto può produrre un numero valido ma scientificamente inaffidabile.
9. SQLite: persistenza e schema relazionale
SQLite è un DBMS relazionale incorporato, accessibile tramite il modulo standard sqlite3. I dati rimangono nel file rilevazioni.sqlite3 anche quando il programma termina. Nel progetto si usa una tabella:
CREATE TABLE IF NOT EXISTS rilevazioni (
id INTEGER PRIMARY KEY AUTOINCREMENT,
esperimento TEXT NOT NULL,
istante TEXT NOT NULL,
temperatura REAL NOT NULL,
umidita REAL NOT NULL CHECK (umidita >= 0 AND umidita <= 100),
pressione REAL NOT NULL CHECK (pressione > 0),
note TEXT NOT NULL DEFAULT ''
);
La chiave primaria identifica univocamente ogni riga. I vincoli SQL CHECK costituiscono un secondo livello di controllo per umidità e pressione; la validazione Python resta necessaria per campi e casi che lo schema non verifica. Modello ER, normalizzazione e SQL sistematico saranno approfonditi nel Blocco D.
10. CRUD: creare, leggere, aggiornare, eliminare
CRUD riassume Create, Read, Update, Delete. Un identificatore distingue le righe anche quando più esperimenti hanno lo stesso nome. Il repository Archivio offre i metodi inserisci, elenca, ottieni, modifica ed elimina.
from pathlib import Path
from tempfile import TemporaryDirectory
from megestionale.database import Archivio
from megestionale.service import converti
with TemporaryDirectory() as cartella:
db = Archivio(Path(cartella) / "prove.sqlite3")
r = converti("Serra", "2026-11-18T10:00:00",
"22", "50", "1013")
identificativo = db.inserisci(r)
print(db.ottieni(identificativo).esperimento)
print(len(db.elenca()))
# Output: Serra; 1
Questo esempio usa una cartella temporanea per esercitarsi senza modificare il database personale. Il metodo ottieni restituisce None quando l’ID non esiste. Modifica ed eliminazione restituiscono un booleano che permette alla GUI di distinguere un intervento riuscito da un record mancante.
11. Query parametrizzate: dati separati dal codice SQL
Una query non deve incorporare direttamente il testo inserito dall’utente. Si usano segnaposto ? e una tupla di parametri:
con.execute(
"SELECT * FROM rilevazioni WHERE id = ?",
(identificativo,)
)
Nel repository reale la ricerca usa LIKE ? ESCAPE '!': oltre a usare parametri, rende letterali i caratteri speciali % e _. In questo modo una ricerca di % non viene interpretata come «tutte le righe». Le query parametrizzate mitigano l’iniezione SQL; la gestione dei caratteri jolly risolve un problema diverso, quello della semantica del filtro.
12. Transazioni e integrità
Una transazione raggruppa operazioni che devono essere confermate insieme oppure annullate insieme. Il metodo Archivio.connessione() utilizza commit() al termine regolare e rollback() quando viene sollevata un’eccezione.
def inserisci_molti(self, dati):
with self.connessione() as con:
for rilevazione in dati:
self._inserisci(con, rilevazione)
return len(dati)
È un estratto fedele della logica presente nel repository. Se una riga genera un errore SQLite, nessuna delle righe di quel lotto rimane inserita. Il test automatizzato simula esplicitamente tale errore.
13. File CSV e JSON: due formati, due scopi
CSV rappresenta i dati in righe e colonne: è comodo per fogli elettronici, ma non trasporta automaticamente tipi complessi. JSON rappresenta strutture annidabili, come liste di oggetti, ed è adatto allo scambio tra programmi. Nel gestionale entrambi vengono trattati come formati di trasferimento, non come database principale.
| Formato | Organizzazione | Nel progetto |
|---|---|---|
| CSV | Intestazione + righe; valori testuali | Esporta campi misurati, escluso ID. |
| JSON | Lista di oggetti con proprietà | Esporta anche ID; l’importazione assegna comunque nuovi ID. |
| SQLite | Tabella con indici, vincoli e transazioni | Archivio persistente di riferimento. |
esperimento,istante,temperatura,umidita,pressione,note
Serra,2026-11-18T10:00:00,22.0,50.0,1013.0,controllo
L’importazione valida dapprima l’intero file; poi aggiunge tutte le righe in una sola transazione. Un file errato non lascia mezze importazioni. Il programma non deduplica automaticamente le misure e non sovrascrive record con ID uguali: ogni importazione riuscita aggiunge record nuovi.
14. Percorsi, file temporanei e backup
Salvare nel percorso del codice sorgente è fragile: dopo la distribuzione può essere una cartella non scrivibile. La funzione directory_dati() sceglie invece una directory personale. Su Windows usa %LOCALAPPDATA%\MEGISTONE\GestionaleSTEM; su sistemi Unix-like usa una cartella sotto ~/.local/share, salvo XDG_DATA_HOME.
L’export scrive prima un file temporaneo nella cartella di destinazione e lo sostituisce con os.replace(). È una tecnica utile per ridurre il rischio di lasciare un file di esportazione parziale, senza trasformare il CSV o JSON in un archivio transazionale. Per il backup del database, chiudere l’applicazione prima di copiare rilevazioni.sqlite3.
15. GUI Tkinter: interfaccia e widget
Tkinter mette a disposizione finestre e controlli. Nella GUI reale sono usati ttk.Entry per i campi, ttk.Treeview per le righe, pulsanti per le operazioni e finestre di dialogo per selezionare CSV e JSON. L’interfaccia presenta lo stato delle operazioni e gli errori. La disposizione è pensata per un computer desktop; la prova visiva su Windows resta necessaria.
La GUI non memorizza direttamente dati con SQL: raccoglie input, chiama Gestore, aggiorna la tabella e mostra un messaggio. Il codice del dominio può così essere testato senza monitor.
16. Eventi e callback
Una callback è una funzione chiamata in risposta a un evento. Per esempio un pulsante «Salva» invoca salva(): questa legge il form, convalida, inserisce oppure modifica la rilevazione e aggiorna la vista. Se un errore viene sollevato, messagebox.showerror comunica che l’operazione non è stata completata.
ttk.Button(
contenitore,
text="Salva / Modifica",
command=self.salva
)
L’attributo command=self.salva passa il riferimento alla callback, senza parentesi: usare self.salva() la eseguirebbe subito durante la creazione del pulsante. Questo frammento descrive il meccanismo della GUI, che nel pacchetto crea i controlli all’interno del proprio metodo di costruzione.
17. Statistiche descrittive
Un gestionale scientifico non deve limitarsi a mostrare righe. Per un campo scelto tra temperatura, umidità e pressione, il servizio restituisce il numero di osservazioni, il minimo, il massimo e la media aritmetica.
Se due temperature sono 20 °C e 24 °C, la media è (20 + 24)/2 = 22 °C. Con zero misure il numero è 0 e minimo, massimo e media sono None, non zero: uno zero sarebbe una misura possibile e quindi un risultato scientificamente fuorviante.
Attenzione: nel gestionale le statistiche sono calcolate sull’intero archivio, anche se è attiva una ricerca nella tabella. Il dato numerico è descrittivo: non contiene, da solo, incertezza strumentale o informazioni sulla distribuzione temporale delle osservazioni.
18. Test automatici con unittest
Un test automatico ripete operazioni e confronta risultati reali con risultati attesi. unittest è incluso nella libreria standard e non richiede installazioni aggiuntive. Qui ogni test usa un database temporaneo, evitando di modificare l’archivio dell’utente.
py -3 -m unittest discover -s tests -v
def test_statistiche(self):
self.g.aggiungi(prova(temperatura=20))
self.g.aggiungi(prova(temperatura=24))
s = self.g.statistiche("temperatura")
self.assertEqual(s.media, 22)
Il pacchetto comprende otto metodi di test: CRUD e persistenza; ricerca parametrizzata; validazioni; statistiche; esportazione/importazione CSV e JSON; rollback per dati invalidi; rollback per errore SQLite; intestazioni CSV errate. Un test che supera la prova non dimostra l’assenza di ogni difetto: indica che gli scenari controllati hanno rispettato le attese.
19. Debugging e gestione degli errori
Il debugging individua la causa di un comportamento errato; il test verifica che un comportamento rispetti le specifiche. Per risolvere un difetto si parte da un caso minimo riproducibile, si osservano input, output ed eccezioni, si corregge il modulo responsabile e poi si riesegue l’intera suite di regressione.
- Errore di input: un valore testuale non numerico genera
ValueError. - Errore di schema: un CSV privo di colonne obbligatorie viene rifiutato.
- Errore di persistenza: una transazione fallita viene annullata.
- Errore di interfaccia: deve essere verificato anche manualmente, perché i test automatici forniti non pilotano i widget Tkinter.
20. Distribuzione Windows con PyInstaller
Distribuire non significa soltanto copiare run.py. Occorre consegnare file necessari, istruzioni, versione e procedure di collaudo. L’applicazione si può eseguire direttamente con Python 3.11+ oppure confezionare su Windows mediante PyInstaller.
py -3 -m pip install pyinstaller
py -3 -m PyInstaller --noconfirm --clean --onefile --windowed --name MEGI_Gestionale_STEM run.py
Il pacchetto include anche build_windows.bat. Se il processo termina correttamente, l’eseguibile atteso è dist\MEGI_Gestionale_STEM.exe. L’EXE non è incluso nello ZIP né è stato collaudato su Windows. PyInstaller non converte Python in codice nativo indipendente da ogni sistema operativo: confeziona runtime e componenti necessari per la piattaforma di build.
21. Installazione e collaudo finale
Estrai lo ZIP, apri il terminale nella cartella contenente run.py ed esegui:
py -3 run.py
Esegui i test con il comando già illustrato, poi prova manualmente la GUI: inserisci una misura valida; modifica la temperatura; cerca una parola; annulla una cancellazione; esporta CSV/JSON; importa un file errato e verifica che nessun record sia stato aggiunto. Controlla dove è stato creato il database e prova una riapertura del programma.
Il collaudo definitivo per MEGISTONE comprende anche leggibilità dei widget, assenza di elementi tagliati sul computer Windows, coerenza delle unità, messaggi d’errore e funzionamento dell’eventuale eseguibile. I risultati confermati dai test automatici non vanno confusi con queste prove pratiche.
22. Estensioni interdisciplinari STEM
I dati del gestionale possono essere usati in Fisica per costruire un grafico temperatura–tempo, in Scienze per analizzare l’umidità di una serra e in Matematica per confrontare medie e dispersione. Prima di interpretare le misure, controllare unità, risoluzione, calibrazione e incertezza dello strumento.
- Confrontare una media giornaliera con i valori individuali.
- Registrare temperatura in condizioni sperimentali ripetibili.
- Progettare un grafico scientifico nel foglio elettronico con istanti sull’asse orizzontale.
- Confrontare serie con differenti frequenze di campionamento.
- Ipotizzare un futuro invio di misure da un microcontrollore, senza dichiarare che il programma attuale comunica già con Arduino.
23. Dal progetto Python al Blocco B2
Abbiamo realizzato un sistema che acquisisce dati tramite un form, li valida, li conserva e li analizza. Nel successivo Blocco B2 lo studente studierà come un microcontrollore legge ingressi fisici e pilota uscite: il collegamento didattico è il passaggio da dato inserito manualmente a dato misurato da sensore. Il percorso proseguirà con l’architettura dei microcontrollori, le memorie, i pin e i sistemi embedded.
24. Allenati con MEGI — 24 esercizi graduati
Rispondi per iscritto o in laboratorio; per i compiti pratici conserva uno screenshot o un file di test. Gli esercizi sono classificati per competenza: non sono pulsanti interattivi e non simulano una verifica automatica. Le soluzioni commentate possono essere sviluppate in una scheda docente separata.
- Comprensione. Spiega perché il programma usa sia un modello Python sia uno schema SQLite.
- Comprensione. Distingui un requisito funzionale da uno non funzionale usando il gestionale.
- Comprensione. Indica il ruolo di
run.py,gui.pyeservice.py. - Comprensione. Perché
idè preferibile al nome dell’esperimento come chiave primaria? - Applicazione. Inserisci tre misure valide di una serra e annota i rispettivi ID.
- Applicazione. Modifica una temperatura e verifica che il risultato rimanga dopo una riapertura.
- Applicazione. Esporta in CSV e individua intestazioni, righe e unità di misura.
- Applicazione. Importa lo stesso CSV due volte. Spiega perché il numero di righe aumenta.
- Analisi del codice. Spiega la differenza tra
command=self.salvaecommand=self.salva(). - Analisi del codice. Perché
math.isfinite(float("nan"))restituisceFalse? - Analisi del codice. Individua parametri e segnaposto nella query
WHERE id=?. - Analisi del codice. Perché la ricerca tratta i caratteri
%e_in modo speciale? - Correzione errori. Correggi un input con umidità 125% e spiega quale validazione interviene.
- Correzione errori. Un file CSV contiene solo le colonne
nome,temperatura. Qual è il problema? - Correzione errori. Una data è
oggi. Proponi una data e ora ISO 8601 valida. - Correzione errori. Un’applicazione salva il database accanto all’EXE in una directory protetta. Proponi una soluzione.
- Progettazione. Disegna un diagramma dei moduli e indica quali possono conoscere Tkinter.
- Progettazione. Specifica una funzione per filtrare le misure per intervallo temporale senza alterare il database.
- Progettazione. Proponi due nuovi test per valori ai limiti dell’umidità relativa.
- Progettazione. Descrivi come aggiungeresti un campo
lucecon unità lux senza rompere le importazioni esistenti. - Verifica e collaudo. Esegui tutti i test e registra data, versione Python, numero di test ed esito.
- Verifica e collaudo. Simula un file JSON con una misura corretta e una errata: controlla l’atomicità dell’importazione.
- STEM. Con temperature 20, 22, 24 e 26 °C calcola media, minimo e massimo, poi verifica nel programma.
- STEM. Progetta un esperimento con sensore: definisci variabile, unità, frequenza di acquisizione e incertezza.
25. Errori frequenti e idee da ricordare
- GUI ≠ logica: un pulsante non dovrebbe contenere tutta la logica del database.
- CSV ≠ SQLite: esportare un file non sostituisce vincoli e transazioni.
- Validità ≠ accuratezza: una misura numerica può essere errata scientificamente.
- Media di un insieme vuoto: non è 0; nel gestionale è
None. - Test automatico ≠ collaudo grafico: entrambi servono.
- EXE non incluso: deve essere generato e provato su Windows.
26. Scarica il progetto e approfondisci
Il pacchetto Python è consegnato separatamente come archivio ZIP. Dopo averlo caricato nella Libreria Media o in un percorso stabile del sito, sostituisci il segnaposto del pulsante download con l’URL pubblico reale, verificato in WordPress.
Download progetto Python: [INSERIRE QUI IL PULSANTE BLU SOLTANTO DOPO L’UPLOAD DELLO ZIP]
Il pulsante arancione 3D per MEGISTONE STEM LAB B1.10 verrà inserito soltanto dopo la pubblicazione e il collaudo del laboratorio HTML/JavaScript, in una nuova scheda. Evitiamo collegamenti inattivi o inventati.
Raccordo didattico precedente: B1.09 — GUI Tkinter: widget, eventi, finestre e Canvas. Successivo: B2.01 — Microcontrollori: architettura, memorie, I/O e sistemi embedded (da sviluppare).