
Interfacce grafiche Python Tkinter: impariamo a costruire finestre, widget, eventi e Canvas per trasformare uno script in un’applicazione desktop. Dalle prime Label fino a un cruscotto STEM, ogni passo unisce teoria, codice completo e verifica sperimentale.
Ambiente: Python 3.13 con supporto Tcl/Tk e display desktop. Prerequisiti: funzioni, strutture dati, gestione delle eccezioni e OOP. Competenze: progettare interfacce, gestire eventi, validare dati, modellare grandezze scientifiche e realizzare semplici visualizzazioni grafiche.
17.1 — Dalla console alle interfacce grafiche
Un programma a interfaccia a riga di comando (CLI) riceve dati e mostra risultati nel terminale. Una GUI (Graphical User Interface) organizza le stesse operazioni in finestre, etichette, campi di testo e pulsanti. Il calcolo resta Python: cambia il modo in cui l’utente dialoga con il programma.
Nella CLI l’esecuzione attraversa spesso le istruzioni in sequenza, attendendo input(); nella GUI le azioni partono dagli eventi: un clic, un tasto, uno spostamento del cursore. La GUI aiuta a esplorare dati e strumenti scientifici, ma richiede attenzione allo stato dell’applicazione, alla validazione e alla responsività.
Prerequisiti: variabili, funzioni, eccezioni e classi di B1.01–B1.08. Al termine: costruirai una GUI funzionante, gestirai eventi, organizzerai i widget e visualizzerai grandezze su Canvas. I database e la distribuzione completa appartengono a B1.10.
Esempio — la stessa formula nella CLI
Obiettivo: calcolare una temperatura Celsius partendo da Fahrenheit.
Questa versione è sequenziale; la riscriveremo con un campo di input e un pulsante.
def fahrenheit_celsius(fahrenheit):
return (fahrenheit - 32) * 5 / 9
try:
valore = float(input("Temperatura in °F: "))
print(f"Temperatura: {fahrenheit_celsius(valore):.2f} °C")
except ValueError:
print("Inserisci un numero valido.")
Risultato atteso: Con input 68 viene stampato Temperatura: 20.00 °C.
Da osservare: Il calcolo non dipende dalla presenza di una GUI.
Sperimenta: Prova 32 e 212 °F.
17.2 — Tkinter e l’architettura di una GUI
tkinter è l’interfaccia Python al toolkit Tcl/Tk. In molte installazioni desktop di Python è disponibile, ma la presenza di Tcl/Tk va verificata: un Python minimale o un ambiente senza server grafico può non consentire l’apertura delle finestre.
L’architettura comprende una finestra radice Tk, widget figli, contenitori e un ciclo degli eventi. Il codice crea i controlli e registra funzioni callback; mainloop() riceve gli eventi e richiama le funzioni corrispondenti. È bene mantenere separati modello dei dati, logica e interfaccia.
Esempio — verifica dell’installazione
Obiettivo: controllare la disponibilità di Tkinter.
Da un terminale desktop prova il seguente comando; apre una piccola finestra diagnostica se Tcl/Tk è utilizzabile.
# Eseguire nel terminale:
# python -m tkinter
import tkinter as tk
print("Tk disponibile, versione Tcl:", tk.TclVersion)
print("Versione Tk:", tk.TkVersion)
Risultato atteso: Il programma mostra nel terminale le versioni installate; il comando python -m tkinter apre una finestra di prova quando l’ambiente grafico è disponibile.
Da osservare: L’importazione riuscita non garantisce che sia disponibile un display grafico.
Sperimenta: Confronta l’esecuzione su due sistemi operativi.

17.3 — Creare la prima finestra con Tk()
Normalmente un’applicazione Tkinter possiede una sola radice Tk(); le finestre aggiuntive si creano con Toplevel. title() assegna il titolo, geometry() propone dimensioni iniziali e mainloop() avvia l’interazione.
Esempio — prima finestra
Obiettivo: aprire una finestra con un messaggio.
Copia il file in prima_gui.py ed eseguilo in un ambiente desktop.
import tkinter as tk
root = tk.Tk()
root.title("MEGISTONE — Prima GUI")
root.geometry("420x200")
messaggio = tk.Label(root, text="Benvenuti in Tkinter!", font=("Arial", 16))
messaggio.pack(padx=20, pady=30)
root.mainloop()
Risultato atteso: Una finestra circa 420×200 con il messaggio centrale in alto.
Da osservare: Dopo mainloop() il programma attende eventi; non si usa un ciclo while True per mantenere aperta la finestra.
Sperimenta: Modifica titolo, dimensione e margini.
17.4 — Label, Button ed Entry
Label visualizza informazioni, Entry acquisisce testo su una riga e Button avvia un’azione. La proprietà command riceve una funzione da richiamare più tardi: command=calcola è corretto; command=calcola() eseguirebbe subito la funzione durante la costruzione della GUI.
Esempio — saluto interattivo
Obiettivo: leggere il nome da Entry e aggiornare una Label.
Una callback recupera il testo solo quando l’utente preme il pulsante.
import tkinter as tk
root = tk.Tk()
root.title("Saluto interattivo")
nome = tk.Entry(root, width=28)
nome.pack(padx=16, pady=10)
risposta = tk.Label(root, text="Scrivi il nome e premi Saluta")
risposta.pack(pady=6)
def saluta():
testo = nome.get().strip()
risposta.config(text=f"Ciao, {testo or 'studente'}!")
tk.Button(root, text="Saluta", command=saluta).pack(pady=8)
root.mainloop()
Risultato atteso: Il clic modifica il testo dell’etichetta; senza nome appare “Ciao, studente!”.
Da osservare: get() restituisce una stringa, non un numero.
Sperimenta: Aggiungi un pulsante per svuotare il campo.
17.5 — Organizzare il layout: pack(), grid() e place()
pack() dispone i widget lungo i lati del contenitore; grid() usa righe e colonne; place() permette coordinate o posizioni relative. Non mescolare pack e grid sui widget figli dello stesso contenitore. È invece corretto usare pack sulla cornice principale e grid sui figli di una cornice distinta.
Preferisci grid() nei moduli e nei pannelli di input. Imposta columnconfigure(..., weight=1) e sticky="ew" per consentire l’allargamento dei campi. place() è utile in esercizi a coordinate, ma può adattarsi male a schermi e font differenti.
Esempio — modulo con grid
Obiettivo: allineare due etichette e due Entry.
La radice gestisce il frame con pack; il frame dispone i figli con grid.
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
root.title("Modulo")
frame = ttk.Frame(root, padding=16)
frame.pack(fill="both", expand=True)
frame.columnconfigure(1, weight=1)
for riga, titolo in enumerate(("Temperatura", "Umidità")):
ttk.Label(frame, text=titolo).grid(row=riga, column=0, sticky="w", pady=6)
ttk.Entry(frame).grid(row=riga, column=1, sticky="ew", padx=8)
root.mainloop()
Risultato atteso: Due righe allineate, con campi che si allargano.
Da osservare: Nel frame si usa soltanto grid.
Sperimenta: Aggiungi la riga “Pressione”.

