Liste e tuple Python: Introduzione e Esempi - SapereSemplice

In questa lezione esploriamo liste e tuple in Python, due sequenze fondamentali per organizzare e manipolare collezioni di dati. Imparerai creazione, accesso, slicing, i metodi principali delle liste (append, remove, sort) e la differenza chiave tra lista e tupla (👉 mutabile vs immutabile). Concludiamo con esercizi pratici (💪 tabelline, ➕ somma da 1 a n usando liste e range) per consolidare i concetti.

🔗 Ripassi consigliati:
• Lezione 2 – Primo script → https://www.saperesemplice.com/primo-script-python-hello/
• Lezione 3 – Variabili e Tipi di Dato (include nota su mutabilità) → https://www.saperesemplice.com/variabili-tipi-dato-python/
• Lezione 8 – Ciclo while → https://www.saperesemplice.com/ciclo-while-python-base/
• Percorso Corsi Python → https://www.saperesemplice.com/corsi-informatica/corsi-di-informatica-python/

Dettagli lezione

⏱️ Tempo stimato: 35–45 minuti
🧩 Difficoltà: Facile
🎯 Obiettivi specifici

Creare liste e tuple; accedere agli elementi con indice e slicing.
Usare i metodi principali delle liste: append, remove, sort (+ reverse, pop, insert in breve).
Comprendere immutabilità delle tuple e quando preferirle alle liste.
Conoscere differenze tra list.sort() e sorted() e gli argomenti key= e reverse=.
Applicare i concetti con esercizi realistici (tabelline, somma da 1 a n).

🧱 Che cosa sono liste e tuple

Lista (list): collezione mutabile, ordinata, indicizzabile. Puoi aggiungere, rimuovere e riordinare elementi.

Tupla (tuple): collezione immutabile, ordinata, indicizzabile. Una volta creata, non puoi modificarne gli elementi.

# Creazione
nums = [10, 20, 30]             # lista
coords = (41.9, 12.5)           # tupla
single = (42,)                  # tupla a un solo elemento → virgola necessaria
also_tuple = 1, 2, 3            # tuple packing (parentesi opzionali)

# Accesso per indice
print(nums[0])      # 10
print(coords[1])    # 12.5

# Slicing (start:stop:step)
print(nums[0:2])    # [10, 20]
print(nums[::-1])   # [30, 20, 10] (reverse)

💡 Unpacking: puoi “spacchettare” una sequenza in variabili.

x, y = coords
print(x, y)  # 41.9 12.5

Domanda per te: in quali casi preferiresti una tupla a una lista? (Pista: dati costanti, chiavi di dizionario, ritorni multipli da funzioni.)

🔧 Metodi essenziali delle liste

I metodi agiscono in place sulla lista e ritornano None. È un errore aspettarsi che restituiscano la lista modificata.

colors = ["red", "blue"]
colors.append("green")       # aggiunge in coda → ["red", "blue", "green"]
colors.remove("blue")        # rimuove la prima occorrenza → ["red", "green"]
colors.sort()                 # ordina in-place (alfabetico) → ["green", "red"]
print(colors)

list.sort() vs sorted(iterable)

nums = [3, 1, 2]
nums.sort()                   # modifica nums → [1, 2, 3]
ordered = sorted(nums, reverse=True)   # crea nuova lista → [3, 2, 1]

Ordinamenti personalizzati con key= e reverse=:

words = ["apple", "banana", "cherry", "fig"]
words.sort(key=len)           # ['fig', 'apple', 'banana', 'cherry']
print(sorted(words, key=len, reverse=True))  # per lunghezza decrescente

Altri metodi utili (panoramica rapida): insert(i, x), pop([i]), count(x), index(x), extend(iterable), clear(), reverse().

📎 Riferimenti: documentazione su metodi delle liste e comportamento “in place”.

Errore comune da evitare

Scrivere new = colors.append("green") e poi usare new. ❌ append ritorna None; la lista modificata resta in colors.

Domanda per te: quando useresti sorted() invece di list.sort() in un programma reale?

🧊 Tuple e immutabilità

