
Python: funzioni, parametri, moduli, scope, lambda e ricorsione. Capitolo completo con laboratorio scientifico scaricabile e venti esercizi.
Obiettivo del capitolo. Imparare a progettare funzioni Python riutilizzabili, gestire argomenti e variabili, organizzare moduli, interpretare funzioni lambda e costruire algoritmi ricorsivi verificabili. Riferimento: Python 3.13; classe seconda, Liceo Scientifico – Scienze Applicate. Prerequisiti: variabili, tipi, input/output, condizioni, cicli, debugging ed eccezioni, già trattati in B1.02–B1.03.
12.1 — Perché utilizzare le funzioni
Un algoritmo complesso diventa più comprensibile se viene decomposto in sottoproblemi. Per esempio, per simulare un esperimento di fisica si possono isolare il calcolo della posizione, quello della velocità e la presentazione dei risultati. A ciascuna operazione si assegna una funzione con uno scopo definito. Una funzione incapsula istruzioni che possono essere richiamate più volte, con dati diversi, senza duplicarle. I vantaggi sono riuso, leggibilità, testabilità e manutenzione; non è invece corretto presumere che le funzioni rendano automaticamente più veloce un programma.
Nel progettare una funzione chiediamoci: quali dati riceve (input)? Quale risultato restituisce (output)? Quali condizioni devono essere soddisfatte (precondizioni)? Che cosa garantisce al termine (postcondizioni)? L’interfaccia di una funzione dovrebbe essere semplice e il suo nome descrittivo. Per esempio, area_rettangolo è più chiaro di calcolo1.
Esempio — evitare ripetizioni. Obiettivo: calcolare la superficie di due rettangoli con la stessa regola.
# Una sola definizione riutilizzata
def area_rettangolo(base, altezza):
return base * altezza
print(area_rettangolo(3, 4))
print(area_rettangolo(2.5, 2))
12
5.0
La prima chiamata usa interi, la seconda anche un numero decimale. La funzione contiene la formula una sola volta. Un controllo delle dimensioni fisiche non compare ancora in questa versione introduttiva: lo aggiungeremo nel progetto STEM.

