Liste Python, tuple, matrici, dizionari e insiemi rappresentati con codice Python, matrice numerica e algoritmi di analisi dei dati.
Le principali strutture dati di Python e gli algoritmi per organizzare, cercare, ordinare e analizzare informazioni.

Liste Python, tuple, matrici, dizionari e insiemi permettono di organizzare, trasformare e analizzare dati. In questo capitolo impariamo a scegliere strutture adeguate, a evitare errori di mutabilità e a sviluppare algoritmi verificabili con Python 3.13 e applicazioni STEM.

Prerequisiti: variabili, espressioni, condizioni, cicli, funzioni, parametri, scope, debugging (B1.01–B1.04). Obiettivi: creare e manipolare collezioni, risolvere problemi con ricerca e ordinamento, rappresentare matrici, calcolare statistiche descrittive, documentare e testare funzioni. Perimetro: non sono trattati qui lettura di file, database e programmazione a oggetti.

Ripasso consigliato: Python: funzioni, parametri, moduli e ricorsione.

Media aritmetica = (somma delle misure) / (numero delle misure), per n > 0

13.1 — Le strutture dati in Python

Una variabile può rappresentare un singolo valore, ma una rilevazione scientifica produce spesso molti valori collegati: temperature nel tempo, voti, coordinate, categorie. Una struttura dati permette di organizzarli e di applicare algoritmi in modo sistematico. In Python le liste e le tuple sono sequenze, i dizionari associano chiavi a valori e gli insiemi modellano collezioni di elementi distinti.

Per scegliere una struttura considera quattro domande: conta l’ordine? I valori possono ripetersi? Dovranno cambiare? Serve recuperare un valore mediante un indice oppure una chiave? Per esempio una serie temporale richiede generalmente una lista; le coordinate fisse possono essere una tupla; una scheda di laboratorio può essere un dizionario; le categorie osservate senza ripetizioni un insieme.

Codice Python 3.13
temperature = [18.5, 19.0, 18.5]  # lista: duplicati consentiti
punto = (3, 4)                 # tupla
sensore = {"id": "T1", "valore": 18.5}  # dizionario
categorie = {"sole", "pioggia", "sole"}  # insieme
print(len(temperature), punto[0], sensore["id"], len(categorie))
Output verificato
3 3 T1 2

13.2 — Le liste Python

Una lista è una sequenza ordinata e mutabile: mantiene l’ordine degli elementi, ammette duplicati e può essere modificata. Le parentesi quadre delimitano la lista; gli indici partono da 0. Un indice negativo conta dalla fine: -1 seleziona l’ultimo elemento. Le liste possono mescolare tipi, ma in analisi numerica è preferibile mantenere dati omogenei.

Codice Python 3.13
misure = [12.4, 13.1, 12.4]
vuota = []
print(misure[0], misure[-1], len(misure))
misure[1] = 13.5
print(misure)
print(12.4 in misure, 20 in misure)
Output verificato
12.4 12.4 3
[12.4, 13.5, 12.4]
True False

Gli indici inesistenti causano IndexError. Prima di leggere misure[0], controlla che la lista non sia vuota: if misure:.

13.3 — Slicing e attraversamento delle liste

Lo slicing produce una nuova lista con la sintassi lista[start:stop:step]. L’indice start è incluso, stop è escluso, mentre step è il passo e non può valere zero. Se omessi, vengono usati valori predefiniti coerenti con la direzione del passo.

Codice Python 3.13
dati = [10, 20, 30, 40, 50]
print(dati[1:4], dati[::2], dati[::-1])
for indice, valore in enumerate(dati):
    print(indice, valore, end="; ")
print()
for i in range(2):
    print(dati[i], end=" ")
Output verificato
[20, 30, 40] [10, 30, 50] [50, 40, 30, 20, 10]
0 10; 1 20; 2 30; 3 40; 4 50; 
10 20

Usa for valore in dati quando ti serve soltanto il valore; enumerate() quando serve anche la posizione. Modificare la lunghezza della lista durante un normale ciclo di attraversamento può portare a saltare elementi.

Liste Python con indici positivi e negativi, esempi di slicing, metodi append, insert, remove, sort e confronto tra copia e mutabilità.
Le liste Python: accesso tramite indici, estrazione di elementi con slicing, metodi principali e differenza tra assegnazione e copia.

13.4 — Metodi delle liste

