Funzioni Python, parametri, moduli, lambda e ricorsione: codice del fattoriale e illustrazioni 3D MEGISTONE.
Python: funzioni, parametri, moduli e ricorsione. Dalla definizione delle funzioni al calcolo ricorsivo.

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))
Output atteso

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.

Infografica sulle funzioni Python: sintassi def, parametri, return ed esempio di calcolo dell'area di un rettangolo.
Le funzioni in Python: definizione, parametri, valore di ritorno ed esempio pratico con il calcolo dell’area di un rettangolo.

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")
Output atteso

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))
Output atteso

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)
Output atteso

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)
Output atteso

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}")
Output atteso

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))
Output atteso

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))
Output atteso

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.

Regola LEGB in Python: scope Local, Enclosing, Global e Built-in, variabili locali e globali, nonlocal e global.
La regola LEGB in Python: ricerca dei nomi negli ambiti locali, enclosing, globali e built-in, con esempi di shadowing e istruzioni global e nonlocal.

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)
Output atteso

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())
Output atteso

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)
Output atteso

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))
Output atteso

[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")
Output atteso

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.

Infografica sui moduli Python: import, libreria standard, organizzazione dei file .py ed esempi di codice riutilizzabile.
Moduli Python e importazioni: come organizzare i file .py, riutilizzare funzioni e gestire le istruzioni import e from import.

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))
Output atteso

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

Output atteso

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)
Output atteso

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.

Infografica sulla ricorsione Python con fattoriale, stack delle chiamate, caso base e algoritmo di Euclide per il MCD.
La ricorsione in Python: caso base, chiamate ricorsive, stack e risalita dei risultati, con esempi del fattoriale e dell’algoritmo di Euclide.

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.

0! = 1; per n ≥ 1, n! = n × (n − 1)!
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))
Output atteso

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))
Output atteso

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))
Output atteso

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:

x(t) = x₀ + v₀t + ½at²   |   v(t) = v₀ + at   |   Δx = x(t) − x₀

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.

Aᵣ = b · h; Pᵣ = 2(b + h); A꜀ = πr²; S = 2πr(r + h); V = πr²h; 1 m³ = 1000 L

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))
Risultato atteso

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))
Risultato atteso

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)
Risultato atteso

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)
Risultato atteso

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)
Risultato atteso

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))
Risultato atteso

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)
Risultato atteso

[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))
Risultato atteso

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)
Risultato atteso

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))
Risultato atteso

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))
Risultato atteso

[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)
Risultato atteso

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}")
Risultato atteso

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))
Risultato atteso

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))
Risultato atteso

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))
Risultato atteso

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")
Risultato atteso

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")
Risultato atteso

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))
Risultato atteso

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()
Risultato atteso

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

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.

Articoli simili