Insiemi e tuple
tuple, spacchettare, più valori da una funzione, set, add, remove, discard, unione, intersezione e differenza
Due contenitori meno famosi della lista. La tupla è una lista che non si può cambiare: un gruppo di valori che stanno insieme. L'insieme (set) è un sacchetto senza doppioni e senza ordine. Ogni voce dice a cosa serve un'operazione, mostra un esempio da provare e la cosa da ricordare. Nel codice, # → dice cosa vale quella riga, o cosa stampa.
Creare una tupla
Tra tonde, invece che tra quadre. Si legge come una lista: indici, fette, len, in, for, tutto come nel capitolo Liste e cicli.
corsa = ("M12", "Porta Codice", 7)
corsa # → ('M12', 'Porta Codice', 7)
corsa[0] # → 'M12'
corsa[-1] # → 7
len(corsa) # → 3
"Porta Codice" in corsa # → True
type(corsa) # → <class 'tuple'>
posizione = 3, 4
posizione # → (3, 4)
vuota = ()
len(vuota) # → 0A fare la tupla sono le virgole: le tonde servono a leggerla meglio. Per questo 3, 4 senza tonde è già una tupla.
sola = ("M12",)
sola # → ('M12',)
type(sola) # → <class 'tuple'>
non_tupla = ("M12")
non_tupla # → 'M12'
type(non_tupla) # → <class 'str'>Le tuple non si cambiano
Una tupla, una volta creata, resta com'è: niente append, niente assegnazione a una posizione. Si dice che è immutabile.
corsa = ("M12", "Porta Codice", 7)
corsa[2] = 8 # → TypeError: 'tuple' object does not support item assignment
corsa.append("Largo Lista") # → AttributeError: 'tuple' object has no attribute 'append'
corsa = ("M12", "Porta Codice", 8)
corsa # → ('M12', 'Porta Codice', 8)
lista = list(corsa)
lista[2] = 9
tuple(lista) # → ('M12', 'Porta Codice', 9)Per «cambiarla» ne crei una nuova e ci attacchi la stessa etichetta, oppure la trasformi in lista, la cambi e torni alla tupla. Si usa una tupla quando i valori stanno insieme e non devono cambiare: un treno con la sua fermata e i minuti, una coppia di coordinate. E una tupla, a differenza di una lista, può fare da chiave.
Spacchettare
Dai a ogni valore della tupla la sua etichetta, in una riga sola. Le etichette a sinistra devono essere tante quanti i valori.
corsa = ("M12", "Porta Codice", 7)
treno, fermata, minuti = corsa
treno # → 'M12'
minuti # → 7
print(treno, "a", fermata, "tra", minuti, "minuti") # → M12 a Porta Codice tra 7 minuti
treno, fermata = corsa # → ValueError: too many values to unpack (expected 2)Funziona anche nel for, quando scorri una lista di tuple: è lo stesso meccanismo di for chiave, valore in d.items() e di enumerate.
corse = [("M12", 7), ("M14", 12)]
for treno, minuti in corse:
print(treno, "tra", minuti, "minuti")
# → M12 tra 7 minuti
# → M14 tra 12 minutiCon lo spacchettamento si scambiano due valori senza una variabile di appoggio:
primo, secondo = "Lucia", "Ivo"
primo, secondo = secondo, primo
primo # → 'Ivo'
secondo # → 'Lucia'Restituire più valori da una funzione
Una funzione consegna una cosa sola, ma quella cosa può essere una tupla. Scrivi i valori dopo il return, separati da virgole; chi chiama li spacchetta.
def prossima_corsa():
return "M12", 7
prossima_corsa() # → ('M12', 7)
treno, minuti = prossima_corsa()
treno # → 'M12'
minuti # → 7Più esempi, e il resto sulle funzioni, nella pagina Le funzioni.
Tuple come chiavi di un dizionario
Una chiave deve essere un valore che non cambia: la tupla va bene, la lista no. Serve quando la chiave è fatta di due pezzi, per esempio una tratta, da una fermata all'altra.
tempi = {("Porta Codice", "Largo Lista"): 6, ("Largo Lista", "Ponte Ciclo"): 4}
tempi[("Porta Codice", "Largo Lista")] # → 6
tempi["Porta Codice", "Largo Lista"] # → 6
("Largo Lista", "Porta Codice") in tempi # → False
{["Porta Codice", "Largo Lista"]: 6} # → TypeError: unhashable type: 'list'In una tupla l'ordine conta: ("Largo Lista", "Porta Codice") è un'altra chiave, il viaggio al contrario. Le chiavi spiegate per bene: I dizionari.
Creare un insieme
Tra graffe come un dizionario, ma senza i due punti: solo valori. I doppioni spariscono da soli.
binari = {3, 1, 2, 3, 1}
binari # → {1, 2, 3}
len(binari) # → 3
set([4, 4, 2]) # → {2, 4}
binari[0] # → TypeError: 'set' object is not subscriptable
fermate = {"Ponte Ciclo", "Largo Lista", "Ponte Ciclo"}
len(fermate) # → 2
sorted(fermate) # → ['Largo Lista', 'Ponte Ciclo']Un insieme non ha ordine, quindi non ha indici: per guardarci dentro usi in o un for. Se ti serve una lista in ordine, sorted(...).
L'insieme vuoto è set()
Le graffe vuote sono un dizionario, non un insieme: il dizionario è arrivato prima. Per un insieme vuoto si scrive set(), ed è così che Python lo mostra.
vuoto = set()
vuoto # → set()
type(vuoto) # → <class 'set'>
graffe = {}
type(graffe) # → <class 'dict'>
graffe.add(3) # → AttributeError: 'dict' object has no attribute 'add'Se vedi 'dict' object has no attribute 'add', cerca un = {} dove volevi un insieme.
Togliere i doppioni
Passare da una lista a un insieme toglie i doppioni. Così sai quanti elementi diversi ci sono.
letture = ["B-03", "B-01", "B-03", "B-02", "B-01"]
len(letture) # → 5
len(set(letture)) # → 3
sorted(set(letture)) # → ['B-01', 'B-02', 'B-03']
list(dict.fromkeys(letture)) # → ['B-03', 'B-01', 'B-02']sorted(set(...)) ti dà la lista senza doppioni in ordine alfabetico. Se vuoi tenere l'ordine di arrivo, list(dict.fromkeys(...)): un dizionario ha le chiavi uniche e ricorda l'ordine. list(set(...)) invece ti dà un ordine qualsiasi.
add()
Aggiunge un elemento. Se c'è già, non succede niente: nessun errore, nessun doppione.
giorni = {1, 4}
giorni.add(6)
giorni.add(4)
giorni # → {1, 4, 6}
len(giorni) # → 3
giorni.append(2) # → AttributeError: 'set' object has no attribute 'append'Si chiama add, non append: un insieme non ha un «in fondo» dove attaccare le cose.
remove() e discard()
Tutti e due tolgono un elemento. La differenza è quando l'elemento non c'è: remove si ferma con KeyError, discard non dice niente.
giorni = {1, 3, 5}
giorni.remove(3)
giorni # → {1, 5}
giorni.remove(4) # → KeyError: 4
giorni.discard(4)
giorni.discard(5)
giorni # → {1}È la stessa scelta tra d[chiave] e get nei dizionari: remove quando l'elemento deve esserci (se manca è un bug), discard quando può mancare davvero.
in
Chiede se un elemento c'è. Su un insieme è velocissimo, anche con un milione di elementi: Python non li guarda uno alla volta, va dritto al posto giusto, come con le chiavi di un dizionario.
abilitati = {"B-01", "B-02", "B-07"}
"B-02" in abilitati # → True
"B-09" in abilitati # → False
"B-09" not in abilitati # → True
letture = ["B-02", "B-09", "B-07", "B-09"]
[badge for badge in letture if badge not in abilitati] # → ['B-09', 'B-09']Su una lista, invece, in guarda un elemento alla volta finché non trova. Se devi chiedere «c'è?» tante volte, trasforma la lista in insieme una volta sola, prima del for.
Unione, intersezione e differenza
Tre modi di mettere insieme due insiemi. Qui ci sono i giorni della settimana in cui guidano Lucia e Ivo (1 è lunedì).
lucia = {1, 2, 3, 5}
ivo = {3, 4, 5}
lucia | ivo # → {1, 2, 3, 4, 5}
lucia & ivo # → {3, 5}
lucia - ivo # → {1, 2}
ivo - lucia # → {4}
lucia # → {1, 2, 3, 5}lucia | ivo, l'unione: i giorni in cui guida almeno uno dei due.lucia & ivo, l'intersezione: i giorni in cui guidano tutti e due.lucia - ivo, la differenza: i giorni di Lucia in cui Ivo non guida. Qui l'ordine conta:ivo - luciaè un'altra cosa.
Gli insiemi di partenza non cambiano: ogni operazione ne fa uno nuovo. Con i nomi al posto dei simboli si scrive lucia.union(ivo), lucia.intersection(ivo) e lucia.difference(ivo). Con le stringhe, passa da sorted per avere un ordine fisso:
abilitati = {"B-01", "B-02", "B-07"}
presenti = {"B-02", "B-07", "B-09"}
sorted(abilitati & presenti) # → ['B-02', 'B-07']
sorted(presenti - abilitati) # → ['B-09']