Un metodo è un’operazione richiamata sull’oggetto, per esempio lista.append(5). Alcuni metodi cambiano la lista e restituiscono None, altri forniscono un’informazione senza modificarla. Non confondere lista.sort() (modifica in loco) con sorted(lista) (crea una nuova lista ordinata).

Metodo Effetto Modifica la lista?
append(x) Aggiunge un elemento in coda Sì
extend(iterabile) Aggiunge tutti gli elementi Sì
insert(i,x) Inserisce nella posizione i Sì
remove(x) Elimina la prima occorrenza, errore se assente Sì
pop(i) Rimuove e restituisce l’elemento (di default l’ultimo) Sì
clear() Svuota Sì
index(x) Restituisce l’indice della prima occorrenza, errore se assente No
count(x) Conta occorrenze No
reverse() Inverte in loco Sì
sort() Ordina in loco Sì
Codice Python 3.13
numeri = [3, 1, 3]
numeri.append(2)
numeri.extend([5, 4])
numeri.insert(0, 9)
print(numeri.count(3), numeri.index(5))
numeri.remove(3)
print(numeri.pop(), numeri)
numeri.sort()
print(numeri)
numeri.reverse()
print(numeri)
Output verificato
2 5
4 [9, 1, 3, 2, 5]
[1, 2, 3, 5, 9]
[9, 5, 3, 2, 1]

13.5 — Copia, riferimenti e mutabilità

Le variabili Python contengono riferimenti a oggetti. L’istruzione b = a non copia gli elementi: entrambi i nomi si riferiscono alla stessa lista. L’operatore == confronta i valori, mentre is confronta l’identità dell’oggetto. Una copia superficiale duplica la lista esterna, ma non gli oggetti mutabili annidati; una copia profonda duplica ricorsivamente gli oggetti annidati secondo le regole di copy.deepcopy().

Codice Python 3.13
a = [1, 2]
b = a
b.append(3)
print(a, a is b)
c = a.copy()
c.append(4)
print(a, c, a == c, a is c)
Output verificato
[1, 2, 3] True
[1, 2, 3] [1, 2, 3, 4] False False
Codice Python 3.13
from copy import deepcopy
originale = [[1], [2]]
superficiale = originale.copy()
profonda = deepcopy(originale)
originale[0].append(99)
print(superficiale)
print(profonda)
Output verificato
[[1, 99], [2]]
[[1], [2]]

Se una funzione esegue lista.append(...) sull’argomento ricevuto, può modificare la lista del chiamante: è un effetto collaterale. Se non desiderato, lavora su una copia o costruisci e restituisci una nuova lista.

13.6 — Le tuple

Una tupla è una sequenza ordinata e immutabile: dopo la creazione non se ne possono sostituire o eliminare gli elementi. Supporta indici, slicing, len(), packing e unpacking. Per creare una tupla con un solo elemento è indispensabile la virgola: (7,). La semplice parentesi (7) rappresenta invece un intero.

Codice Python 3.13
coordinate = (4, 7)
x, y = coordinate
print(x, y, coordinate[-1], coordinate[:1])
def estremi(valori):
    return min(valori), max(valori)
print(estremi([5, 2, 8]))
print(type((7,)).__name__, type((7)).__name__)
Output verificato
4 7 7 (4,)
(2, 8)
tuple int

L’immutabilità della tupla riguarda i suoi riferimenti: una lista contenuta in una tupla resta mutabile, quindi ([1, 2],)[0].append(3) è consentito. Le tuple sono utili per coordinate e risultati composti da più valori.

13.7 — Le matrici mediante liste annidate

Una matrice rettangolare è una tabella con righe e colonne. In Python, senza librerie esterne, si rappresenta come lista di liste: m[i][j] individua la riga i e la colonna j. Per sommare gli elementi si usano due cicli, oppure una somma di somme. Le medie per colonna richiedono di mantenere fisso l’indice della colonna e attraversare le righe.

Codice Python 3.13
m = [[1, 2, 3], [4, 5, 6]]
print(m[1][2])
print(sum(sum(riga) for riga in m))
print([sum(riga) for riga in m])
print([sum(m[i][j] for i in range(len(m)))
       for j in range(len(m[0]))])
Output verificato
6
21
[6, 15]
[5, 7, 9]

Errore da evitare: [[0] * 3] * 3 crea tre riferimenti alla medesima riga: cambiare una cella può alterare più righe. Usa una comprehension che costruisca ogni riga in modo indipendente.

