Python: selezioni, cicli for e while, debugging ed eccezioni con diagramma di flusso e codice Python 3.13.
Selezioni, cicli e debugging in Python: dalle decisioni alle iterazioni, fino alla gestione degli errori.

Obiettivo: imparare a scrivere programmi capaci di prendere decisioni, ripetere operazioni, diagnosticare problemi e gestire input errati, applicando queste competenze a esperimenti scientifici.

Prerequisiti: variabili, operatori, tipi, condizioni booleane, stringhe, input e output del capitolo B1.02.

11.1 — Dal programma sequenziale al controllo del flusso

Un programma sequenziale esegue le istruzioni nell’ordine in cui sono scritte. Nei problemi reali, però, occorre decidere quale percorso seguire oppure quante volte ripetere un’operazione. Le tre strutture fondamentali sono sequenza, selezione e iterazione. In un diagramma di flusso, i rettangoli rappresentano elaborazioni, i rombi condizioni con uscite Vero/Falso e le frecce il verso del controllo.

prezzo = 12
quantita = 3
totale = prezzo * quantita
print(f"Totale: {totale} euro")
Output atteso

Totale: 36 euro

Le quattro istruzioni sono eseguite una volta, in successione. Inserendo una selezione potremo applicare uno sconto; con un ciclo potremo sommare acquisti successivi. Il diagramma dovrà mostrare sempre dove confluiscono i percorsi e dove termina una ripetizione.

11.2 — Blocchi Python e indentazione

In Python l’indentazione è parte della sintassi: le istruzioni allineate allo stesso livello appartengono allo stesso blocco. Il carattere : introduce una suite di istruzioni dopo if, else, while e for. Lo standard pratico è usare quattro spazi per livello, senza mescolare tabulazioni e spazi.

temperatura = 28
if temperatura > 25:
    print("Fa caldo")
    print("Porta dell’acqua")
print("Controllo terminato")
Output atteso

Fa caldo
Porta dell’acqua
Controllo terminato

Le prime due stampe dipendono dalla condizione; l’ultima è all’esterno del blocco, quindi viene sempre eseguita. Eliminare il rientro dalla seconda riga subordinata cambia il comportamento o causa un errore. Un blocco non può essere lasciato vuoto: si può usare temporaneamente pass.

Come riconoscere un errore di indentazione

Un rientro mancante dopo i due punti provoca IndentationError: expected an indented block; un rientro inatteso può invece provocare unexpected indent. Anche se il programma sembra visivamente allineato, mischiare tabulazioni e spazi può causare TabError.

# ESEMPIO INTENZIONALMENTE ERRATO
if 3 > 1:
print("Vero")
# Versione corretta
if 3 > 1:
    print("Vero")
Output corretto

Vero
Selezioni in Python con if, elif ed else: esempio di codice, diagramma di flusso e indentazione dei blocchi a quattro spazi.
Le strutture di selezione if, elif ed else permettono di prendere decisioni in Python. Il diagramma di flusso mostra i percorsi alternativi, mentre l’indentazione identifica i blocchi di istruzioni.

11.3 — Selezione semplice: if

La selezione semplice esegue un blocco solo se la condizione è vera. La condizione viene valutata una volta quando il flusso raggiunge l’if; non è un controllo continuo.

eta = 16
if eta >= 14:
    print("Età sufficiente per questo esempio")
print("Fine")
Output atteso

Età sufficiente per questo esempio
Fine

Caso limite: per eta = 14 il messaggio compare, perché il confronto è >=; per eta = 13 compare soltanto «Fine». Attenzione a non confondere = (assegnazione) con == (uguaglianza).

Controlliamo i valori di confine

Prima di eseguire un confronto, prepariamo una tabella dei casi. Per eta >= 14:

Età Condizione Messaggio condizionale
13 Falso Non compare
14 Vero Compare
15 Vero Compare

Il caso esattamente sul limite è spesso il più importante da testare.

11.4 — Selezione doppia: if / else

Se due percorsi sono alternativi si usa if ... else: esattamente uno dei due blocchi viene eseguito, purché il programma raggiunga l’istruzione.

numero = -5
if numero >= 0:
    print("Non negativo")
else:
    print("Negativo")
Output atteso

Negativo

La scelta include lo zero nel primo ramo. Per esercizio, cambiare il valore in 0 e prevedere l’output. L’else non richiede una nuova condizione: raccoglie tutti i casi non soddisfatti dall’if.

Applicazione: soglia di temperatura

temperatura = 3
if temperatura <= 0:
    print("Possibile gelo")
else:
    print("Temperatura sopra lo zero")
Output atteso

Temperatura sopra lo zero

La verifica sul valore 0 è inclusiva: a 0 °C si sceglie il primo ramo. L’esempio classifica una soglia, non pretende di descrivere tutte le condizioni meteorologiche.