12.2 — Definire e chiamare una funzione con def
La parola chiave def crea una funzione associata a un nome. Dopo def si scrivono nome, parentesi con eventuali parametri, due punti e un blocco indentato (quattro spazi per livello). Definire non significa eseguire: il corpo viene eseguito quando si chiama la funzione. La chiamata si effettua scrivendo il nome con le parentesi e gli argomenti necessari.
def saluta(nome):
"""Mostra un saluto per il nome indicato."""
print(f"Ciao, {nome}!")
print("Prima")
saluta("Ada")
print("Dopo")
Prima
Ciao, Ada!
Dopo
Il programma procede fino alla chiamata, entra nel corpo della funzione, lo esegue e torna all’istruzione successiva. L’indentazione delimita il corpo. Una funzione può chiamarne un’altra; se una definizione viene eseguita solo dopo la chiamata, il nome non è ancora disponibile e si ottiene NameError.
12.3 — Parametri, argomenti e passaggio degli oggetti
I parametri formali sono i nomi presenti nella definizione; gli argomenti effettivi sono le espressioni fornite nella chiamata. Nella chiamata potenza(2, 3), i valori 2 e 3 vengono associati ai parametri base ed esponente. Python passa alle funzioni riferimenti agli oggetti: i nomi locali della funzione vengono associati agli oggetti ricevuti. Non si tratta né di un’indiscriminata copia dell’oggetto né del passaggio di una variabile modificabile del chiamante.
def potenza(base, esponente):
return base ** esponente
print(potenza(2, 3))
print(potenza(5, 0))
8
1
Un parametro può essere riassegnato senza cambiare il nome della variabile del chiamante. Tuttavia, se l’oggetto ricevuto è mutabile (come una lista), un’operazione che lo modifica in place è osservabile anche dal chiamante. Approfondiremo tale distinzione al §12.8. L’espressione utilizzata come argomento viene valutata prima che la funzione esegua il proprio corpo.
12.4 — return, print() e restituzione dei risultati
print() produce un effetto visibile a schermo; return restituisce il valore al punto di chiamata e termina immediatamente l’esecuzione della funzione. Separare elaborazione e visualizzazione consente di riutilizzare il risultato in altre formule, nei test e nelle applicazioni. In assenza di return esplicito, una funzione restituisce l’oggetto speciale None; anche un return senza espressione restituisce None.
def doppio_valore(x):
return 2 * x
def doppio_schermo(x):
print(2 * x)
risultato = doppio_valore(6)
print(risultato + 1)
risultato2 = doppio_schermo(6)
print(risultato2 is None)
13
12
True
La prima funzione produce il valore 12, poi l’espressione esterna calcola 13. La seconda stampa 12 durante la chiamata, ma non restituisce quel numero. Attenzione: None non equivale a zero. Quando vogliamo restituire due risultati possiamo usare return a, b: Python costruisce una tupla, che possiamo assegnare con x, y = funzione().
def quoziente_resto(a, b):
if b == 0:
raise ValueError("Divisore nullo")
return a // b, a % b
q, r = quoziente_resto(17, 5)
print(q, r)
3 2
La divisione per zero viene impedita con un errore esplicito. Per numeri negativi, // applica la divisione con arrotondamento verso meno infinito; non va confusa con il troncamento verso zero.
12.5 — Argomenti posizionali, per nome e valori predefiniti
Gli argomenti posizionali vengono associati secondo l’ordine della definizione, mentre quelli per nome specificano il parametro cui assegnare il valore. I valori predefiniti rendono alcuni argomenti facoltativi. Nei parametri ordinari, quelli senza valore predefinito precedono quelli con un default. Il valore predefinito viene valutato quando la def è eseguita, non a ogni chiamata.
def prezzo_finale(prezzo, sconto=0, iva=0.22):
if prezzo < 0 or not 0 <= sconto <= 1 or iva < 0:
raise ValueError("Parametri non validi")
return prezzo * (1 - sconto) * (1 + iva)
print(f"{prezzo_finale(100):.2f}")
print(f"{prezzo_finale(100, iva=0.10, sconto=0.20):.2f}")
122.00
88.00
L’ordine degli argomenti per nome non cambia la corrispondenza. In una chiamata normale, un argomento posizionale non può seguire un argomento per nome. La sintassi / permette di dichiarare parametri solo posizionali e * parametri solo per nome: per la classe seconda è sufficiente riconoscerla quando si legge la documentazione.
def scala(valore, /, *, fattore=1):
return valore * fattore
print(scala(4, fattore=3))
12
12.6 — Parametri variabili *args e **kwargs
Quando il numero di argomenti non è noto in anticipo, *args raccoglie gli ulteriori argomenti posizionali in una tupla; **kwargs raccoglie gli argomenti per nome non già assegnati in un dizionario. I nomi args e kwargs sono convenzioni, mentre gli asterischi sono parte della sintassi. Questi meccanismi sono utili ma non vanno utilizzati per nascondere un’interfaccia mal progettata.
def somma_misure(*misure):
return sum(misure)
def descrivi(**dati):
return ", ".join(f"{k}={v}" for k, v in dati.items())
print(somma_misure(1, 2, 3, 4))
print(descrivi(unita="m", campione=3))
10
unita=m, campione=3
sum e il metodo join provengono dagli strumenti standard del linguaggio. La comprensione usata nel secondo esempio è una forma compatta di iterazione: basta comprenderne l’effetto, senza anticipare l’intero capitolo sulle strutture dati. Con f(*sequenza) e f(**mappatura) è possibile anche espandere argomenti al momento della chiamata. Evitare di confondere la raccolta nella definizione con l’espansione nella chiamata.