Codice Python 3.13
errata = [[0] * 3] * 3
errata[0][1] = 7
print(errata)
corretta = [[0] * 3 for _ in range(3)]
corretta[0][1] = 7
print(corretta)
quadrata = [[1, 2], [3, 4]]
print(sum(quadrata[i][i] for i in range(len(quadrata))))
Output verificato
[[0, 7, 0], [0, 7, 0], [0, 7, 0]]
[[0, 7, 0], [0, 0, 0], [0, 0, 0]]
5

L’estrazione della diagonale principale vale per matrici quadrate. Prima di elaborare una matrice esterna, controlla che contenga righe non vuote e tutte della stessa lunghezza.

Una matrice rettangolare di dimensioni r × c contiene r righe e c colonne. Un attraversamento completo con due cicli annidati visita r × c celle: per esempio, per ogni riga si legge ciascun valore e si accumula la somma. Gli accessi m[i][j] richiedono indici validi, con 0 ≤ i < r e 0 ≤ j < c.

Tuple e matrici Python con esempi di accesso agli elementi, indici di riga e colonna, liste annidate e cicli di attraversamento.
Tuple e matrici in Python: sequenze immutabili, rappresentazione delle matrici mediante liste annidate e accesso agli elementi con due indici.

13.8 — Algoritmi sulle liste

Un algoritmo è una sequenza finita di operazioni ben definite, mentre sum(), min() e max() sono funzioni integrate che risolvono operazioni frequenti. Una ricerca sequenziale controlla ogni elemento fino al primo risultato o fino al termine della lista. La media aritmetica richiede n > 0; il calcolo deve gestire esplicitamente il caso vuoto.

Codice Python 3.13
def media(valori):
    if not valori:
        raise ValueError("Lista vuota")
    return sum(valori) / len(valori)

def cerca(valori, bersaglio):
    for posizione, valore in enumerate(valori):
        if valore == bersaglio:
            return posizione
    return -1

misure = [11, 13, 12, 13]
print(f"{media(misure):.2f}", cerca(misure, 12))
print(sum(v > 12 for v in misure))
print([v for v in misure if v >= 12])
Output verificato
12.25 2
2
[13, 12, 13]

Per il minimo e il massimo su una lista vuota, Python solleva ValueError; è corretto controllare i dati oppure utilizzare il parametro default quando esiste un valore sensato per il problema.

13.9 — Ordinamento e ricerca binaria

L’ordinamento dispone i dati secondo un criterio. sorted() restituisce una nuova lista; sort() modifica l’originale. Entrambi ammettono reverse=True e key per definire il criterio. La ricerca lineare funziona anche con dati disordinati e nel caso peggiore esamina tutti gli n elementi: costo O(n). La ricerca binaria, invece, richiede dati già ordinati e dimezza progressivamente l’intervallo: costo O(log n) della sola ricerca; ordinare prima ha un costo aggiuntivo.

Codice Python 3.13
parole = ["sole", "pioggia", "vento"]
print(sorted(parole, key=len))
numeri = [7, 1, 4, 9, 3]
ordinati = sorted(numeri)
def binaria(a, valore):
    sinistra, destra = 0, len(a) - 1
    while sinistra <= destra:
        centro = (sinistra + destra) // 2
        if a[centro] == valore:
            return centro
        if a[centro] < valore:
            sinistra = centro + 1
        else:
            destra = centro - 1
    return -1
print(ordinati, binaria(ordinati, 7), binaria(ordinati, 8))
Output verificato
['sole', 'vento', 'pioggia']
[1, 3, 4, 7, 9] 3 -1

Traccia della ricerca di 7 in [1, 3, 4, 7, 9]: prima esamina l’indice 2 (valore 4); restringe agli indici 3–4; poi trova 7 all’indice 3. Se i dati non sono ordinati, il risultato non è affidabile.

Per un elenco già ordinato, la ricerca binaria richiede al più un numero di confronti proporzionale a log₂(n). Se devi effettuare una sola ricerca su dati disordinati, non è detto che ordinarli prima sia vantaggioso. Questa implementazione restituisce un indice corrispondente al valore, non necessariamente la prima occorrenza in presenza di duplicati.

13.10 — List comprehension