17.6 — Variabili Tkinter e aggiornamento dello stato
StringVar, IntVar, DoubleVar e BooleanVar sono variabili di controllo collegate all’interprete Tcl/Tk. Non sono semplici nomi Python: tramite get(), set() e textvariable sincronizzano automaticamente lo stato di widget compatibili. Per aggiornare una StringVar si usa variabile.set(...), non la riassegnazione del nome a una stringa.
Esempio — contatore reattivo
Obiettivo: contare i clic con IntVar.
Il testo della Label cambia automaticamente quando la variabile di controllo viene aggiornata.
import tkinter as tk
root = tk.Tk()
root.title("Contatore")
conteggio = tk.IntVar(value=0)
tk.Label(root, textvariable=conteggio, font=("Arial", 24)).pack(padx=30, pady=12)
def aumenta():
conteggio.set(conteggio.get() + 1)
tk.Button(root, text="+1", command=aumenta).pack(pady=8)
root.mainloop()
Risultato atteso: La Label visualizza 0, poi 1, 2 e così via.
Da osservare: Il collegamento tra Label e variabile è fornito da textvariable.
Sperimenta: Aggiungi il pulsante “Azzera”.
17.7 — Programmazione guidata dagli eventi
Un evento è un fatto osservabile, come il clic o la pressione di un tasto. Con command si assegna un’azione ai controlli che supportano l’opzione; con bind("<Return>", funzione) si collega una funzione a un evento di tastiera. La callback di bind riceve un oggetto evento, mentre quella di command normalmente non riceve argomenti.
Nel thread dell’interfaccia i callback devono essere brevi: un time.sleep() lungo blocca la gestione degli eventi e congela la finestra. La programmazione temporizzata si affronta con after() nella sezione 17.14.
Esempio — Invio oppure clic
Obiettivo: attivare la stessa logica con due eventi.
Si usa una funzione di lavoro senza argomenti e un adattatore per l’evento di tastiera.
import tkinter as tk
root = tk.Tk()
root.title("Eventi")
risultato = tk.StringVar(value="In attesa")
def esegui():
risultato.set("Azione eseguita")
def invio(event):
esegui()
tk.Button(root, text="Esegui", command=esegui).pack(padx=20, pady=10)
tk.Label(root, textvariable=risultato).pack(pady=6)
root.bind("<Return>", invio)
root.mainloop()
Risultato atteso: Un clic o il tasto Invio mostrano “Azione eseguita”.
Da osservare: command=esegui non coincide con command=esegui().
Sperimenta: Associa Escape alla chiusura della finestra.
17.8 — Validazione dell’input e gestione degli errori
L’input di Entry è sempre testo. Per lavorare con grandezze fisiche si converte con float e si controllano i casi non numerici e i valori non finiti. Una GUI robusta avvisa l’utente senza interrompere il programma. messagebox.showerror presenta un dialogo di errore; showinfo fornisce informazioni.
Esempio — temperatura sicura
Obiettivo: convertire un valore e gestire gli errori.
Separiamo il calcolo dalla callback e rifiutiamo NaN e infinito.
import math
import tkinter as tk
from tkinter import messagebox
def in_celsius(testo):
fahrenheit = float(testo.strip().replace(",", "."))
if not math.isfinite(fahrenheit):
raise ValueError("La temperatura deve essere finita")
return (fahrenheit - 32) * 5 / 9
root = tk.Tk()
root.title("Convertitore")
campo = tk.Entry(root)
campo.pack(padx=18, pady=10)
risultato = tk.Label(root, text="Inserisci °F")
risultato.pack(pady=5)
def converti():
try:
valore = in_celsius(campo.get())
except ValueError:
messagebox.showerror("Dato non valido", "Inserisci una temperatura numerica finita")
else:
risultato.config(text=f"{valore:.2f} °C")
tk.Button(root, text="Converti", command=converti).pack(pady=9)
root.mainloop()
Risultato atteso: Con 68 °F appare 20.00 °C; con lettere compare un messaggio di errore.
Da osservare: La validazione è parte del programma, non solo un effetto grafico.
Sperimenta: Prova -40, 212 e una stringa vuota.