Le tuple sono immutabili: non puoi aggiungere/rimuovere elementi né modificarli. Sono utili per:

rappresentare record o coordinate (dimensioni fisse),
evitare modifiche accidentali,
essere usate come chiavi in dizionari (se contengono solo elementi immutabili).

point = (10, 20)
# point[0] = 99   # ❌ TypeError: 'tuple' object does not support item assignment

# tuple ↔ list (conversioni)
nums = [1, 2, 3]
nums_t = tuple(nums)          # (1, 2, 3)
back_to_list = list(nums_t)   # [1, 2, 3]

🔍 Nota: l’immutabilità riguarda la tupla, non eventuali oggetti mutabili al suo interno.

nested = ([1, 2], 3)
nested[0].append(99)  # ✅ le liste interne sono mutabili
print(nested)         # ([1, 2, 99], 3)

Domanda per te: perché una tupla può essere una chiave di dizionario mentre una lista no?

🔎 Accesso, slicing e operazioni comuni

items = [10, 20, 30, 40, 50]
print(items[0], items[-1])     # 10 50
print(items[1:4])              # [20, 30, 40]
print(items[:3])               # [10, 20, 30]
print(items[::2])              # [10, 30, 50]

# Membership
print(30 in items)             # True

# Min/Max/Sum su liste numeriche
print(min(items), max(items), sum(items))  # 10 50 150

💡 Copia di lista: copy(), slicing [:] o list(...) creano shallow copy.

original = [[1], [2]]
shallow = original[:]   # copia superficiale
shallow[0].append(99)
print(original)         # [[1, 99], [2]]  ← attenzione agli annidamenti

Domanda per te: quando serve una deep copy e con quale modulo standard la ottieni?

🔶 Esempi pratici

1) Rubrica minimale con lista di tuple

contacts = [("Alice", "+39-111"), ("Bob", "+39-222")]
name = "Carol"
phone = "+39-333"
contacts.append((name, phone))
print(contacts)

2) Ordina prodotti per prezzo

products = [["mouse", 15.9], ["keyboard", 29.0], ["monitor", 189.0]]
products.sort(key=lambda p: p[1])
print(products)

3) Normalizza input con `remove` (pulisci placeholder)

fields = ["name", "email", "(optional)", "city"]
fields.remove("(optional)")
print(fields)

4) Unpacking elegante

user = ("alice", 27, "IT")
username, age, country = user
print(username, age, country)

Domanda per te: l’esempio 2 modifica l’ordine originale dei prodotti: in quali casi preferiresti usare sorted(products, key=...) lasciando intatta la lista?

⚠️ Errore comune da evitare

Confondere indice e valore iterando sulle liste: preferisci for x in lista invece di for i in range(len(lista)) se non ti serve l’indice.
Aspettarsi un ritorno da metodi in-place (append, remove, sort → sempre None).
Shallow vs deep copy: modificare un sotto‑elenco nella copia influenza l’originale.

📖 Sezione teorica

Liste: sequenze mutabili; metodi principali append, remove, sort (in‑place, ritorno None).
Tuple: sequenze immutabili; utili per dati costanti, hashable come chiavi, unpacking.
sort vs sorted: in‑place vs nuova lista; usa key=/reverse=.
Slicing e copy: [:], copy(), list() creano shallow copy.
Best practice: itera sugli elementi, usa variabili booleane e nomi parlanti.

🔗 Riferimenti esterni :
• Tutorial Python – Strutture dati (liste, tuple) → https://docs.python.org/3/tutorial/datastructures.html
• Built‑in types – Lista & mutabilità/ritorno None → https://docs.python.org/3/library/stdtypes.html
• FAQ di design – Immutabilità delle tuple → https://docs.python.org/3/faq/design.html

📚 Glossario tecnico

Sequenza: collezione ordinata indicizzabile (stringhe, liste, tuple).
Mutabilità: capacità di cambiare lo stato di un oggetto senza ricrearlo.
Hashable: oggetto con hash immutabile utilizzabile come chiave in un dizionario.
Shallow/Deep copy: copia superficiale/profonda degli oggetti contenuti.