Una list comprehension esprime in forma compatta la costruzione di una lista: [espressione for elemento in sequenza if condizione]. Può trasformare oppure filtrare i dati. Non è necessario usarla a ogni costo: quando la logica comprende più passaggi, un normale ciclo for è spesso più facile da leggere e verificare.

Codice Python 3.13
valori = [1, 2, 3, 4, 5]
quadrati = [x * x for x in valori]
pari = [x for x in valori if x % 2 == 0]
tradizionale = []
for x in valori:
    if x % 2 == 0:
        tradizionale.append(x)
print(quadrati, pari, tradizionale)
Output verificato
[1, 4, 9, 16, 25] [2, 4] [2, 4]

13.11 — Dizionari Python

Un dizionario (dict) associa chiavi a valori. Le chiavi devono essere hashable, cioè possedere un valore hash stabile per la loro durata come chiavi: stringhe, interi e tuple di elementi hashable sono esempi comuni; le liste non lo sono. Le chiavi sono uniche; assegnare una chiave già presente ne aggiorna il valore. In Python moderno, il dizionario mantiene l’ordine di inserimento, ma l’accesso tipico avviene per chiave, non per indice numerico.

Codice Python 3.13
campione = {"id": "A1", "massa": 12.5}
campione["massa"] = 12.8
campione["unita"] = "g"
print(campione.get("temperatura", "non rilevata"))
print(list(campione.keys()))
print(list(campione.values()))
for chiave, valore in campione.items():
    print(chiave, valore)
del campione["unita"]
Output verificato
non rilevata
['id', 'massa', 'unita']
['A1', 12.8, 'g']
id A1
massa 12.8
unita g

L’accesso con d[chiave] solleva KeyError se la chiave manca; d.get(chiave, default) consente invece un valore sostitutivo. keys(), values() e items() restituiscono viste dinamiche del contenuto.

13.12 — Dizionari e algoritmi sui dati

Per contare le frequenze, visita ogni osservazione e aumenta il contatore associato alla categoria. get() semplifica la gestione della prima comparsa; il risultato conserva l’ordine della prima apparizione delle chiavi. Nelle analisi su dati inseriti dall’utente conviene normalizzare le etichette, per esempio con strip().lower(), e rifiutare categorie vuote.

Codice Python 3.13
osservazioni = ["sole", "vento", "sole", "pioggia", "vento", "sole"]
frequenze = {}
for categoria in osservazioni:
    frequenze[categoria] = frequenze.get(categoria, 0) + 1
print(frequenze)
print(max(frequenze, key=frequenze.get))
Output verificato
{'sole': 3, 'vento': 2, 'pioggia': 1}
sole

Una scheda scientifica può essere {"id": "P1", "misure": [12.0, 12.5]}: il dizionario descrive campi con nomi significativi, mentre la lista associata raccoglie osservazioni. Non confondere questa struttura con un database: le basi di dati saranno affrontate in B1.07.

13.13 — Gli insiemi Python

Un insieme (set) contiene elementi unici e hashable. L’ordine di iterazione non è garantito e non esistono indici come insieme[0]. Per creare l’insieme vuoto si scrive set(); {} crea invece un dizionario vuoto. Le operazioni di unione, intersezione, differenza e differenza simmetrica sono utili per confrontare categorie di due esperimenti.

Codice Python 3.13
a = {"rosso", "verde", "blu"}
b = {"blu", "giallo"}
print(sorted(a | b))
print(sorted(a & b))
print(sorted(a - b))
print(sorted(a ^ b))
a.add("bianco")
a.discard("assente")  # nessun errore se manca
print("bianco" in a)
Output verificato
['blu', 'giallo', 'rosso', 'verde']
['blu']
['rosso', 'verde']
['giallo', 'rosso', 'verde']
True

remove(x) solleva KeyError se l’elemento manca, mentre discard(x) non solleva errori in quel caso. Per mostrare un insieme in ordine riproducibile, trasforma il risultato con sorted().

Esempio di eliminazione: s = {“A”, “B”}; s.remove(“A”) lascia {“B”}; s.clear() su un insieme non è trattato qui. Per remove(“C”) si ottiene KeyError, mentre discard(“C”) non produce errore.

Dizionari e insiemi Python con coppie chiave-valore, metodi dei dizionari e operazioni di unione, intersezione e differenza tra insiemi.
Dizionari e insiemi in Python: gestione delle coppie chiave-valore, elementi unici e operazioni di unione, intersezione, differenza e differenza simmetrica.

