Interfacce grafiche Python con Tkinter: finestre, widget, sensori virtuali e grafici Canvas in un progetto STEM MEGISTONE.
Python Tkinter: interfacce grafiche, widget, eventi e Canvas per applicazioni scientifiche STEM.

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.

	Infografica sull’architettura di Tkinter con codice Python, finestra radice Tk(), widget Label e Button, ciclo mainloop() e callback saluta().
FIG01 — Schema dell’architettura Tkinter: il codice crea la finestra radice e i widget, mentre mainloop() gestisce eventi e callback. La finestra mostrata rappresenta il risultato dopo il clic sul pulsante.

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”.

Confronto tra pack(), grid() e place() di Python Tkinter, con esempi di disposizione dei widget, finestre grafiche e tabella riepilogativa.
FIG02 — I tre gestori di layout di Tkinter: pack() dispone i widget in sequenza, grid() li organizza in righe e colonne e place() li posiziona mediante coordinate.

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.

Diagramma degli eventi in Python Tkinter: input utente, callback, validazione dei dati e gestione dei risultati o degli errori.
FIG03 — Gestione degli eventi in Tkinter: un clic o la pressione di Invio attiva una callback Python che valida l’input e aggiorna l’interfaccia. Il risultato corretto e il messaggio di errore rappresentano due esiti alternativi.

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.

Trasformazione grafica: ypixel = ybase − scala × (valore − riferimento)

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.

Infografica Python Tkinter con coordinate Canvas, animazione di una pallina tramite after() e grafico STEM dei sensori virtuali.
FIG04 — Canvas permette di disegnare linee, rettangoli e ovali; after() programma aggiornamenti nel ciclo degli eventi, consentendo animazioni e grafici STEM interattivi.

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.

Articoli simili