11.5 — Selezione multipla: if / elif / else

Una catena if / elif / else verifica le condizioni dall’alto verso il basso. Quando una condizione è vera, il relativo blocco viene eseguito e i successivi rami della catena vengono saltati. Pertanto l’ordine dei controlli è significativo.

voto = 8
if voto < 0 or voto > 10:
    print("Voto non valido")
elif voto >= 9:
    print("Ottimo")
elif voto >= 6:
    print("Sufficiente")
else:
    print("Insufficiente")
Output atteso

Sufficiente

Se controllassimo voto >= 6 prima di voto >= 9, anche 10 verrebbe classificato come «Sufficiente». L’esclusività è garantita dai rami della stessa catena, non necessariamente dalla natura matematica delle condizioni.

Tabella delle decisioni

Voto Primo ramo soddisfatto Output
−1 Fuori intervallo Voto non valido
5 Ramo finale else Insufficiente
6 voto >= 6 Sufficiente
9 voto >= 9 Ottimo
10 voto >= 9 Ottimo

11.6 — Condizioni composte e selezioni annidate

Le condizioni si combinano con and, or, not. and e or valutano il secondo operando soltanto quando necessario: è la valutazione a corto circuito. Un confronto concatenato, come 0 <= x <= 10, è leggibile e verifica i due limiti.

x = 8
if 0 <= x <= 10 and x % 2 == 0:
    print("Pari nell’intervallo")

password_presente = False
if password_presente and len("segreto") > 5:
    print("Controllo supplementare")
Output atteso

Pari nell’intervallo

Nel secondo if il controllo a destra non viene eseguito perché il primo operando è falso. Un if interno a un altro if è una selezione annidata; un elif è invece un ramo della stessa catena. Annidare è utile quando la seconda decisione ha senso soltanto dopo la prima.

autorizzato = True
età = 16
if autorizzato:
    if età >= 14:
        print("Accesso consentito")
Output atteso

Accesso consentito

Priorità degli operatori e corto circuito

Tra gli operatori booleani esaminati, Python valuta prima not, poi and e infine or. Le parentesi rendono esplicita l’intenzione. Con and, se il primo operando è falso, il secondo non serve; con or, se il primo è vero, il secondo non serve. Attenzione: in Python gli operatori possono restituire un operando, non necessariamente un valore di tipo bool; nelle condizioni, tuttavia, se ne valuta il valore di verità.

denominatore = 0
if denominatore != 0 and 12 / denominatore > 2:
    print("Quoziente maggiore di 2")
else:
    print("Controllo non superato")

x = 4
print((x < 0 or x > 10) and x % 2 == 0)
Output atteso

Controllo non superato
False

La divisione non viene tentata perché il primo confronto dell’and è falso. Se scrivessimo 12 / denominatore > 2 and denominatore != 0, Python tenterebbe invece la divisione per zero. L’ordine conta.

11.7 — Espressioni condizionali

Una breve scelta tra due valori può essere scritta come espressione: valore_se_vero if condizione else valore_se_falso. A differenza di una struttura if completa, serve a produrre un valore e non a racchiudere una sequenza estesa di azioni.

temperatura = 19
stato = "caldo" if temperatura >= 25 else "non caldo"
print(stato)
Output atteso

non caldo

Si preferisce l’istruzione if/else quando le operazioni sono articolate o si rischia di perdere leggibilità. Le espressioni condizionali annidate sono possibili ma spesso sconsigliabili per chi inizia.

Stesso problema, due scritture

voto = 7
if voto >= 6:
    esito = "promosso"
else:
    esito = "da recuperare"

# Equivalente, più conciso:
esito_breve = "promosso" if voto >= 6 else "da recuperare"
print(esito, esito_breve)
Output atteso

promosso promosso

Usa la forma breve quando ciascun ramo produce un valore semplice; per più istruzioni, resta preferibile il blocco tradizionale.

11.8 — Ciclo while: condizione e terminazione

Il ciclo while controlla una condizione prima di ogni iterazione. Se è già falsa all’inizio, il corpo non viene mai eseguito. Un ciclo corretto richiede: inizializzazione, condizione di permanenza, elaborazione, aggiornamento e una ragione per cui alla fine si terminerà.

contatore = 1
somma = 0
while contatore <= 4:
    somma += contatore
    print(contatore, somma)
    contatore += 1
print("Somma finale:", somma)
Output atteso

1 1
2 3
3 6
4 10
Somma finale: 10

Il contatore percorre 1, 2, 3, 4; dopo l’ultimo aggiornamento vale 5 e il controllo diventa falso. La variabile somma è un accumulatore. Alla fine di ogni iterazione vale la somma degli interi già elaborati: questa proprietà è un semplice invariante utile a motivare la correttezza.

