
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")
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")
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")
Vero

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")
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")
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")
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")
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")
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")
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)
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)
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)
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)
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)
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)
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)
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")
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.

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)
M E G I
for riga in range(1, 4):
for colonna in range(1, 4):
print(riga * colonna, end=" ")
print()
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)
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")
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")
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)
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)
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)
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)
3
# Esempio di errore logico:
prezzo = 10
sconto = 20
risultato_errato = prezzo - sconto
risultato_corretto = prezzo * (1 - sconto / 100)
print(risultato_errato, risultato_corretto)
-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)
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
- Riproduci: annota input, output ottenuto e output atteso.
- Isola: individua la prima riga in cui lo stato devia dalle aspettative.
- Osserva: inserisci una stampa temporanea oppure un breakpoint.
- Correggi: modifica la causa, non nascondere soltanto il sintomo.
- 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")
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)
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")
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.

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

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.
MEGI — Simulatore di esperimenti iterativi
Archivio ZIP con programma Python 3.13
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.
Riepilogo e competenze raggiunte
Le selezioni decidono quali blocchi eseguire, i cicli ripetono azioni, le tabelle di traccia descrivono l’evoluzione dei valori e il debugging permette di individuare difetti. Le eccezioni vanno gestite in modo mirato, senza confondere esecuzione riuscita e correttezza del risultato. Lo studente sa ora progettare un algoritmo con controllo del flusso, motivarne la terminazione, affrontare casi limite e verificare semplici modelli STEM.
Errori frequenti da evitare
- Indentare arbitrariamente o dimenticare i due punti.
- Invertire l’ordine di condizioni sovrapposte.
- Confondere
=e==. - Omettere gli aggiornamenti nei cicli
while. - Considerare incluso l’estremo finale di
range(). - Interpretare
elsedei cicli come quello diif. - Mascherare gli errori con
except:generico. - Trascurare unità, limiti del modello e arrotondamento dei
float.
Fonti e approfondimenti
- Python 3.13 — More Control Flow Tools.
- Python 3.13 — Errors and Exceptions.
- Python — funzioni integrate e range().
- Indicazioni nazionali — Informatica, Scienze Applicate.
Prossima unità B1.04: funzioni, parametri, moduli, scope, lambda e ricorsione. Il collegamento sarà inserito soltanto quando l’articolo sarà realmente pubblicato.