12.7 — Scope: locali, globali, enclosing e regola LEGB
Lo scope indica l’ambito nel quale un nome viene cercato. Python segue, in modo semplificato, la regola LEGB: Local (funzione corrente), Enclosing (funzioni che la racchiudono), Global (modulo), Built-in (nomi predefiniti del linguaggio). La ricerca di un nome non equivale a modificarlo: all’interno di una funzione un’assegnazione rende normalmente quel nome locale, salvo dichiarazioni specifiche.
x = 10
def esempio():
x = 3
print("locale:", x)
esempio()
print("globale:", x)
locale: 3
globale: 10
La variabile locale x oscura (shadowing) il nome globale. I nomi locali normali cessano di essere direttamente accessibili dopo la chiamata, ma eventuali oggetti possono continuare a vivere se riferiti altrove (per esempio da una funzione interna restituita).
def contatore():
numero = 0
def aumenta():
nonlocal numero
numero += 1
return numero
return aumenta
c = contatore()
print(c())
print(c())
1
2
nonlocal permette l’assegnazione a un nome nello scope di una funzione esterna. global consente l’assegnazione al nome di modulo: va usato con parsimonia, perché aumenta le dipendenze fra parti del programma. Un tipico errore è il seguente:
# ESEMPIO INTENZIONALMENTE ERRATO: genera UnboundLocalError
x = 5
def errore():
print(x)
x = 7
# errore() # Non eseguire qui: x è considerata locale
La presenza di x = 7 fa sì che Python interpreti x come locale nell’intero corpo, perciò la lettura precedente all’assegnazione fallisce. Meglio passare il valore come argomento e restituire quello aggiornato. Anche chiamare una variabile sum, list o print oscura nomi built-in e può generare problemi successivi.
12.8 — Oggetti mutabili, immutabili ed effetti collaterali
Numeri, stringhe e tuple sono esempi di oggetti immutabili; le liste e i dizionari sono generalmente mutabili. Quando una funzione riceve un oggetto, il suo parametro si riferisce allo stesso oggetto: riassegnare il parametro a un altro oggetto non cambia la variabile esterna, ma mutare l’oggetto condiviso ne modifica lo stato osservabile.
def aumenta_numero(n):
n += 1
def aggiungi_misura(valori):
valori.append(4)
numero = 3
misure = [1, 2]
aumenta_numero(numero)
aggiungi_misura(misure)
print(numero)
print(misure)
3
[1, 2, 4]
La distinzione è essenziale anche per i default mutabili. Non scrivere def registra(v, raccolta=[]) se vuoi una raccolta nuova a ogni chiamata: l’unica lista predefinita sarebbe condivisa fra chiamate successive. Usa invece un valore sentinella:
def registra(valore, raccolta=None):
if raccolta is None:
raccolta = []
raccolta.append(valore)
return raccolta
print(registra(7))
print(registra(8))
[7]
[8]
append modifica la lista in ingresso: questo è un effetto collaterale, da documentare chiaramente. Per evitare la modifica, quando è adatto, si può costruire e restituire una nuova lista, senza cambiare quella originaria.
12.9 — Funzioni pure, docstring e annotazioni di tipo
Una funzione è pura quando, a parità di argomenti, restituisce sempre lo stesso risultato e non produce effetti collaterali osservabili. Una funzione che legge input(), stampa o modifica una lista condivisa non è pura. La purezza semplifica i test: il risultato dipende soltanto dagli input espliciti.
Le docstring, racchiuse di solito fra tripli apici come prima istruzione del corpo, spiegano cosa calcola una funzione, i parametri e gli eventuali vincoli. Le annotazioni di tipo (x: float, -> float) aiutano lettori e strumenti di analisi: Python, per impostazione predefinita, non le fa rispettare automaticamente a runtime.
def energia_cinetica(massa_kg: float, velocita_ms: float) -> float:
"""Restituisce l'energia cinetica in joule; massa non negativa."""
if massa_kg < 0:
raise ValueError("Massa negativa")
return 0.5 * massa_kg * velocita_ms**2
print(f"{energia_cinetica(2.0, 3.0):.1f} J")
9.0 J
Il test dei valori invalidi va scritto esplicitamente: l’annotazione float non rifiuterebbe da sola una stringa. Nei programmi reali le funzioni vanno testate con valori ordinari, ai confini del dominio e con input non validi.

12.10 — Moduli e libreria standard
Un modulo è un file o componente importabile che raggruppa definizioni. import math rende disponibili nomi come math.pi e math.sqrt. Con from math import sqrt il nome sqrt entra direttamente nello scope corrente; import statistics as st assegna un alias al modulo. L’importazione può eseguire codice di inizializzazione la prima volta che il modulo viene caricato nel processo.
import math
import statistics as st
import random
print(f"{math.sqrt(81):.1f}")
print(st.mean((2, 4, 6)))
generatore = random.Random(7)
print(generatore.randrange(1, 2))
9.0
4
1
In questo esempio l’intervallo di randrange(1, 2) contiene un solo numero, 1: il risultato è quindi deterministico. Per estrazioni reali la sequenza può variare e non bisogna inventare un output fisso; fissare il seme rende invece riproducibile una sequenza con un dato generatore e ambiente. random è utile per simulazioni, non per generare segreti crittografici. statistics offre, fra le altre, media e mediana; math funzioni matematiche e costanti. È preferibile import math quando vogliamo rendere chiara l’origine dei nomi.
12.11 — Creare un modulo personale e usare __main__
Un progetto può essere suddiviso in più file senza anticipare i capitoli dedicati alla gestione dei dati. Immaginiamo due file nella stessa cartella. Il primo contiene le funzioni, il secondo le utilizza. Evita di chiamare un file personale math.py, random.py o statistics.py, perché potrebbe nascondere il modulo standard.
File formule.py
def kelvin(celsius):
return celsius + 273.15
if __name__ == "__main__":
print(kelvin(20))
File app.py
import formule
print(f"{formule.kelvin(20):.2f} K")
Output di python app.py
293.15 K
Quando si avvia direttamente formule.py, la variabile speciale __name__ vale "__main__" e viene eseguita la stampa di prova; quando il file viene importato da app.py, il blocco protetto non viene eseguito. Un package raggruppa moduli sotto un percorso di importazione: lo approfondiremo soltanto nei capitoli successivi. Il progetto STEM scaricabile usa lo stesso modello di separazione fra funzioni e avvio del programma.
12.12 — Espressioni lambda: utilizzi e limiti
Una lambda definisce una piccola funzione anonima costituita da una sola espressione. Ha parametri, valuta l’espressione e ne restituisce il risultato; non contiene un blocco con istruzioni come for, while o return. È utile come funzione di appoggio, per esempio nella scelta di una chiave di ordinamento, ma le funzioni con significato autonomo e logica articolata meritano un nome tramite def.
quadrato = lambda x: x * x
misure = [("A", 3), ("B", 1), ("C", 2)]
ordinate = sorted(misure, key=lambda elemento: elemento[1])
print(quadrato(5))
print(ordinate)
25
[('B', 1), ('C', 2), ('A', 3)]
La chiave seleziona il secondo elemento di ciascuna coppia. Nell’esempio quadrato = lambda ... è lecito ma def quadrato(x): return x*x è generalmente più leggibile, dato che la funzione riceve un nome. sorted produce una nuova lista e non modifica quella passata come argomento.