Un ciclo che dimentica contatore += 1 potrebbe non terminare. Quando il numero di ripetizioni dipende da un input sentinella, si controlla esplicitamente la richiesta di uscita.

testo = ""
while testo != "fine":
    testo = input("Scrivi fine per terminare: ").strip().lower()
print("Terminato")

Qui l’output dipende dagli input dell’utente; il ciclo può eseguire una o più letture. Evitare di attribuirgli un output fisso senza specificare i dati inseriti.

Ciclo con sentinella e tracciamento

Una sentinella è un valore concordato che interrompe l’acquisizione, senza essere incluso nei calcoli. Il programma seguente somma numeri inseriti dall’utente fino allo zero.

somma = 0
numero = int(input("Numero (0 termina): "))
while numero != 0:
    somma += numero
    numero = int(input("Numero (0 termina): "))
print("Totale:", somma)
Prova con input 3, 4, 0

Totale: 7

In questo esempio introduttivo l’input deve essere un intero valido; la gestione degli errori di conversione viene aggiunta nella sezione 11.14. La sentinella 0 è esclusa dalla somma.

Invariante e terminazione

Un invariante è una proprietà che resta vera a ogni passaggio significativo. Nel primo esempio di while, prima di ogni controllo somma = 1 + ··· + (contatore − 1). Se il contatore aumenta di uno e il limite è 4, dopo un numero finito di passi la condizione diventa falsa. Per un input con sentinella, invece, la terminazione dipende dal fatto che l’utente inserisca effettivamente il valore previsto.

11.9 — Ciclo for e funzione range()

Il for Python itera sugli elementi di un iterabile, non è semplicemente la versione abbreviata del for del linguaggio C. range(start, stop, step) rappresenta una progressione di interi: stop è escluso e step non può essere zero.

for numero in range(2, 7, 2):
    print(numero)
print("Discesa:")
for numero in range(5, 0, -2):
    print(numero)
Output atteso

2
4
6
Discesa:
5
3
1

range(2, 7, 2) comprende 2, 4 e 6 ma non 7; con passo negativo gli estremi devono essere ordinati coerentemente. range(5) produce 0, 1, 2, 3, 4. L’oggetto range non costruisce automaticamente una lista di tutti questi numeri.

totale = 0
for i in range(1, 5):
    totale += i
print(totale)
Output atteso

10

Quando range non produce elementi

for i in range(3, 3):
    print(i)
print("Intervallo vuoto")

for i in range(2, 5, -1):
    print(i)
print("Passo non coerente")
Output atteso

Intervallo vuoto
Passo non coerente

Entrambi i cicli sono eseguiti zero volte: nel primo gli estremi coincidono; nel secondo il passo è negativo ma il limite finale è maggiore del valore iniziale. range(1, 5, 0) provocherebbe invece ValueError.

Cicli while e for in Python: esempi di codice, diagrammi di flusso, funzione range() e controllo delle iterazioni.
Confronto tra i cicli while e for in Python: condizioni di ripetizione, diagrammi di flusso e utilizzo di range() per generare sequenze numeriche con estremo finale escluso.

11.10 — Iterazione su stringhe e cicli annidati

Una stringa è iterabile: il for visita progressivamente i suoi caratteri. I cicli annidati permettono di costruire tabelle o figure; per ogni iterazione esterna viene eseguito tutto il ciclo interno, salvo interruzioni.

for lettera in "MEGI":
    print(lettera)
Output atteso

M
E
G
I
for riga in range(1, 4):
    for colonna in range(1, 4):
        print(riga * colonna, end=" ")
    print()
Output atteso

1 2 3 
2 4 6 
3 6 9

La prima istruzione stampa ciascun carattere su una riga. Nel secondo esempio si ottengono 3 × 3 = 9 prodotti: intuitivamente, raddoppiando entrambi i limiti si quadruplica il numero di calcoli. Questa è una prima osservazione sui costi delle iterazioni, non una trattazione formale della complessità.

Traccia dei cicli annidati

riga colonna Prodotto
1 1 1
1 2 2
1 3 3
2 1 2
2 2 4
2 3 6
3 1 3
3 2 6
3 3 9

11.11 — Controllo dei cicli: break, continue, pass, else

break interrompe immediatamente il ciclo più interno; il flusso prosegue dopo quel ciclo. continue salta le istruzioni rimanenti dell’iterazione corrente e passa alla prossima iterazione (nel while, prima si rivaluta la condizione). pass non fa nulla: è un’istruzione segnaposto.

for n in range(1, 6):
    if n == 2:
        continue
    if n == 4:
        break
    print(n)
Output atteso

1
3

Per n=2 la stampa viene saltata; per n=4 il ciclo termina e 5 non viene visitato. Nel while bisogna aggiornare le variabili prima di un eventuale continue, per evitare cicli infiniti.