13.14 — Confronto tra strutture dati

Struttura Ordine Mutabilità Duplicati Accesso
Lista Sì Mutabile Ammessi Indice
Tupla Sì Immutabile Ammessi Indice
Dizionario Inserimento Mutabile Chiavi uniche; valori ripetibili Chiave
Insieme Non garantito Mutabile Non ammessi Appartenenza

Scegli una lista per serie di misure modificabili; una tupla per coordinate e valori che non devono essere riassegnati; un dizionario per schede e conteggi per categoria; un insieme per eliminare duplicati o confrontare gruppi. Nessuna struttura è “migliore” in assoluto: la correttezza dipende dall’uso.

13.15 — Funzioni e collezioni

Il capitolo precedente ha introdotto parametri, scope, return e moduli. Con le collezioni questi concetti diventano essenziali: una funzione può ricevere una lista e restituire una tupla, oppure produrre un dizionario riepilogativo. Una docstring documenta lo scopo della funzione; annotazioni come list[float] aiutano a comprendere il contratto, ma non impongono automaticamente controlli dei tipi durante l’esecuzione.

Nota: nel caso di una funzione che legge soltanto la lista, la copia non è necessaria. La copia difensiva è utile quando la funzione intende modificare una collezione senza alterare l’originale; una copia superficiale non isola gli oggetti mutabili annidati.

Codice Python 3.13
def statistiche(valori: list[float]) -> dict[str, float]:
    """Calcola media ed estremi senza modificare la lista iniziale."""
    if not valori:
        raise ValueError("Nessuna misura")
    copia = valori.copy()
    return {"media": sum(copia) / len(copia),
            "min": min(copia), "max": max(copia)}

misure = [2.0, 4.0, 6.0]
print(statistiche(misure))
print(misure)
Output verificato
{'media': 4.0, 'min': 2.0, 'max': 6.0}
[2.0, 4.0, 6.0]

13.16 — Applicazioni STEM

Esperimento A — Analisi di misure fisiche

Problema: quattro letture di lunghezza (cm) sono 12,4; 12,8; 12,5; 12,7. Calcolare media, minimo, massimo e intervallo di variazione. Algoritmo: controllare che la lista non sia vuota, sommare e dividere per il numero di letture, trovare estremi e differenza. Interpretazione: l’intervallo di variazione descrive la distanza tra massimo e minimo, non è una stima completa dell’incertezza sperimentale.

Codice Python 3.13
misure = [12.4, 12.8, 12.5, 12.7]
if misure:
    media = sum(misure) / len(misure)
    minimo, massimo = min(misure), max(misure)
    print(f"Media: {media:.2f} cm")
    print(f"Minimo: {minimo:.2f}; massimo: {massimo:.2f}")
    print(f"Intervallo: {massimo - minimo:.2f} cm")
Output verificato
Media: 12.60 cm
Minimo: 12.40; massimo: 12.80
Intervallo: 0.40 cm

Caso limite: con zero misure non si può calcolare la media; con una sola misura l’intervallo è 0,00 cm.

Esperimento B — Matrici e temperature

Problema: tre giornate di temperature (°C), con due rilevazioni ciascuna. Dati: [[18, 22], [19, 23], [17, 21]]. Calcolare medie per giorno (righe) e per orario (colonne), minimo e massimo globali. Algoritmo: verifica della forma rettangolare, somme per riga e per colonna, ricerca degli estremi. Le medie descrivono questi dati e non una temperatura climatica generale.

Codice Python 3.13
t = [[18, 22], [19, 23], [17, 21]]
if not t or not t[0] or any(len(r) != len(t[0]) for r in t):
    raise ValueError("La matrice deve essere rettangolare e non vuota")
medie_giorno = [sum(r) / len(r) for r in t]
medie_ora = [sum(t[i][j] for i in range(len(t))) / len(t)
             for j in range(len(t[0]))]
tutti = [v for r in t for v in r]
print([f"{v:.2f}" for v in medie_giorno])
print([f"{v:.2f}" for v in medie_ora])
print(min(tutti), max(tutti))
Output verificato
['20.00', '21.00', '19.00']
['18.00', '22.00']
17 23

Caso limite: una matrice vuota o con righe di lunghezza diversa deve essere rifiutata prima di effettuare accessi per indice.

Esperimento C — Frequenze e classificazioni