12.13 — Ricorsione: definizione, caso base e passo ricorsivo
Una funzione è ricorsiva quando richiama se stessa direttamente (o tramite altre funzioni). Ogni definizione ricorsiva corretta deve possedere un caso base, risolvibile senza ulteriori chiamate, e un passo ricorsivo che avvicini il problema al caso base. Per il fattoriale degli interi non negativi: 0! = 1 e n! = n · (n − 1)! per n ≥ 1. La precondizione è che n sia intero non negativo.
def fattoriale(n):
if not isinstance(n, int) or n < 0:
raise ValueError("Serve un intero non negativo")
if n <= 1:
return 1
return n * fattoriale(n - 1)
print(fattoriale(0))
print(fattoriale(4))
1
24
Il caso base copre sia 0 sia 1. La verifica del dominio impedisce di entrare in una sequenza infinita quando si passa un valore negativo. Anche con un caso base corretto, una chiamata molto profonda può superare il limite di ricorsione dell’interprete e sollevare RecursionError.
Secondo esempio — somma dei primi n interi.
def somma_primi(n):
if not isinstance(n, int) or n < 0:
raise ValueError("n non valido")
if n == 0:
return 0
return n + somma_primi(n - 1)
print(somma_primi(5))
15
12.14 — Stack delle chiamate, Euclide e confronto con i cicli
A ogni chiamata di funzione corrisponde una nuova attivazione con i propri parametri e nomi locali. Nella ricorsione queste attivazioni rimangono sullo stack delle chiamate fino a quando i risultati possono risalire verso la funzione chiamante. Per fattoriale(4) si scende a fattoriale(3), fattoriale(2), fattoriale(1) e poi si ritorna moltiplicando: 1 → 2 → 6 → 24. Le chiamate sono quattro: includono il caso base.
| Chiamata in discesa | Operazione sospesa | Risultato nel ritorno |
|---|---|---|
fattoriale(4) |
4 × fattoriale(3) |
24 |
fattoriale(3) |
3 × fattoriale(2) |
6 |
fattoriale(2) |
2 × fattoriale(1) |
2 |
fattoriale(1) |
Caso base | 1 |
Il massimo comune divisore si può trovare con l’algoritmo di Euclide: per b ≠ 0, MCD(a,b) = MCD(b, a % b); quando b = 0, il risultato è abs(a). Nel progetto STEM escludiamo il caso (0,0), perché il MCD di entrambi nulli non ha un valore positivo univoco nel nostro modello didattico.
def mcd(a, b):
if b == 0:
return abs(a)
return mcd(b, a % b)
print(mcd(48, 18))
6
Per questo esempio: (48,18) → (18,12) → (12,6) → (6,0); quattro chiamate, compresa quella finale. Il processo termina perché il resto, in valore assoluto nel caso di interi positivi, diminuisce fino a zero. Con input negativi Python definisce comunque %, ma è utile normalizzare gli argomenti con abs se si vuole tracciare il modello standard su non negativi.
Il fattoriale iterativo richiede un ciclo e memoria aggiuntiva costante per il risultato e il contatore (escludendo lo spazio occupato dall’intero sempre più grande); quello ricorsivo richiede inoltre uno stack di profondità proporzionale a n. Entrambe le strategie richiedono un numero di moltiplicazioni proporzionale a n; la ricorsione non è automaticamente più efficiente. L’algoritmo di Euclide riduce rapidamente la grandezza dei resti ed è in genere molto più pratico per numeri grandi rispetto alla ricerca di tutti i divisori. In Python, per una lunga ripetizione lineare è spesso preferibile un ciclo, che non rischia il limite dello stack.
12.15 — Progetto STEM: MEGI — Laboratorio di funzioni e modelli scientifici
Il file scaricabile MEGI_funzioni_modelli_scientifici.py è un programma da terminale progettato per Python 3.13, senza pacchetti esterni. Comprende tre esperimenti indipendenti selezionabili da menu; le funzioni esprimono i calcoli mentre le procedure di interazione leggono gli input e stampano i risultati. Il programma utilizza validazione di numeri finiti, gestione degli errori e formattazione dei risultati decimali.
Esperimento A — Cinematica
Con accelerazione costante, posizione iniziale x0, velocità iniziale v0 e tempo t ≥ 0, assumendo un moto lungo un asse cartesiano e unità SI:
La velocità media sull’intervallo è Δx / t, definita soltanto se t > 0; il tempo del moto uniforme può essere ricavato da t = Δx / v quando v ≠ 0 e i segni sono compatibili. Prova di controllo: x0 = 0 m, v0 = 2 m/s, a = 1 m/s², t = 4 s. Il modello restituisce x = 16 m, Δx = 16 m, v = 6 m/s, velocità media 4 m/s. Il moto ha accelerazione costante e non considera attrito o effetti relativistici.
Esperimento B — Geometria e misure
L’esperimento calcola l’area e il perimetro di un rettangolo, l’area di un cerchio, la superficie totale e il volume di un cilindro. Tutte le dimensioni lineari devono essere strettamente positive. La superficie totale comprende due basi e una superficie laterale; il volume è convertito da metri cubi a litri.
Per un cilindro con r = 1 m e h = 2 m, il volume è 2π m³ ≈ 6.2832 m³ ≈ 6283.19 L; la superficie totale è 6π m² ≈ 18.850 m². I decimali sono visualizzati arrotondati, non alterano le formule.
Esperimento C — Ricorsione e calcolo scientifico
Il programma confronta fattoriale e algoritmo di Euclide in versione ricorsiva e iterativa, mostrando il risultato e conteggi che misurano eventi differenti: le chiamate alla funzione ricorsiva, le moltiplicazioni del fattoriale iterativo e le iterazioni di Euclide. Impone 0 ≤ n ≤ 20 per un’attività didattica controllata; nel modulo il fattoriale ricorsivo è ulteriormente limitato a n ≤ 900 per non rischiare profondità eccessive nelle condizioni usuali. Per il fattoriale di 4 si hanno 4 chiamate ricorsive e 3 moltiplicazioni iterative; per MCD(48,18), 4 chiamate ricorsive e 3 iterazioni del ciclo. Non confondere quantità e unità dei conteggi.
Istruzioni d’uso. Scarica lo ZIP e decomprimilo. Apri la cartella in IDLE, VS Code o terminale; esegui python MEGI_funzioni_modelli_scientifici.py (su alcuni sistemi python3). Scegli 1, 2 o 3, inserisci i valori richiesti e premi 0 per terminare. Non è richiesto Internet. Il programma Python scaricabile è un’applicazione autonoma da eseguire sul computer. Per esplorare visivamente funzioni, parametri, scope, moduli e ricorsione, utilizza anche il MEGISTONE STEM LAB interattivo disponibile tramite il pulsante seguente.
⚡ APRI IL LABORATORIO INTERATTIVO
MEGISTONE STEM LAB — Funzioni, moduli e ricorsione
5 modalità interattive A–E
12.16 — Allenati con MEGI: 20 esercizi progressivi
Esercizio 01 — Livello A · Perché una funzione?
Obiettivo: Riconoscere decomposizione e riuso.
Traccia: Spiega perché in una simulazione con 100 prove conviene isolare il calcolo della velocità in una funzione. Indica input, output e un caso limite.
Mostra soluzione e procedimento
La funzione riceve spostamento e tempo, restituisce la velocità media; controlla il tempo positivo. Evita 100 copie della stessa formula.
def velocita(dx, t):
if t <= 0:
raise ValueError("Tempo non positivo")
return dx / t
print(velocita(12, 3))
4.0
Esercizio 02 — Livello A · Parametri e argomenti
Obiettivo: Distinguere definizione e chiamata.
Traccia: Nella funzione `potenza(base, esponente)` chiamata con `potenza(2, 5)`, identifica parametri e argomenti e prevedi il risultato.
Mostra soluzione e procedimento
`base` ed `esponente` sono parametri; 2 e 5 sono argomenti effettivi.
def potenza(base, esponente):
return base ** esponente
print(potenza(2, 5))
32
Esercizio 03 — Livello A · Stampare o restituire?
Obiettivo: Comprendere return e print.
Traccia: Spiega perché `x = saluta()` non contiene il testo stampato se `saluta` usa soltanto `print`. Modifica la funzione perché il testo sia disponibile.
Mostra soluzione e procedimento
Una funzione senza return esplicito restituisce None: bisogna restituire la stringa e stamparla dal chiamante.
def saluta():
return "Ciao"
x = saluta()
print(x)
Ciao
Esercizio 04 — Livello A · Scope e variabili
Obiettivo: Comprendere la regola LEGB.
Traccia: Distingui nome locale e globale. Che valore assume `numero` esterno dopo una funzione che dichiara `numero=5` localmente?
Mostra soluzione e procedimento
La riassegnazione locale non modifica il nome globale.
numero = 10
def prova():
numero = 5
return numero
print(prova(), numero)
5 10
Esercizio 05 — Livello B · Traccia di una chiamata
Obiettivo: Prevedere output e ordine.
Traccia: Senza eseguire, traccia le stampe: `f(3)` restituisce `n+2`, poi si moltiplica per 2.
Mostra soluzione e procedimento
Si valuta prima f(3)=5, quindi il prodotto vale 10.
def f(n):
return n + 2
x = f(3) * 2
print(x)
10
Esercizio 06 — Livello B · Default e keyword
Obiettivo: Tracciare valori predefiniti.
Traccia: Con `calcola(a,b=3)`, prevedi output per `calcola(4)` e `calcola(4,b=5)`.
Mostra soluzione e procedimento
Il default 3 vale solo quando b non è fornito.
def calcola(a, b=3):
return a * b
print(calcola(4))
print(calcola(4, b=5))
12 20
Esercizio 07 — Livello B · Riferimento a lista
Obiettivo: Riconoscere un effetto collaterale.
Traccia: Una funzione aggiunge 9 a una lista. Prevedi cosa viene stampato dalla variabile originaria.
Mostra soluzione e procedimento
La lista è mutabile e lo stesso oggetto viene osservato dal chiamante.
def modifica(a):
a.append(9)
valori = [1, 2]
modifica(valori)
print(valori)
[1, 2, 9]
Esercizio 08 — Livello B · Stack del fattoriale
Obiettivo: Tracciare chiamate ricorsive.
Traccia: Scrivi le chiamate e il risultato di `fatt(3)` con caso base `n<=1`.
Mostra soluzione e procedimento
Scende 3→2→1, poi risale con 1, 2, 6: tre chiamate.
def fatt(n):
if n <= 1:
return 1
return n * fatt(n - 1)
print(fatt(3))
6
Esercizio 09 — Livello C · Correggi il valore di ritorno
Obiettivo: Fare debugging semantico.
Traccia: Il codice `def quadrato(x): print(x*x)` è usato in `print(quadrato(3)+1)`. Individua l’errore e correggi.
Mostra soluzione e procedimento
La funzione originale restituisce None e l’addizione fallisce. Serve return, non una stampa interna.
def quadrato(x):
return x * x
print(quadrato(3) + 1)
10
Esercizio 10 — Livello C · Correggi la ricorsione
Obiettivo: Identificare caso base.
Traccia: La funzione `def conta(n): return 1+conta(n-1)` non termina. Correggila per restituire n per gli interi non negativi.
Mostra soluzione e procedimento
Con n=0 si restituisce 0. Ogni chiamata diminuisce n di uno: la terminazione è garantita nel dominio.
def conta(n):
if n < 0:
raise ValueError("n negativo")
if n == 0:
return 0
return 1 + conta(n - 1)
print(conta(4))
4
Esercizio 11 — Livello C · Default condiviso
Obiettivo: Correggere un default mutabile.
Traccia: Il codice `def add(x, a=[]): a.append(x); return a` conserva dati fra chiamate. Scrivi una versione che crei una lista nuova per ogni chiamata senza argomento.
Mostra soluzione e procedimento
Usa None come default e inizializza la lista all’interno.
def add(x, a=None):
if a is None:
a = []
a.append(x)
return a
print(add(1))
print(add(2))
[1] [2]
Esercizio 12 — Livello C · Variabile letta prima di assegnazione
Obiettivo: Risolvere UnboundLocalError.
Traccia: Una funzione contiene `print(conta)` prima di `conta += 1`, con `conta=3` globale. Correggila senza utilizzare global.
Mostra soluzione e procedimento
Passa conta come parametro e restituisci il nuovo valore, senza dipendere dallo stato esterno.
def aggiorna(conta):
print(conta)
return conta + 1
conta = 3
conta = aggiorna(conta)
print(conta)
3 4
Esercizio 13 — Livello D · Convertitore termico
Obiettivo: Progettare funzione e test.
Traccia: Implementa `celsius_kelvin` con controllo della temperatura inferiore allo zero assoluto; testa 0°C e -273.15°C. Restituisci i kelvin e non stamparli nella funzione.
Mostra soluzione e procedimento
La trasformazione è K=°C+273.15; sotto -273.15 °C il valore è fuori dal dominio fisico scelto.
def celsius_kelvin(c):
if c < -273.15:
raise ValueError("Sotto lo zero assoluto")
return c + 273.15
print(f"{celsius_kelvin(0):.2f}")
print(f"{celsius_kelvin(-273.15):.2f}")
273.15 0.00
Esercizio 14 — Livello D · Misure e valori limite
Obiettivo: Scrivere funzioni pure con validazione.
Traccia: Crea `media_due` che riceve due misure numeriche finite; prova 2 e 6 e rifiuta un valore infinito. Spiega perché separare la validazione dal display.
Mostra soluzione e procedimento
Controllare gli input evita che un risultato numerico privo di significato entri nel modello; la funzione restituisce il valore.
import math
def media_due(a, b):
if not math.isfinite(a) or not math.isfinite(b):
raise ValueError("Misure non finite")
return (a + b) / 2
print(media_due(2, 6))
4.0
Esercizio 15 — Livello D · Modulo di geometria
Obiettivo: Organizzare il codice in file.
Traccia: Progetta un modulo personale `figure.py` con funzione `perimetro_quadrato(l)` e un programma separato `esegui.py` che lo importi. Mostra il risultato per lato 3 m.
Mostra soluzione e procedimento
Le definizioni risiedono nel modulo e il programma usa `import figure`; evita conflitti con nomi standard.
File 1 — figure.py (salvare nella cartella del progetto)
def perimetro_quadrato(l):
if l <= 0:
raise ValueError("Lato non positivo")
return 4 * l
File 2 — esegui.py (salvare nella stessa cartella)
import figure
print(figure.perimetro_quadrato(3))
12
Esercizio 16 — Livello D · Somma ricorsiva e iterativa
Obiettivo: Confrontare due algoritmi.
Traccia: Realizza due funzioni che sommano gli interi da 1 a n, una con ricorsione e una con ciclo. Gestisci n negativo e confronta i valori per n=6.
Mostra soluzione e procedimento
La versione ricorsiva riduce n; l’iterativa accumula. Entrambe restituiscono 21 per n=6.
def ric(n):
if n < 0: raise ValueError("n negativo")
if n == 0: return 0
return n + ric(n - 1)
def ciclo(n):
if n < 0: raise ValueError("n negativo")
totale = 0
for i in range(1, n + 1):
totale += i
return totale
print(ric(6), ciclo(6))
21 21
Esercizio 17 — Livello E · Moto a velocità costante
Obiettivo: Applicare funzioni a misure fisiche.
Traccia: Un oggetto parte da 3 m con velocità +2 m/s. Progetta funzioni per posizione e spostamento a 5 s, verificando t≥0. Specifica tutte le unità.
Mostra soluzione e procedimento
Per moto uniforme x=x0+vt; da 3 m a 13 m lo spostamento è 10 m.
def posizione(x0, v, t):
if t < 0: raise ValueError("Tempo negativo")
return x0 + v*t
def delta(x0, x1):
return x1-x0
x = posizione(3, 2, 5)
print(f"x={x} m, spostamento={delta(3, x)} m")
x=13 m, spostamento=10 m
Esercizio 18 — Livello E · Volume e conversione
Obiettivo: Gestire unità e dimensioni.
Traccia: Un parallelepipedo ha lati 0.5, 0.4 e 0.3 m. Calcola volume in m³ e litri con due funzioni, impedendo lati non positivi.
Mostra soluzione e procedimento
Il volume è 0.06 m³, cioè 60 L. Il controllo dei parametri è essenziale nel modello.
def volume(a, b, c):
if min(a, b, c) <= 0: raise ValueError("Lati non positivi")
return a*b*c
def litri(m3):
return m3*1000
v = volume(0.5, 0.4, 0.3)
print(f"{v:.2f} m³; {litri(v):.0f} L")
0.06 m³; 60 L
Esercizio 19 — Livello E · MCD di intervalli
Obiettivo: Applicare Euclide e contare chiamate.
Traccia: Confronta ricorsione e iterazione per MCD(84,30); aggiungi un contatore delle chiamate e dei cicli e interpreta la differenza.
Mostra soluzione e procedimento
La catena è (84,30)→(30,24)→(24,6)→(6,0): 4 chiamate e 3 cicli.
def mcd_r(a, b, c):
c[0] += 1
if b == 0: return abs(a)
return mcd_r(b, a%b, c)
def mcd_i(a, b):
passi = 0
while b:
a, b = b, a%b
passi += 1
return abs(a), passi
c = [0]
print(mcd_r(84, 30, c), c[0], mcd_i(84, 30))
6 4 (6, 3)
Esercizio 20 — Livello E · Progettazione mini-laboratorio
Obiettivo: Integrare funzioni, test e scelta del modello.
Traccia: Crea una mini-applicazione da terminale con funzioni indipendenti per area cerchio e circonferenza. Usa `math.pi`, valida raggio positivo, definisci `main()` e stampa per r=2 m con due decimali. Spiega perché è utile separare calcolo e interazione.
Mostra soluzione e procedimento
Le due funzioni sono riutilizzabili e testabili. Per r=2 m, area≈12.57 m² e circonferenza≈12.57 m (stesso valore numerico, unità diverse).
import math
def area(r):
if r <= 0: raise ValueError("Raggio non positivo")
return math.pi*r*r
def circonferenza(r):
if r <= 0: raise ValueError("Raggio non positivo")
return 2*math.pi*r
def main():
r = 2
print(f"Area: {area(r):.2f} m²")
print(f"Circonferenza: {circonferenza(r):.2f} m")
if __name__ == "__main__":
main()
Area: 12.57 m² Circonferenza: 12.57 m
Le attività sono divise in cinque livelli: A comprensione, B tracciamento, C debugging, D programmazione, E applicazioni STEM. Prima prova autonomamente; apri «Mostra soluzione» soltanto dopo aver completato il tentativo. Ogni proposta riporta obiettivo, traccia, soluzione commentata e risultato atteso ove applicabile.
Riepilogo generale
Le funzioni rappresentano sottoproblemi con un’interfaccia esplicita; return produce un risultato riutilizzabile mentre print scrive sullo schermo. I parametri e gli argomenti collegano definizione e chiamata; i nomi seguono la ricerca LEGB, gli oggetti possono essere mutabili o immutabili e i default mutabili richiedono cautela. I moduli organizzano il codice e offrono librerie collaudate. Le lambda sono adatte a espressioni brevi. La ricorsione richiede un caso base e un passo che garantisca l’avvicinamento a esso; uno stack profondo ha costi e limiti.
Errori frequenti e correzioni
| Errore | Perché è scorretto | Correzione |
|---|---|---|
Scambiare print() con return |
Una stampa non è il valore restituito | Restituire il risultato, stampare fuori |
| Omettere gli argomenti obbligatori | Il parametro non riceve il valore previsto | Controllare la firma della funzione |
| Modificare una lista condivisa senza avviso | Produce effetti collaterali | Documentare la modifica o creare una copia |
Usare raccolta=[] come default |
La stessa lista è riutilizzata | Usare None e creare la lista dentro |
Riassegnare una globale senza global |
Il nome diventa locale, possibile UnboundLocalError |
Preferire input/return |
Usare lambda per logica complessa |
La funzione diventa poco leggibile | Preferire def |
| Scrivere ricorsione senza caso base | Chiamate potenzialmente senza termine | Individuare un caso base dimostrabile |
Passare t=0 alla velocità media |
Divisione per zero | Validare t > 0 |
Competenze raggiunte
Al termine, lo studente sa: progettare una funzione con precondizioni e risultato; scegliere fra print e return; usare parametri, keyword e valori predefiniti; riconoscere LEGB e effetti collaterali; importare e costruire un modulo; interpretare una lambda; analizzare un semplice algoritmo ricorsivo e confrontarlo con un ciclo; verificare una formula STEM con unità, casi limite e controlli degli input.
Fonti e approfondimenti
- Documentazione ufficiale Python — Defining Functions (sintassi, parametri, default).
- Python Language Reference — Execution model (scope e binding dei nomi).
- Python — Modules (import e
__main__). - Python — math, statistics, random.
- Python — Errors and Exceptions (errori e validazione).
- D.M. 7 ottobre 2010, n. 211, Indicazioni nazionali: Liceo Scientifico, opzione Scienze Applicate, Informatica (raccordo curricolare).
Raccordo didattico. La prossima unità B1.05 approfondirà liste, tuple, matrici, dizionari, insiemi e algoritmi sui dati. In questo capitolo tali strutture sono utilizzate soltanto negli esempi indispensabili su mutabilità e argomenti; l’unità futura non è ancora pubblicata e non viene collegata.