for numero in range(2, 5):
    if numero == 7:
        break
else:
    print("Nessuna interruzione")
Output atteso

Nessuna interruzione

L’else di un ciclo viene eseguito se il ciclo termina senza break, anche quando non vi sono iterazioni. Non è il ramo falso di un normale if. Un’eccezione non gestita o un return dalla funzione impediscono a quel ciclo di raggiungere normalmente il proprio else.

if False:
    pass
print("Il programma prosegue")
Output atteso

Il programma prosegue

Un ciclo per ogni comando

Istruzione Effetto immediato Passo successivo
break Abbandona il ciclo più interno Prima istruzione dopo il ciclo
continue Salta il resto del corpo Nuova iterazione (controllo nel while)
pass Non esegue operazioni Istruzione seguente
else del ciclo Si attiva solo se manca break Alla conclusione normale del ciclo

Attenzione a continue nel while

i = 0
while i < 4:
    i += 1        # Aggiornamento prima del continue
    if i == 2:
        continue
    print(i)
Output atteso

1
3
4

Se spostassimo i += 1 dopo il continue, quando i diventasse 2 il ciclo rimarrebbe bloccato nello stesso stato.

11.12 — Tracciamento dell’esecuzione

Tracciare significa annotare lo stato delle variabili dopo ciascuna istruzione significativa, specificando quando una condizione è vera o falsa. La tabella deve essere coerente con il flusso effettivo, compreso l’ultimo controllo che fa terminare il ciclo.

x = 1
s = 0
while x < 4:
    s += x
    x += 1
print(s)
Output atteso

6
Controllo x prima x < 4 s dopo somma x dopo aggiornamento
1 1 Vero 1 2
2 2 Vero 3 3
3 3 Vero 6 4
4 4 Falso — —

L’ultimo controllo con x=4 è essenziale: chiarisce perché il ciclo si ferma. L’output 6 è prodotto solo dopo la conclusione del ciclo. Per il debugging si possono inserire temporaneamente stampe diagnostiche dei valori.

Traccia con due variabili e una decisione

pari = 0
somma = 0
for n in range(1, 5):
    if n % 2 == 0:
        pari += 1
    somma += n
print(pari, somma)
Output atteso

2 10
n n pari? pari dopo if somma dopo incremento
1 No 0 1
2 Sì 1 3
3 No 1 6
4 Sì 2 10

11.13 — Debugging e classificazione degli errori

Un errore di sintassi impedisce l’interpretazione del programma; un’eccezione in esecuzione interrompe normalmente il flusso se non viene gestita; un errore logico produce risultati inattesi senza necessariamente sollevare eccezioni; un errore numerico deriva per esempio dai limiti della rappresentazione in virgola mobile o dall’approssimazione di un modello.

# Errore intenzionale di sintassi (NON eseguire così):
# if x > 0
#     print(x)

# Correzione:
x = 3
if x > 0:
    print(x)
Output atteso

3
# Esempio di errore logico:
prezzo = 10
sconto = 20
risultato_errato = prezzo - sconto
risultato_corretto = prezzo * (1 - sconto / 100)
print(risultato_errato, risultato_corretto)
Output atteso

-10 8.0

In caso di eccezione, il traceback mostra il percorso delle chiamate e la riga del problema; leggerne il tipo e il messaggio è fondamentale. Con IDLE è possibile usare il debugger e avanzare passo per passo; in Visual Studio Code si impostano breakpoint, si avvia il debug e si osservano le variabili. Un test deve includere casi ordinari, estremi e input errati: l’assenza di eccezioni non dimostra la correttezza.

print(0.1 + 0.2 == 0.3)
Output atteso

False

L’ultimo esempio evidenzia l’approssimazione dei numeri float. Per confronti numerici approssimati si può usare math.isclose, che sarà richiamata quando si studieranno i moduli.

Debugging guidato: riprodurre, isolare, correggere

  1. Riproduci: annota input, output ottenuto e output atteso.
  2. Isola: individua la prima riga in cui lo stato devia dalle aspettative.
  3. Osserva: inserisci una stampa temporanea oppure un breakpoint.
  4. Correggi: modifica la causa, non nascondere soltanto il sintomo.
  5. Riprova: esegui il caso iniziale e almeno un caso limite.

IDLE: salva il file .py, apri Debug → Debugger nella Shell, quindi esegui lo script con F5; usa Step e osserva lo stato delle variabili. VS Code: apri il file con l’estensione Python configurata, clicca a sinistra del numero di riga per impostare un breakpoint, avvia Run and Debug (F5), quindi usa Step Over e il pannello delle variabili. Le etichette possono variare leggermente tra versioni.

Tre famiglie di test

Tipo Esempio Che cosa verifica
Ordinario voto = 7 Percorso usuale
Limite voto = 6 oppure 10 Estremi e inclusività
Errato input non numerico Gestione delle eccezioni