Problema: classificare osservazioni meteorologiche e confrontare le categorie rilevate in due gruppi. Algoritmo: frequenze con dizionario, categorie uniche con set(), confronto tramite intersezione e differenza. L’ordine di visualizzazione degli insiemi viene reso stabile con sorted().

Codice Python 3.13
a = ["sole", "vento", "sole", "pioggia"]
b = ["sole", "neve", "vento"]
f = {}
for x in a:
    f[x] = f.get(x, 0) + 1
print(f)
print(sorted(set(a) & set(b)))
print(sorted(set(a) - set(b)))
Output verificato
{'sole': 2, 'vento': 1, 'pioggia': 1}
['sole', 'vento']
['pioggia']

Caso limite: un elenco senza osservazioni produce un dizionario vuoto; le operazioni insiemistiche restano definite, ma non esiste una categoria più frequente.

Le due cifre decimali negli output sono una scelta di presentazione: non implicano automaticamente che gli strumenti di misura abbiano quella precisione. I dati dell’esempio sono illustrativi, e non bisogna dedurne un’incertezza metrologica non calcolata.

Algoritmi Python per ricerca lineare e binaria, ordinamento di liste con sort e sorted, calcolo di somma, media, minimo e massimo.
Algoritmi sui dati in Python: ricerca lineare e binaria, ordinamento crescente e decrescente e analisi statistica di misure numeriche.

13.17 — Progetto Python STEM scaricabile

Il progetto autonomo MEGI — Analizzatore di dati e collezioni Python integra tre modalità: misure fisiche con liste; temperature con matrici; frequenze e confronti con dizionari e insiemi.

🐍 SCARICA IL PROGETTO PYTHON STEM

Come eseguirlo: estrai l’archivio ZIP; apri il programma con IDLE o Visual Studio Code ed eseguilo con Python 3.

Laboratorio interattivo MEGISTONE: esplora visivamente liste, tuple, matrici, dizionari, insiemi e algoritmi sui dati attraverso cinque modalità interattive A–E. Modifica i parametri, esegui gli algoritmi passo dopo passo e verifica i risultati direttamente nel browser.

🐍 APRI IL LABORATORIO INTERATTIVO

13.18 — Allenati con MEGI — 20 esercizi progressivi

Cinque livelli di difficoltà, quattro esercizi ciascuno. Per ogni esercizio, formula prima una risposta autonoma; poi apri soltanto la soluzione relativa. I risultati numerici con due decimali sono formattazioni, non nuove misure esatte.

Livello A · 1 — Riconosci le strutture

Obiettivo e traccia: Indica la struttura più adatta per: misure nel tempo, coordinate immutabili, scheda con campi nominati, insieme di categorie diverse.

Apri la soluzione commentata

Lista per misure, tupla per coordinate, dizionario per scheda, insieme per categorie uniche.

Livello A · 2 — Indici

Obiettivo e traccia: Data a=[4, 8, 12], trova a[0], a[-1] e len(a).

Apri la soluzione commentata

Risultati: 4, 12, 3. Gli indici iniziano da zero.

Livello A · 3 — Mutabilità

Obiettivo e traccia: Spiega perché b=a non crea una copia indipendente di una lista.

Apri la soluzione commentata

Entrambi i nomi si riferiscono allo stesso oggetto. Per la copia superficiale usa a.copy().

Livello A · 4 — Insiemi

Obiettivo e traccia: Un insieme ammette duplicati? Si può leggere il primo elemento con s[0]?

Apri la soluzione commentata

No: i duplicati vengono eliminati e l’insieme non supporta l’indicizzazione.

Livello B · 5 — Slicing

Obiettivo e traccia: Data a=[2,4,6,8,10], prevedi a[1:4] e a[::-1].

Apri la soluzione commentata

[4,6,8] e [10,8,6,4,2]. L’estremo superiore del primo slice è escluso.

Livello B · 6 — Metodi

Obiettivo e traccia: Prevedi il risultato di a=[1,2]; a.append(3); a.pop(0); print(a).

Apri la soluzione commentata

[2,3], perché pop(0) elimina il primo elemento.

Livello B · 7 — Tuple

Obiettivo e traccia: Quali valori assumono x e y dopo x,y=(5,9)?

Apri la soluzione commentata

x=5 e y=9, grazie all’unpacking.

Livello B · 8 — Dizionari

