Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Prontuario Python6. Insiemi e tuple

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.

Python
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)  # → 0

A fare la tupla sono le virgole: le tonde servono a leggerla meglio. Per questo 3, 4 senza tonde è già una tupla.

Python
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.

Python
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.

Python
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.

Python
corse = [("M12", 7), ("M14", 12)]
for treno, minuti in corse:
    print(treno, "tra", minuti, "minuti")
# → M12 tra 7 minuti
# → M14 tra 12 minuti

Con lo spacchettamento si scambiano due valori senza una variabile di appoggio:

Python
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.

Python
def prossima_corsa():
    return "M12", 7

prossima_corsa()  # → ('M12', 7)
treno, minuti = prossima_corsa()
treno  # → 'M12'
minuti  # → 7

Più 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.

Python
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.

Python
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.

Python
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.

Python
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.

Python
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.

Python
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.

Python
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ì).

Python
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:

Python
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']