11.14 — Eccezioni, input e gestione consapevole degli errori

La validazione preventiva controlla condizioni prevedibili; try/except intercetta errori durante l’esecuzione; raise permette di segnalare intenzionalmente un valore non ammissibile. Queste tecniche sono complementari e non equivalenti. Specificare sempre i tipi di eccezione pertinenti; evitare except: generico.

testo = "12"
try:
    numero = int(testo)
except ValueError:
    print("Non è un intero")
else:
    print("Numero valido:", numero)
finally:
    print("Controllo concluso")
Output atteso

Numero valido: 12
Controllo concluso

Il blocco else del try viene eseguito solo se il blocco try termina senza eccezione; finally viene normalmente eseguito durante l’uscita dalla struttura, anche se si verifica un’eccezione, prima di propagarla. Non va considerato un meccanismo che cancella qualsiasi errore.

valore = -2
try:
    if valore < 0:
        raise ValueError("La misura non può essere negativa")
    print("Misura:", valore)
except ValueError as errore:
    print("Errore:", errore)
Output atteso

Errore: La misura non può essere negativa

ValueError riguarda valori non appropriati per un’operazione; TypeError tipi incompatibili; ZeroDivisionError divisione per zero; IndexError accesso fuori dagli indici validi di una sequenza. Gli esempi seguenti sono volutamente difettosi e servono a riconoscere le eccezioni.

# ESEMPI INTENZIONALMENTE ERRATI: da provare separatamente
# int("ciao")         # ValueError
# "3" + 2             # TypeError
# 4 / 0               # ZeroDivisionError
# "ciao"[8]           # IndexError

Un input robusto può ripetere la richiesta fino a ricevere un numero valido. Qui la ripetizione e la gestione dell’eccezione collaborano:

while True:
    try:
        eta = int(input("Età (0–120): "))
        if not 0 <= eta <= 120:
            raise ValueError("Età fuori intervallo")
        break
    except ValueError as errore:
        print("Riprova:", errore)
print("Età valida:", eta)

L’output varia secondo gli input. Se lo studente inserisce prima abc e poi 16, il programma mostra un messaggio di riprova e infine Età valida: 16.

Quale except viene scelto?

Quando nel blocco try si verifica un’eccezione, Python cerca una clausola except compatibile nell’ordine scritto. Se la trova, esegue quel gestore. Se non la trova, l’eccezione viene propagata. L’else viene eseguito soltanto quando il try termina normalmente; finally si presta soprattutto alle operazioni di pulizia.

testo = "0"
try:
    denominatore = int(testo)
    risultato = 12 / denominatore
except ValueError:
    print("Inserisci un intero")
except ZeroDivisionError:
    print("Non puoi dividere per zero")
else:
    print("Risultato:", risultato)
finally:
    print("Operazione conclusa")
Output atteso

Non puoi dividere per zero
Operazione conclusa

Se testo fosse "4", verrebbero stampati Risultato: 3.0 e Operazione conclusa; se fosse "ciao", verrebbe eseguito il gestore ValueError. Evita except: pass: potrebbe occultare problemi importanti.

Gestione e prevenzione non coincidono

Prima di una divisione puoi verificare denominatore != 0; se l’input viene convertito con int(), puoi intercettare ValueError; se una misura viola una regola del problema, puoi segnalare il difetto con raise ValueError(...). Sono tre strategie distinte, utili in punti differenti del programma.

Debugging ed eccezioni in Python: errori di sintassi e logici, traceback, controllo preventivo e gestione con try, except, else e finally.
Il debugging permette di individuare e correggere gli errori nei programmi Python. Il controllo preventivo e i blocchi try, except, else e finally consentono di affrontare condizioni anomale e gestire le eccezioni.

11.15 — Progetto STEM — MEGI: simulatore di esperimenti iterativi

Il progetto integra i costrutti studiati in tre esperimenti a menu, eseguibili dal terminale con Python 3.13. Il codice completo è fornito come file .py autonomo: non richiede installazioni di librerie e non utilizza Tkinter. Le tre simulazioni assumono condizioni ideali, da confrontare con dati reali soltanto dopo aver discusso le ipotesi del modello.

Esperimento A — Moto uniformemente accelerato

v(t) = v0 + at    |    s(t) = s0 + v0t + ½at2

Si assume moto rettilineo e accelerazione costante. Gli input sono velocità iniziale in m/s, accelerazione in m/s², posizione iniziale in m, durata e passo in secondi. Il programma calcola i valori direttamente dall’istante assoluto; l’ultima riga corrisponde alla durata anche se non è multipla del passo.

t (s) v (m/s) s (m)
0.00 0.00 0.00
1.00 2.00 1.00
2.00 4.00 4.00