17.9 — Frame, LabelFrame e organizzazione modulare
Una GUI cresce rapidamente. Frame raggruppa controlli; LabelFrame aggiunge un titolo visibile. Ogni contenitore ha il proprio sistema di geometria. Dividere la finestra in area dati, area azioni e area risultati facilita manutenzione, riuso e accessibilità.
Esempio — pannelli separati
Obiettivo: costruire due sezioni della stessa finestra.
Le cornici separano input e risultato senza duplicare la radice.
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
root.title("Pannelli")
controlli = ttk.LabelFrame(root, text="Controlli", padding=12)
controlli.pack(fill="x", padx=12, pady=8)
risultati = ttk.LabelFrame(root, text="Risultati", padding=12)
risultati.pack(fill="both", expand=True, padx=12, pady=8)
valore = tk.StringVar(value="0")
ttk.Entry(controlli, textvariable=valore).pack(fill="x")
ttk.Label(risultati, textvariable=valore).pack(anchor="w")
root.mainloop()
Risultato atteso: Due pannelli con un campo e una Label sincronizzati.
Da osservare: I contenitori possono gestire ciascuno una disposizione distinta.
Sperimenta: Crea un terzo pannello per gli strumenti.
17.10 — Widget di selezione e controllo
Checkbutton seleziona opzioni indipendenti, Radiobutton sceglie un solo valore tra alternative che condividono la stessa variabile, Scale varia un numero lungo una scala e Spinbox permette incrementi discreti. ttk.Combobox fornisce un elenco a discesa; state="readonly" limita la scelta ai valori proposti.
Esempio — strumento e opzioni
Obiettivo: selezionare una misura e un valore.
Combobox e Checkbutton aggiornano variabili di controllo distinte.
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
root.title("Scelte")
strumento = tk.StringVar(value="Temperatura")
mostra_unita = tk.BooleanVar(value=True)
scelta = ttk.Combobox(root, values=["Temperatura", "Umidità", "Pressione"],
textvariable=strumento, state="readonly")
scelta.pack(padx=20, pady=8)
ttk.Checkbutton(root, text="Mostra unità", variable=mostra_unita).pack()
output = ttk.Label(root, text="")
output.pack(pady=10)
def aggiorna():
output.config(text=strumento.get() + (" — unità attive" if mostra_unita.get() else ""))
ttk.Button(root, text="Applica", command=aggiorna).pack(pady=6)
root.mainloop()
Risultato atteso: La pressione di Applica mostra lo strumento selezionato e l’eventuale nota.
Da osservare: ttk adotta widget tematici e opzioni di stile che non coincidono sempre con quelle dei widget Tk.
Sperimenta: Sostituisci la Combobox con tre Radiobutton.
17.11 — Text, Listbox e Scrollbar
Text ospita contenuti multilinea; Listbox visualizza una lista selezionabile; Scrollbar consente lo scorrimento dei widget che supportano i relativi comandi. Gli indici di Text sono del tipo "1.0" (riga 1, carattere 0); la selezione di una Listbox si consulta con curselection().
Esempio — registro delle osservazioni
Obiettivo: inserire righe in un registro scorrevole.
Una scrollbar verticale è collegata a Text mediante yscrollcommand e yview.
import tkinter as tk
root = tk.Tk()
root.title("Registro STEM")
contenitore = tk.Frame(root)
contenitore.pack(fill="both", expand=True, padx=10, pady=10)
registro = tk.Text(contenitore, width=44, height=8)
barra = tk.Scrollbar(contenitore, command=registro.yview)
registro.configure(yscrollcommand=barra.set)
registro.pack(side="left", fill="both", expand=True)
barra.pack(side="right", fill="y")
for indice in range(1, 21):
registro.insert("end", f"Campione {indice:02d}: {20 + indice / 10:.1f} °C\n")
root.mainloop()
Risultato atteso: Il registro contiene 20 campioni e scorre verticalmente.
Da osservare: Senza collegare entrambi i comandi lo scorrimento può non funzionare correttamente.
Sperimenta: Aggiungi un pulsante che cancelli il registro.
17.12 — Finestre secondarie, dialog e menu
Una finestra supplementare si ottiene da tk.Toplevel(root), senza creare una seconda radice Tk(). I dialoghi messagebox mostrano messaggi o richieste; filedialog.askopenfilename() può chiedere un percorso scelto dall’utente, che può anche essere vuoto se l’operazione viene annullata. Un Menu organizza comandi come File e Aiuto.
Esempio — finestra Informazioni
Obiettivo: aprire un Toplevel tramite menu.
La finestra secondaria resta associata alla radice e può essere chiusa indipendentemente.
import tkinter as tk
from tkinter import messagebox
root = tk.Tk()
root.title("Menu e finestre")
root.geometry("360x180")
def informazioni():
altra = tk.Toplevel(root)
altra.title("Informazioni")
tk.Label(altra, text="Laboratorio MEGISTONE B1.09", padx=20, pady=20).pack()
def conferma_uscita():
if messagebox.askyesno("Uscita", "Vuoi chiudere l’applicazione?"):
root.destroy()
menu = tk.Menu(root)
aiuto = tk.Menu(menu, tearoff=False)
aiuto.add_command(label="Informazioni", command=informazioni)
menu.add_cascade(label="Aiuto", menu=aiuto)
menu.add_command(label="Esci", command=conferma_uscita)
root.config(menu=menu)
root.protocol("WM_DELETE_WINDOW", conferma_uscita)
root.mainloop()
Risultato atteso: Il menu Aiuto apre una nuova finestra, Esci chiede conferma.
Da osservare: Per le finestre secondarie si usa Toplevel; il comando di chiusura deve liberare correttamente le risorse.
Sperimenta: Aggiungi una voce che mostri messagebox.showinfo.
17.13 — Canvas: coordinate e primitive grafiche
Canvas fornisce un piano per disegnare e aggiornare elementi grafici. L’origine (0, 0) è nell’angolo superiore sinistro; x cresce verso destra e y verso il basso. Le primitive principali sono create_line, create_rectangle, create_oval e create_text. Ogni funzione restituisce un identificatore utile per modificare o spostare l’oggetto.
Esempio — coordinate e forme
Obiettivo: disegnare un’area cartesiana semplificata.
Una linea orizzontale, un asse verticale e un punto aiutano a leggere le coordinate.
import tkinter as tk
root = tk.Tk()
root.title("Canvas")
c = tk.Canvas(root, width=440, height=260, bg="white")
c.pack(padx=12, pady=12)
c.create_line(30, 220, 410, 220, arrow="last", width=2)
c.create_line(30, 220, 30, 20, arrow="last", width=2)
c.create_rectangle(90, 110, 180, 220, fill="#a8dcf0")
c.create_oval(245, 70, 275, 100, fill="#f59e0b", outline="")
c.create_text(250, 235, text="x →")
c.create_text(55, 18, text="y (pixel) ↓")
root.mainloop()
Risultato atteso: Un grafico con assi, rettangolo e cerchio.
Da osservare: Il grafico scientifico usa spesso y crescente verso l’alto: bisogna quindi trasformare le coordinate dei dati.
Sperimenta: Cambia dimensioni e colori delle primitive.
17.14 — Animazione e aggiornamento con after()
after(millisecondi, callback) programma una chiamata futura nel ciclo degli eventi. Non crea un nuovo thread e non garantisce una precisione temporale assoluta: la chiamata avviene quando il ciclo può elaborarla. Occorre memorizzare l’identificatore restituito per annullare una chiamata pianificata con after_cancel e impedire che la chiusura lasci aggiornamenti pendenti.
Esempio — pallina in movimento
Obiettivo: avviare, fermare e ripristinare un’animazione.
La callback sposta la pallina e pianifica il frame successivo soltanto se l’animazione è attiva.
import tkinter as tk
root = tk.Tk()
root.title("Animazione after")
c = tk.Canvas(root, width=360, height=110, bg="white")
c.pack(padx=12, pady=8)
palla = c.create_oval(10, 40, 40, 70, fill="orange")
attivo = False
job = None
def passo():
global job
job = None
if not attivo:
return
x1, _, x2, _ = c.coords(palla)
c.move(palla, -x1 + 10 if x2 >= 350 else 5, 0)
job = root.after(40, passo)
def avvia():
global attivo
if not attivo:
attivo = True
passo()
def pausa():
global attivo, job
attivo = False
if job is not None:
root.after_cancel(job)
job = None
def reset():
pausa()
c.coords(palla, 10, 40, 40, 70)
def chiudi():
pausa()
root.destroy()
tk.Button(root, text="AVVIA", command=avvia).pack(side="left", padx=9)
tk.Button(root, text="PAUSA", command=pausa).pack(side="left", padx=9)
tk.Button(root, text="RIPRISTINA", command=reset).pack(side="left", padx=9)
root.protocol("WM_DELETE_WINDOW", chiudi)
root.mainloop()
Risultato atteso: La pallina avanza verso destra, ricomincia quando raggiunge il bordo e risponde ai controlli.
Da osservare: Usare time.sleep() in questa callback congelerebbe l’interfaccia.
Sperimenta: Regola velocità e intervallo separatamente.