📝 Esercizio finale

Usa liste e range per:

Generare la tabellina del numero n (da n×1 a n×10) in una lista e stamparla ordinata.
Calcolare la somma dei numeri da 1 a n e salvarla in una variabile total.
Dato un testo s, costruire una lista con solo le vocali presenti (minuscole) e ordinarla alfabeticamente.

Requisiti:

Usa for + range per popolare le liste.
Usa append, remove/count dove appropriato e sort/sorted.
Stampa messaggi in inglese.

Schema d’aiuto:

n = 7
s = "Programming in Python"
# Your code here...

🧠 Quiz finale

Non guardare le risposte subito! Sono più sotto 👇

Qual è la differenza principale tra lista e tupla?
A) La lista è disordinata, la tupla è ordinata
B) La lista è mutabile, la tupla è immutabile
C) La lista contiene solo numeri, la tupla solo stringhe
Cosa restituisce colors.append("blue")?
A) La lista modificata
B) True/False
C) None
Quale riga crea correttamente una tupla con un solo elemento?
A) (5)
B) (5,)
C) 5, 5
Quale chiamata non modifica la lista originale?
A) mylist.sort()
B) sorted(mylist)
C) mylist.remove(x)
Qual è l’effetto di words.sort(key=len, reverse=True)?
A) Ordina per alfabeto crescente
B) Ordina per lunghezza crescente
C) Ordina per lunghezza decrescente
Quale affermazione è vera sulle tuple?
A) Possono essere usate come chiavi di un dizionario
B) Possono cambiare lunghezza dopo la creazione
C) Hanno i metodi append e remove
Cosa stampa?

original = [[1], [2]]
copy = original[:]
copy[0].append(9)
print(original)

A) [[1], [2]]
B) [[1, 9], [2]]
C) [[9], [2]]

Qual è la forma più “pitonica” per iterare una lista?
A) for i in range(len(lst)):
B) for x in lst:
C) while i < len(lst):

❓ FAQ

1) Quando usare una tupla al posto di una lista?
Quando i dati sono fissi, devono essere hashable (es. chiavi di dict) o vuoi comunicare che non vanno modificati.

2) sort o sorted?
sort modifica in‑place e ritorna None; sorted crea una nuova lista. Usa sorted se devi preservare l’originale.

3) Posso avere elementi mutabili dentro una tupla?
Sì, ma la tupla resta immutabile; gli oggetti interni possono cambiare (attenzione agli effetti collaterali!).

4) remove elimina tutte le occorrenze?
No, solo la prima. Per tutte, usa un ciclo o una list comprehension filtrante.

5) Come copio in modo “sicuro” una lista annidata?
Usa copy.deepcopy dal modulo copy per una deep copy.

🔗 Link utili

Esterni
• Strutture dati (liste, tuple) – Tutorial Python: https://docs.python.org/3/tutorial/datastructures.html
• Tipi built‑in – comportamento e metodi delle liste: https://docs.python.org/3/library/stdtypes.html
• FAQ di design – immutabilità delle tuple: https://docs.python.org/3/faq/design.html

Interni SapereSemplice
• Lezione 2 – Primo script Python: https://www.saperesemplice.com/primo-script-python-hello/
• Lezione 3 – Variabili e Tipi di Dato: https://www.saperesemplice.com/variabili-tipi-dato-python/
• Lezione 8 – Ciclo while: https://www.saperesemplice.com/ciclo-while-python-base/
• Percorso “Corsi Python – Programmare da zero”: https://www.saperesemplice.com/corsi-informatica/corsi-di-informatica-python/

🔁 Lezione successiva

➡️ Prosegui alla Lezione 11: Set e operazioni insiemistiche
(Il link verrà inserito non appena l’articolo sarà online.)

🗨️ Hai dubbi? Lascia un commento!
📩 Vuoi il PDF della lezione? Scrivici!
🔗 Condividi con un compagno di corso.

🧪 Risposte del quiz

🗓️ Changelog

📅 Aggiornato il 29/08/2025