Caso di prova: v0=0, a=2, s0=0, durata=2, passo=1. Sono soddisfatte le relazioni analitiche senza errore di integrazione temporale.

Esperimento B — Raffreddamento di Newton

Tn+1 = Tn − k(Tn − Tamb)Δt

Il corpo scambia calore con un ambiente a temperatura costante. k è misurato in s⁻¹, il passo Δt in secondi. Si utilizza il metodo di Eulero esplicito: l’esito è approssimato e dipende dal passo. Il controllo 0 < kΔt ≤ 1 evita, in questo modello, il superamento artificiale della temperatura ambiente quando le condizioni iniziali sono ordinarie; passi più piccoli possono comunque essere necessari per una buona accuratezza.

t (s) T (°C)
0.00 80.00
1.00 74.00
2.00 68.60

Prova: T0=80 °C, Tamb=20 °C, k=0.1 s⁻¹, durata=2 s, passo=1 s. Si ottiene 74 °C dopo un secondo e 68,6 °C dopo due secondi.

Esperimento C — Consumo e risparmio energetico

E = P × t    |    1 Wh = 3 600 J    |    1 kWh = 1 000 Wh

Con potenza costante P espressa in watt e tempo t in ore, E è in wattora. Due scenari sono confrontati alla stessa durata. I watt sono unità di potenza, mentre J, Wh e kWh sono unità di energia. Una differenza negativa nel risparmio indica che il secondo scenario consuma di più.

Tempo (h) Scenario 1 (Wh) Scenario 2 (Wh) Risparmio (Wh)
0 0 0 0
1 100 60 40
2 200 120 80

Prova: P1=100 W, P2=60 W, durata=2 h, passo=1 h: 200 Wh contro 120 Wh, differenza 80 Wh = 0,080 kWh = 288 000 J.

Simulatore STEM Python con moto uniformemente accelerato, raffreddamento di Newton, risparmio energetico, formule, grafici e tabelle.
Il simulatore STEM MEGI utilizza i cicli Python per studiare tre applicazioni scientifiche: moto uniformemente accelerato, raffreddamento di Newton con metodo di Eulero e confronto dei consumi energetici.

Utilizzo: scarica il file Python allegato a questa consegna, aprilo con IDLE o VS Code, eseguilo, scegli A/B/C, inserisci i valori richiesti e premi Q per uscire. La validazione ripete gli input errati; durata e passo devono essere positivi; il numero di intervalli è limitato a 500 per mantenere il programma utilizzabile.

Materiale per lo studente:
scarica il progetto
MEGI — Simulatore di esperimenti iterativi
utilizzando il pulsante seguente.

Estrai dall’archivio ZIP il file
MEGI_Simulatore_Esperimenti_Iterativi.py,
aprilo con IDLE o
Visual Studio Code
ed eseguilo sul tuo computer.

Il programma comprende tre esperimenti:
moto uniformemente accelerato,
raffreddamento di Newton e risparmio energetico.

🐍 SCARICA IL PROGRAMMA PYTHON

MEGI — Simulatore di esperimenti iterativi

Archivio ZIP con programma Python 3.13

⚡ APRI IL LABORATORIO STEM — PYTHON

MEGISTONE STEM LAB — Selezioni, cicli e debugging

Test di collaudo aggiuntivi

Scenario Prova Risultato atteso
Durata non multipla Moto: 2,5 s, passo 1 s Ultimo istante 2,5 s, non 3 s
Valore non numerico Inserisci abc dove è richiesto un numero Messaggio e nuova richiesta
Raffreddamento instabile k=2 e dt=1 Rifiuto della simulazione (kΔt > 1)
Scenario meno efficiente P1=40 W, P2=70 W Risparmio negativo

Le prove di input non dimostrano che il modello rappresenti ogni esperimento fisico reale: servono a validare il comportamento del software entro le ipotesi dichiarate.

11.16 — Allenati con MEGI — 20 esercizi progressivi

Gli esercizi sono suddivisi in cinque livelli, quattro quesiti per livello. Ogni soluzione è nascosta all’apertura della pagina: provare prima a risolvere il problema, poi aprire la verifica individuale. Gli esempi di codice multilinea sono presentati in forma compatta nelle risposte; è consigliato riscriverli nell’editor per eseguirli.

Esercizio 01 · Livello A — Individuare il blocco

Obiettivo: Confrontare il rientro delle righe.

Traccia: In if x > 0: quali istruzioni appartengono al ramo?

Mostra soluzione e spiegazione

Soluzione: Le istruzioni consecutive con un livello di indentazione maggiore di quello dell’if appartengono al blocco, fino alla prima dedentazione.

Procedimento: L’indentazione, non l’aspetto grafico arbitrario, determina l’appartenenza.

Esercizio 02 · Livello A — Confronto inclusivo

Obiettivo: Distinguere ≥ da >.