17.15 — Tkinter e programmazione orientata agli oggetti
Dopo B1.08 possiamo racchiudere la GUI in una classe. Il modello rappresenta la grandezza fisica e applica regole; la vista crea i widget; il controllore gestisce gli eventi e aggiorna la vista. In un progetto piccolo controller e vista possono appartenere alla medesima classe, ma la logica scientifica dovrebbe restare verificabile senza aprire una finestra.
Esempio — modello e applicazione
Obiettivo: separare calcolo e finestra.
La classe Termometro è indipendente da Tkinter e può essere testata autonomamente.
import tkinter as tk
class Termometro:
def __init__(self, celsius=20.0):
self.celsius = float(celsius)
def fahrenheit(self):
return self.celsius * 9 / 5 + 32
class App:
def __init__(self, root):
self.modello = Termometro(20)
root.title("OOP + GUI")
self.output = tk.StringVar()
tk.Label(root, textvariable=self.output).pack(padx=20, pady=12)
tk.Button(root, text="Mostra °F", command=self.aggiorna).pack(pady=8)
self.aggiorna()
def aggiorna(self):
self.output.set(f"{self.modello.fahrenheit():.1f} °F")
root = tk.Tk()
app = App(root)
root.mainloop()
Risultato atteso: L’etichetta mostra 68.0 °F e il pulsante richiama il metodo della classe.
Da osservare: Un oggetto del modello non deve conoscere i pulsanti.
Sperimenta: Aggiungi un parametro per cambiare la temperatura.
17.16 — Tre applicazioni STEM con Tkinter
Tre applicazioni illustrano un percorso dal calcolo numerico alla rappresentazione di segnali. Ogni programma è autonomo: salvalo in un file .py e avvialo su desktop. I valori dei sensori dei due ultimi esempi sono simulati, non acquisiti da hardware reale.
Esempio — Applicazione 1 — convertitore di temperatura
Obiettivo: convertire tra Celsius e Fahrenheit.
La funzione di conversione valida i numeri e la GUI utilizza una Combobox per selezionare la direzione.
import math
import tkinter as tk
from tkinter import ttk, messagebox
def conversione(testo, modo):
x = float(testo.replace(",", "."))
if not math.isfinite(x):
raise ValueError("Numero non finito")
return (x * 9 / 5 + 32) if modo == "°C → °F" else ((x - 32) * 5 / 9)
root = tk.Tk()
root.title("MEGI — Convertitore")
valore = tk.StringVar(value="20")
modo = tk.StringVar(value="°C → °F")
risposta = tk.StringVar(value="")
ttk.Entry(root, textvariable=valore).pack(padx=16, pady=8)
ttk.Combobox(root, textvariable=modo, state="readonly",
values=["°C → °F", "°F → °C"]).pack(pady=6)
ttk.Label(root, textvariable=risposta).pack(pady=6)
def calcola():
try:
numero = conversione(valore.get(), modo.get())
unita = "°F" if modo.get() == "°C → °F" else "°C"
risposta.set(f"{numero:.2f} {unita}")
except ValueError:
messagebox.showerror("Errore", "Immetti un numero finito")
ttk.Button(root, text="Converti", command=calcola).pack(pady=9)
root.mainloop()
Risultato atteso: Con 20 °C il risultato è 68.00 °F.
Da osservare: Il risultato dipende dalla modalità selezionata; gli errori restano gestiti.
Sperimenta: Verifica il punto di coincidenza -40 °C = -40 °F.
Esempio — Applicazione 2 — sensore virtuale
Obiettivo: campionare una temperatura simulata con andamento regolare.
Il segnale è deterministico, per rendere ripetibili gli esperimenti; un clic produce un nuovo campione.
import math
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
root.title("Sensore virtuale")
indice = 0
output = tk.StringVar(value="Premi Acquisisci")
def acquisisci():
global indice
indice += 1
temp = 22 + 2 * math.sin(indice * 0.4)
output.set(f"Campione {indice}: {temp:.2f} °C")
ttk.Label(root, textvariable=output).pack(padx=20, pady=15)
ttk.Button(root, text="Acquisisci", command=acquisisci).pack(pady=10)
root.mainloop()
Risultato atteso: A ogni clic cambia il numero del campione e viene mostrata una temperatura simulata.
Da osservare: La sinusoide serve a costruire dati controllabili; non è una misura ambientale.
Sperimenta: Cambia periodo e ampiezza del segnale.
Esempio — Applicazione 3 — cruscotto con Canvas
Obiettivo: tracciare una sequenza di misure virtuali.
Le coordinate del segnale vengono trasformate per mostrarlo nell’area del Canvas.
import math
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
root.title("Cruscotto STEM")
canvas = tk.Canvas(root, width=460, height=260, bg="white")
canvas.pack(padx=12, pady=8)
valori = []
def acquisisci():
t = len(valori)
valori.append(20 + 4 * math.sin(t * 0.45))
canvas.delete("grafico")
canvas.create_line(30, 20, 30, 230, fill="#475569", tags="grafico")
canvas.create_line(30, 230, 445, 230, fill="#475569", tags="grafico")
punti = []
for i, v in enumerate(valori[-40:]):
punti.extend((35 + i * 10, 225 - (v - 14) * 10))
if len(punti) >= 4:
canvas.create_line(*punti, fill="#007bb5", width=3, tags="grafico")
elif len(punti) == 2:
x, y = punti
canvas.create_oval(x - 3, y - 3, x + 3, y + 3, fill="#007bb5", tags="grafico")
ttk.Button(root, text="Nuovo campione", command=acquisisci).pack(pady=8)
root.mainloop()
Risultato atteso: Premendo Nuovo campione il grafico si estende fino a 40 misure recenti.
Da osservare: La conversione y = 225 - (v - 14) * 10 inverte la direzione di y.
Sperimenta: Aggiungi una scala con tacche e unità.
17.17 — Progetto Python STEM scaricabile
Il progetto associato a questa unità è un’applicazione desktop didattica autonoma sviluppata con Python Tkinter. Comprende tre sensori virtuali di temperatura, umidità e pressione, storici indipendenti, statistiche e grafici su Canvas. La separazione tra modello scientifico e interfaccia grafica consente di eseguire test automatici senza aprire finestre.
Funzionalità disponibili: selezione del sensore, acquisizione simulata e manuale, validazione dei valori, visualizzazione delle unità di misura, calcolo di minimo, massimo e media, ripristino selettivo e generale e chiusura ordinata. Non sono richiesti database, connessione Internet, account o librerie Python di terze parti.
Il progetto Python STEM B1.09 è disponibile per il download gratuito. Il pacchetto ZIP comprende MEGI_Laboratorio_Tkinter.py, il modulo megi_model.py, i test automatici test_megi.py e il file README.txt. L’applicazione ha superato 11 controlli funzionali guidati su Windows.
Un nucleo testabile senza GUI
Esempio — statistiche delle acquisizioni
Obiettivo: separare la logica scientifica dai widget.
Questo esempio elementare mostra la futura logica testabile e l’uso di un elenco indipendente dalla GUI.
def statistiche(valori):
if not valori:
raise ValueError("Nessuna acquisizione disponibile")
return {"minimo": min(valori), "massimo": max(valori),
"media": sum(valori) / len(valori)}
if __name__ == "__main__":
dati = [20.0, 21.0, 19.0]
esito = statistiche(dati)
print(f"Media: {esito['media']:.2f} °C")
Risultato atteso: Per i dati forniti viene stampato Media: 20.00 °C.
Da osservare: Il modello è testabile anche quando Tkinter non può aprire finestre.
Sperimenta: Aggiungi un controllo dei valori non finiti.
17.18 — Allenati con MEGI: 20 esercizi progressivi
Questa palestra comprende 20 esercizi progressivi in cinque livelli. Ogni soluzione è inizialmente chiusa: prova prima da solo, poi apri Mostra soluzione commentata. Ogni programma è autonomo e richiede un ambiente desktop Tkinter.
Esercizio 01 · Livello A — Fondamenti — Prima finestra
Obiettivo verificabile: Creare la radice e il ciclo eventi.
Consegna: Crea una finestra intitolata “MEGI 01” con dimensioni 300×140.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 01 — Prima finestra
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
root.title("MEGI 01")
root.geometry("300x140")
root.mainloop()
Risultato atteso: Si apre una finestra intitolata MEGI 01.
Errore frequente / verifica: Dimenticare mainloop causa la chiusura immediata in uno script.
Esercizio 02 · Livello A — Fondamenti — Etichetta scientifica
Obiettivo verificabile: Visualizzare un testo.
Consegna: Mostra “Sensore temperatura” in una Label.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 02 — Etichetta scientifica
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
tk.Label(root, text="Sensore temperatura").pack(padx=20, pady=20)
root.mainloop()
Risultato atteso: La finestra contiene la scritta richiesta.
Errore frequente / verifica: Senza un geometry manager il widget non viene disposto.
Esercizio 03 · Livello A — Fondamenti — Pulsante conta-clic
Obiettivo verificabile: Associare una callback a Button.
Consegna: Realizza un pulsante che aumenti il numero dei clic.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 03 — Pulsante conta-clic
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
n = tk.IntVar(value=0)
tk.Label(root, textvariable=n).pack(pady=8)
def clic():
n.set(n.get() + 1)
tk.Button(root, text="Conta", command=clic).pack(pady=8)
root.mainloop()
Risultato atteso: Ogni clic incrementa di 1 il numero visualizzato.
Errore frequente / verifica: Scrivere command=clic() esegue subito la funzione.
Esercizio 04 · Livello A — Fondamenti — Acquisizione del nome
Obiettivo verificabile: Leggere un campo Entry.
Consegna: Mostra in una Label il testo digitato dall’utente.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 04 — Acquisizione del nome
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
e = tk.Entry(root)
e.pack(pady=7)
out = tk.Label(root, text="")
out.pack(pady=7)
def mostra():
out.config(text=e.get())
tk.Button(root, text="Mostra", command=mostra).pack()
root.mainloop()
Risultato atteso: Il clic riproduce il testo scritto.
Errore frequente / verifica: get() restituisce una stringa, anche quando sono digitate cifre.
Esercizio 05 · Livello B — Widget e layout — Modulo a due colonne
Obiettivo verificabile: Disporre controlli con grid.
Consegna: Crea righe Nome e Valore con etichette e campi.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 05 — Modulo a due colonne
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
f = tk.Frame(root)
f.pack(padx=12, pady=12)
for i, titolo in enumerate(("Nome", "Valore")):
tk.Label(f, text=titolo).grid(row=i, column=0, sticky="w")
tk.Entry(f).grid(row=i, column=1, padx=6, pady=4)
root.mainloop()
Risultato atteso: I campi risultano allineati per righe.
Errore frequente / verifica: Non usare pack e grid sui figli dello stesso frame.
Esercizio 06 · Livello B — Widget e layout — Due pannelli
Obiettivo verificabile: Separare i gruppi in LabelFrame.
Consegna: Crea un riquadro Ingresso e uno Output.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 06 — Due pannelli
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
for nome in ("Ingresso", "Output"):
f = ttk.LabelFrame(root, text=nome, padding=10)
f.pack(fill="x", padx=10, pady=7)
ttk.Label(f, text=f"Area {nome}").pack(anchor="w")
root.mainloop()
Risultato atteso: Appaiono due riquadri distinti.
Errore frequente / verifica: Un Frame non ha automaticamente un titolo.
Esercizio 07 · Livello B — Widget e layout — Variabile di controllo
Obiettivo verificabile: Collegare una StringVar a Entry e Label.
Consegna: La Label deve mostrare in tempo reale il testo del campo.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 07 — Variabile di controllo
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
s = tk.StringVar()
tk.Entry(root, textvariable=s).pack(pady=6)
tk.Label(root, textvariable=s).pack(pady=6)
root.mainloop()
Risultato atteso: Digitando nell’Entry cambia subito la Label.
Errore frequente / verifica: Non sostituire s con una stringa Python dopo il collegamento.
Esercizio 08 · Livello B — Widget e layout — Combobox strumenti
Obiettivo verificabile: Selezionare un’opzione in ttk.
Consegna: Crea una Combobox non modificabile con tre strumenti.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 08 — Combobox strumenti
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
s = tk.StringVar(value="Temperatura")
ttk.Combobox(root, textvariable=s, state="readonly",
values=["Temperatura", "Umidità", "Pressione"]).pack(padx=15, pady=15)
root.mainloop()
Risultato atteso: Si può scegliere una delle tre grandezze.
Errore frequente / verifica: Il widget Combobox appartiene a ttk.
Esercizio 09 · Livello C — Eventi e validazione — Invio equivalente al clic
Obiettivo verificabile: Legare un evento di tastiera.
Consegna: La pressione di Invio o un clic sul pulsante deve aggiornare una Label.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 09 — Invio equivalente al clic
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
s = tk.StringVar(value="Attesa")
tk.Label(root, textvariable=s).pack(pady=10)
def aggiorna():
s.set("Invio ricevuto")
def invio(event):
aggiorna()
tk.Button(root, text="Aggiorna", command=aggiorna).pack(pady=5)
root.bind("<Return>", invio)
root.mainloop()
Risultato atteso: Premendo Invio o cliccando Aggiorna appare “Invio ricevuto”.
Errore frequente / verifica: bind passa un parametro evento.
Esercizio 10 · Livello C — Eventi e validazione — Input numerico
Obiettivo verificabile: Gestire conversioni errate.
Consegna: Accetta un numero e visualizza il suo doppio, oppure un errore.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 10 — Input numerico
# Esegui questo script su un desktop con Tkinter disponibile.
import math
import tkinter as tk
root = tk.Tk()
e = tk.Entry(root)
e.pack()
out = tk.Label(root)
out.pack()
def calcola():
try:
x = float(e.get())
if not math.isfinite(x):
raise ValueError
out.config(text=f"{2*x:g}")
except ValueError:
out.config(text="Errore: numero non valido")
tk.Button(root, text="Doppio", command=calcola).pack()
root.mainloop()
Risultato atteso: Digitando 4 appare 8; digitando abc appare l’errore.
Errore frequente / verifica: Non dimenticare il controllo di NaN/infinito.
Esercizio 11 · Livello C — Eventi e validazione — Checkbutton unità
Obiettivo verificabile: Gestire una BooleanVar.
Consegna: Mostra se la casella “Mostra unità” è attiva.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 11 — Checkbutton unità
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
s = tk.BooleanVar(value=True)
tk.Checkbutton(root, text="Mostra unità", variable=s).pack()
out = tk.Label(root)
out.pack()
def leggi():
out.config(text="Sì" if s.get() else "No")
tk.Button(root, text="Verifica", command=leggi).pack()
root.mainloop()
Risultato atteso: Il risultato riflette lo stato della casella.
Errore frequente / verifica: BooleanVar.get() restituisce un valore logico.
Esercizio 12 · Livello C — Eventi e validazione — Lista campioni
Obiettivo verificabile: Visualizzare una Listbox.
Consegna: Inserisci cinque temperature numerate in una Listbox.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 12 — Lista campioni
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
lista = tk.Listbox(root)
lista.pack(padx=12, pady=12)
for i, v in enumerate((20, 21, 19, 22, 20), start=1):
lista.insert("end", f"{i}: {v} °C")
root.mainloop()
Risultato atteso: La Listbox contiene cinque righe.
Errore frequente / verifica: insert(“end”, …) aggiunge in fondo.
Esercizio 13 · Livello D — Canvas e programmazione a oggetti — Coordinate Canvas
Obiettivo verificabile: Creare figure grafiche.
Consegna: Disegna un rettangolo e un cerchio dentro Canvas.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 13 — Coordinate Canvas
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
c = tk.Canvas(root, width=300, height=180, bg="white")
c.pack()
c.create_rectangle(20, 20, 120, 100, fill="skyblue")
c.create_oval(170, 30, 250, 110, fill="orange")
root.mainloop()
Risultato atteso: Si vedono le due figure in posizioni diverse.
Errore frequente / verifica: Le coordinate sono in pixel e y cresce in basso.
Esercizio 14 · Livello D — Canvas e programmazione a oggetti — Spostamento grafico
Obiettivo verificabile: Aggiornare un oggetto Canvas.
Consegna: Un pulsante deve spostare di 10 px un cerchio verso destra.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 14 — Spostamento grafico
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
c = tk.Canvas(root, width=300, height=140)
c.pack()
id_ = c.create_oval(10, 40, 40, 70, fill="orange")
def sposta():
c.move(id_, 10, 0)
tk.Button(root, text="Sposta", command=sposta).pack()
root.mainloop()
Risultato atteso: Ogni clic muove il cerchio a destra.
Errore frequente / verifica: Conservare l’ID dell’oggetto evita di ricrearlo.
Esercizio 15 · Livello D — Canvas e programmazione a oggetti — Modello temperatura
Obiettivo verificabile: Applicare OOP a un dato fisico.
Consegna: Definisci una classe con il metodo per convertire °C in °F, poi mostralo nella GUI.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 15 — Modello temperatura
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
class Sensore:
def __init__(self, c):
self.c = c
def fahrenheit(self):
return self.c * 9 / 5 + 32
root = tk.Tk()
modello = Sensore(25)
tk.Label(root, text=f"{modello.fahrenheit():.1f} °F").pack(padx=15, pady=15)
root.mainloop()
Risultato atteso: La finestra mostra 77.0 °F.
Errore frequente / verifica: La classe Sensore non dipende dalla GUI.
Esercizio 16 · Livello D — Canvas e programmazione a oggetti — Animazione temporizzata
Obiettivo verificabile: Usare after senza bloccare.
Consegna: Aggiorna un contatore ogni secondo e fermalo con un pulsante.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 16 — Animazione temporizzata
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
n = tk.IntVar(value=0)
job = None
def tick():
global job
n.set(n.get() + 1)
job = root.after(1000, tick)
def stop():
global job
if job is not None:
root.after_cancel(job)
job = None
def chiudi():
stop()
root.destroy()
tk.Label(root, textvariable=n).pack()
tk.Button(root, text="Avvia", command=lambda: tick() if job is None else None).pack()
tk.Button(root, text="Stop", command=stop).pack()
root.protocol("WM_DELETE_WINDOW", chiudi)
root.mainloop()
Risultato atteso: Il numero cresce circa una volta al secondo finché non premi Stop.
Errore frequente / verifica: after non esegue la callback in un thread separato.
Esercizio 17 · Livello E — Applicazioni STEM — Convertitore scientifico
Obiettivo verificabile: Applicare una formula e validare.
Consegna: Trasforma km in metri usando un campo e un pulsante.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 17 — Convertitore scientifico
# Esegui questo script su un desktop con Tkinter disponibile.
import math
import tkinter as tk
root = tk.Tk()
e = tk.Entry(root)
e.pack()
out = tk.Label(root)
out.pack()
def converti():
try:
km = float(e.get())
if not math.isfinite(km):
raise ValueError
out.config(text=f"{km * 1000:.2f} m")
except ValueError:
out.config(text="Valore non valido")
tk.Button(root, text="Converti", command=converti).pack()
root.mainloop()
Risultato atteso: Per 1.5 km compare 1500.00 m.
Errore frequente / verifica: Converti prima il testo in numero.
Esercizio 18 · Livello E — Applicazioni STEM — Sensore di umidità
Obiettivo verificabile: Validare un intervallo fisico.
Consegna: Accetta soltanto valori di umidità tra 0 e 100%.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 18 — Sensore di umidità
# Esegui questo script su un desktop con Tkinter disponibile.
import math
import tkinter as tk
root = tk.Tk()
e = tk.Entry(root)
e.pack()
out = tk.Label(root)
out.pack()
def acquisisci():
try:
u = float(e.get())
if not math.isfinite(u) or not 0 <= u <= 100:
raise ValueError
out.config(text=f"Umidità: {u:.1f}%")
except ValueError:
out.config(text="Intervallo richiesto: 0–100%")
tk.Button(root, text="Acquisisci", command=acquisisci).pack()
root.mainloop()
Risultato atteso: Per 55 compare 55.0%; per 110 compare l’errore.
Errore frequente / verifica: Non confondere errore di conversione e intervallo.
Esercizio 19 · Livello E — Applicazioni STEM — Storico e media
Obiettivo verificabile: Gestire una sequenza di misure.
Consegna: Registra più temperature inserite e mostra la loro media.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 19 — Storico e media
# Esegui questo script su un desktop con Tkinter disponibile.
import math
import tkinter as tk
root = tk.Tk()
dati = []
e = tk.Entry(root)
e.pack()
out = tk.Label(root)
out.pack()
def acquisisci():
try:
x = float(e.get())
if not math.isfinite(x):
raise ValueError
except ValueError:
out.config(text="Numero non valido")
return
dati.append(x)
out.config(text=f"n={len(dati)}; media={sum(dati)/len(dati):.2f} °C")
tk.Button(root, text="Registra", command=acquisisci).pack()
root.mainloop()
Risultato atteso: Dopo 20 e 22 °C la media mostrata è 21.00 °C.
Errore frequente / verifica: Dividere per zero prima della prima acquisizione è un errore.
Esercizio 20 · Livello E — Applicazioni STEM — Cruscotto STEM
Obiettivo verificabile: Tracciare dati su Canvas.
Consegna: Visualizza su Canvas cinque punti di temperatura simulata.
Mostra soluzione commentata
Soluzione completa; i commenti iniziali ne chiariscono lo scopo.
# Esercizio 20 — Cruscotto STEM
# Esegui questo script su un desktop con Tkinter disponibile.
import tkinter as tk
root = tk.Tk()
c = tk.Canvas(root, width=350, height=200, bg="white")
c.pack()
dati = [20, 22, 21, 23, 24]
punti = []
for i, v in enumerate(dati):
punti.extend((25 + 60*i, 170 - 12*(v - 18)))
c.create_line(*punti, fill="blue", width=3)
for i, v in enumerate(dati):
x, y = 25 + 60*i, 170 - 12*(v - 18)
c.create_oval(x-3, y-3, x+3, y+3, fill="orange")
root.mainloop()
Risultato atteso: Cinque punti collegati rappresentano il segnale virtuale.
Errore frequente / verifica: Per un grafico y va trasformata e non copiato direttamente il valore fisico.
Approfondimenti e continuità
Ripassa classi, attributi e metodi nell’articolo B1.08 — Classi e oggetti Python. Il prossimo articolo B1.10 utilizzerà queste competenze nel progetto gestionale integrato.
Documentazione ufficiale: Tkinter, widget ttk, messagebox e filedialog.
Progetto Python ZIP e laboratorio web B1.09: collegamenti in attesa di realizzazione, verifica e pubblicazione effettiva. In questa fase non sono presenti pulsanti di download o URL fittizi.