Obiettivo e traccia: Prevedi d={"a":1}; d["a"]+=2; print(d["a"]).

Apri la soluzione commentata

Il risultato è 3: viene aggiornata la stessa chiave.

Livello C · 9 — Copia errata

Obiettivo e traccia: Correggi b=a se vuoi modificare una lista piatta senza cambiare a.

Apri la soluzione commentata

Usa b=a.copy() oppure b=list(a). Per liste annidate considera deepcopy.

Livello C · 10 — Righe condivise

Obiettivo e traccia: Spiega il difetto di m=[[0]*2]*3 e proponi la correzione.

Apri la soluzione commentata

Le tre righe sono lo stesso oggetto. Correzione: m=[[0]*2 for _ in range(3)].

Livello C · 11 — Sort e None

Obiettivo e traccia: Perché b=a.sort() non contiene la lista ordinata?

Apri la soluzione commentata

sort() modifica la lista sul posto e restituisce None; usa b=sorted(a).

Livello C · 12 — Chiave assente

Obiettivo e traccia: Correggi un accesso rischioso f["vento"] se la chiave potrebbe mancare.

Apri la soluzione commentata

Usa f.get("vento", 0) oppure verifica prima "vento" in f.

Livello D · 13 — Media

Obiettivo e traccia: Scrivi una funzione media(v) che sollevi ValueError per una lista vuota.

Apri la soluzione commentata
def media(v):
    if not v:
        raise ValueError("Lista vuota")
    return sum(v) / len(v)

print(f"{media([2, 4, 6]):.2f}")  # 4.00

Soluzione eseguibile: i controlli gestiscono i casi attesi e i commenti indicano il risultato.

Livello D · 14 — Filtraggio

Obiettivo e traccia: Ottieni i numeri positivi da [-2,0,3,5] con una comprehension.

Apri la soluzione commentata

[x for x in [-2,0,3,5] if x > 0] restituisce [3,5].

Livello D · 15 — Frequenze

Obiettivo e traccia: Conta le occorrenze di ["A","B","A"] con un dizionario.

Apri la soluzione commentata
f = {}
for x in ["A", "B", "A"]:
    f[x] = f.get(x, 0) + 1
print(f)  # {'A': 2, 'B': 1}

Soluzione eseguibile: i controlli gestiscono i casi attesi e i commenti indicano il risultato.

Livello D · 16 — Ricerca

Obiettivo e traccia: Scrivi una ricerca sequenziale che restituisca -1 se il dato manca.

Apri la soluzione commentata
def cerca(a, x):
    for i, v in enumerate(a):
        if v == x:
            return i
    return -1

print(cerca([4, 7, 9], 7))  # 1
print(cerca([4, 7, 9], 8))  # -1

Soluzione eseguibile: i controlli gestiscono i casi attesi e i commenti indicano il risultato.

Livello E · 17 — Sensore

Obiettivo e traccia: Per le misure [10.0,11.0,12.0], calcola media e intervallo di variazione.

Apri la soluzione commentata

Media 11.00; intervallo 2.00. Verifica con sum(v)/len(v) e max(v)-min(v).

Livello E · 18 — Tabella termica

Obiettivo e traccia: Trova la media di ciascuna riga di [[18,20],[20,22]].

Apri la soluzione commentata

Le medie per riga sono 19.00 e 21.00; usa una comprehension su m.

Livello E · 19 — Categorie comuni

Obiettivo e traccia: Trova intersezione tra {"sole","vento"} e {"vento","neve"}.

Apri la soluzione commentata

L’intersezione è {"vento"}; l’operatore è &.

Livello E · 20 — Mini progetto

Obiettivo e traccia: Progetta una funzione che restituisca media, minimo e massimo delle misure e gestisca lista vuota.

Apri la soluzione commentata
def riepilogo(v):
    if not v:
        raise ValueError("Nessuna misura")
    return {"media": sum(v) / len(v),
            "min": min(v), "max": max(v)}

print(riepilogo([2, 4, 6]))
# {'media': 4.0, 'min': 2, 'max': 6}

Soluzione eseguibile: i controlli gestiscono i casi attesi e i commenti indicano il risultato.

Approfondimenti e riferimenti: Python Tutorial — Data Structures; Built-in Types; Modulo copy; Modulo bisect. Gli esempi sono didattici e non sostituiscono analisi metrologiche complete.

Articoli simili