Traccia: Indicare se n >= 5 vale per n=5.

Mostra soluzione e spiegazione

Soluzione: È vero.

Procedimento: Il confronto include il limite inferiore.

Esercizio 03 · Livello A — Estremo di range

Obiettivo: Ricordare l’estremo escluso.

Traccia: Indicare i valori prodotti da range(3).

Mostra soluzione e spiegazione

Soluzione: 0, 1, 2.

Procedimento: range(3) parte da 0 ed esclude 3.

Esercizio 04 · Livello A — Ciclo con else

Obiettivo: Distinguere da if/else.

Traccia: Quando viene eseguito l’else associato a un for?

Mostra soluzione e spiegazione

Soluzione: Quando il ciclo termina senza break.

Procedimento: Si esegue anche se il ciclo non compie iterazioni.

Esercizio 05 · Livello B — Traccia di if

Obiettivo: Calcolare il resto.

Traccia: Prevedere il risultato: x=7; print("A" if x%2 else "B").

Mostra soluzione e spiegazione

Soluzione: A.

Procedimento: Il resto 1 è truthy: l’espressione seleziona «A».

Esercizio 06 · Livello B — Somma iterativa

Obiettivo: Tracciare i=1,2,3.

Traccia: Dopo aver impostato s=0, un ciclo for i in range(1,4) esegue s += i; al termine viene eseguito print(s). Prevedere l’output.

Mostra soluzione e spiegazione

Soluzione: 6.

Procedimento: Somma 1+2+3 = 6.

Esercizio 07 · Livello B — While e stato

Obiettivo: Registrare gli aggiornamenti.

Traccia: Dati x=1 e while x<8: x*=2, quale valore finale assume x?

Mostra soluzione e spiegazione

Soluzione: 8.

Procedimento: La sequenza è 1 → 2 → 4 → 8; a 8 il controllo è falso.

Esercizio 08 · Livello B — Continue e break

Obiettivo: Stampare i dopo gli if.

Traccia: In for i in range(5), salta i=2 con continue e interrompi a i=4 con break. Cosa viene stampato?

Mostra soluzione e spiegazione

Soluzione: 0, 1, 3 (su righe separate).

Procedimento: 2 è saltato e 4 interrompe il ciclo.

Esercizio 09 · Livello C — Due punti mancanti

Obiettivo: Ricostruire la struttura del blocco.

Traccia: Correggere if x > 0 print(x).

Mostra soluzione e spiegazione

Soluzione: if x > 0:
    print(x)

Procedimento: Il corpo deve essere su riga opportunamente indentata e l’intestazione deve terminare con due punti.

Esercizio 10 · Livello C — Ciclo infinito

Obiettivo: Garantire un aggiornamento.

Traccia: Correggere x=1; while x<5: print(x) con corpo indentato, per renderlo terminante.

Mostra soluzione e spiegazione

Soluzione: Aggiungere x += 1 dentro il blocco while.

Procedimento: I valori stampati diventano 1,2,3,4.

Esercizio 11 · Livello C — Ordine degli elif

Obiettivo: Controllare il primo ramo vero.

Traccia: Un programma verifica voto>=6 prima di voto>=9. Perché 10 non viene classificato «ottimo»?

Mostra soluzione e spiegazione

Soluzione: Perché 10 soddisfa già voto>=6 e i rami successivi vengono ignorati.

Procedimento: Invertire l’ordine: prima il controllo più restrittivo.

Esercizio 12 · Livello C — Divisione non sicura

Obiettivo: Confrontare controllo preventivo ed eccezione.

Traccia: Correggere una divisione a/b quando b può essere zero.

Mostra soluzione e spiegazione

Soluzione: if b != 0: print(a/b)
else: print("Denominatore nullo")

Procedimento: Il test evita ZeroDivisionError per denominatore nullo.

Esercizio 13 · Livello D — Pari o dispari

Obiettivo: Applicare l’operatore modulo.

Traccia: Scrivi un programma che chieda un intero, ne determini la parità e stampi un messaggio. Verifica con 8 e 9.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

n = int(input("Inserisci un intero: "))
if n % 2 == 0:
    print("pari")
else:
    print("dispari")

Verifica e spiegazione: Con 8 stampa «pari»; con 9 stampa «dispari». Il resto modulo 2 vale zero per tutti gli interi pari, anche negativi.

Esercizio 14 · Livello D — Conta le vocali

Obiettivo: Iterare sui caratteri.

Traccia: Scrivi un programma che chieda una parola e conti le vocali, senza distinguere maiuscole e minuscole. Provalo con MEGISTONE.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

parola = input("Parola: ").upper()
conteggio = 0
for carattere in parola:
    if carattere in "AEIOU":
        conteggio += 1
print("Vocali:", conteggio)

Verifica e spiegazione: Con MEGISTONE ottieni 4. Ogni carattere viene visitato una volta; per il conteggio consideriamo le vocali A, E, I, O, U non accentate.

Esercizio 15 · Livello D — Prodotto iterativo

Obiettivo: Usare accumulatore moltiplicativo.

Traccia: Scrivi un programma che chieda un intero n ≥ 0 e calcoli n! usando for; gestisci valori negativi. Verifica con 0 e 5.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

n = int(input("n (non negativo): "))
if n < 0:
    print("n deve essere non negativo")
else:
    prodotto = 1
    for i in range(1, n + 1):
        prodotto *= i
    print("Fattoriale:", prodotto)

Verifica e spiegazione: Con 0 stampa 1; con 5 stampa 120. Inizializzare a 1 consente di gestire correttamente anche un prodotto senza fattori.

Esercizio 16 · Livello D — Validazione numerica

Obiettivo: Combinare while e try.

Traccia: Chiedi un intero strettamente positivo finché non viene fornito un input valido. Gestisci lettere, zero e valori negativi con messaggi comprensibili.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

while True:
    try:
        n = int(input("Intero positivo: "))
        if n <= 0:
            print("Serve un valore maggiore di zero")
            continue
        break
    except ValueError:
        print("Inserisci un numero intero")
print("Valore accettato:", n)

Verifica e spiegazione: Con input abc, 0, 3 il programma segnala due errori e termina con «Valore accettato: 3». Il break scatta solo dopo una conversione riuscita e il controllo di positività.

Esercizio 17 · Livello E — Moto accelerato

Obiettivo: Usare le leggi cinematiche.

Traccia: Scrivi un programma che stampi una tabella per t = 0, 1, 2, 3 s di velocità e posizione, partendo da v0 = 2 m/s, a = 3 m/s² e s0 = 0 m.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

v0 = 2.0
accelerazione = 3.0
s0 = 0.0
for t in range(4):
    v = v0 + accelerazione * t
    s = s0 + v0 * t + 0.5 * accelerazione * t ** 2
    print(f"{t} s: v={v:.2f} m/s, s={s:.2f} m")

Verifica e spiegazione: Per t = 0, 1, 2, 3 s si ottengono v = 2, 5, 8, 11 m/s e s = 0, 3,5, 10, 19,5 m. Il ciclo calcola ogni riga dalla legge analitica a accelerazione costante.

Esercizio 18 · Livello E — Raffreddamento discreto

Obiettivo: Applicare un passo di Eulero.

Traccia: Simula tre passi da 1 s di raffreddamento: T0 = 50 °C, Tamb = 20 °C, k = 0,2 s⁻¹. Usa un ciclo e stampa ogni temperatura.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

temperatura = 50.0
ambiente = 20.0
k = 0.2
dt = 1.0
print(f"t=0 s: {temperatura:.2f} °C")
for passo in range(1, 4):
    temperatura -= k * (temperatura - ambiente) * dt
    print(f"t={passo} s: {temperatura:.2f} °C")

Verifica e spiegazione: Le temperature risultano 50,00; 44,00; 39,20; 35,36 °C. La formula è un’approssimazione discreta: qui kΔt = 0,2 è compreso tra 0 e 1.

Esercizio 19 · Livello E — Energia di un dispositivo

Obiettivo: Convertire le unità.

Traccia: Un dispositivo da 200 W funziona per 3 ore. Scrivi un ciclo che produca una tabella ogni ora in Wh, kWh e J; confronta il dato finale.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

potenza = 200.0
for ore in range(4):
    wh = potenza * ore
    kwh = wh / 1000
    joule = wh * 3600
    print(f"{ore} h: {wh:.0f} Wh, {kwh:.3f} kWh, {joule:.0f} J")

Verifica e spiegazione: Dopo 3 ore: 600 Wh = 0,600 kWh = 2 160 000 J. La conversione è coerente perché 1 Wh = 3 600 J.

Esercizio 20 · Livello E — Confronto energetico

Obiettivo: Sottrarre le energie.

Traccia: Confronta con un ciclo i consumi di due dispositivi da 80 W e 50 W durante 4 ore. Stampa il risparmio progressivo e quello finale in Wh e kWh.

Mostra soluzione e spiegazione

Programma completo (Python 3.13):

p1, p2 = 80.0, 50.0
for ore in range(5):
    risparmio_wh = (p1 - p2) * ore
    print(f"{ore} h: risparmio {risparmio_wh:.0f} Wh")
print(f"Risparmio finale: {(p1 - p2) * 4 / 1000:.3f} kWh")

Verifica e spiegazione: La tabella mostra 0, 30, 60, 90 e 120 Wh: il risparmio finale è 0,120 kWh = 432 000 J. Il confronto ha senso perché le due potenze sono riferite alla stessa durata.

Articoli simili