Set in Python: elementi unici, unione, intersezione e differenza

Un set è un sacchetto non ordinato di elementi unici

Dove liste e tuple tengono all'ordine, i set no. Dove le liste lasciano accumulare i duplicati, i set li scartano in silenzio. Il set è la struttura dati giusta quando hai due esigenze precise:

1. Vuoi elementi unici, punto.
2. Vuoi verificare l'appartenenza in fretta.

Si scrive con le parentesi graffe:

colors = {"red", "green", "blue"}
print(colors)

with_dupes = {"red", "green", "red", "blue", "green"}
print(with_dupes)   # {"red", "green", "blue"}

I duplicati "red" e "green" del secondo set semplicemente spariscono. Non è un errore: è proprio lo scopo.

Creare un set

I due modi che userai davvero:

# Letterale con parentesi graffe.
primes = {2, 3, 5, 7, 11}

# Da un qualsiasi iterabile.
letters = set("banana")
print(letters)

numbers = set([1, 2, 2, 3, 3, 3])
print(numbers)

# Set vuoto: bisogna usare set(), non {}
empty = set()
print(empty, type(empty))

Quest'ultimo punto frega tutti almeno una volta: {} crea un dizionario vuoto, non un set vuoto. L'ambiguità sintattica doveva cadere su uno dei due, e hanno vinto i dict.

Aggiungere e rimuovere

tags = {"python", "docs"}

tags.add("beginner")
print(tags)

tags.update(["seo", "tutorial", "python"])  # aggiunge più elementi, ignora i duplicati
print(tags)

tags.remove("seo")       # solleva KeyError se l'elemento non c'è
tags.discard("missing")  # come remove, ma silenzioso se l'elemento manca
print(tags)

popped = tags.pop()      # rimuove e restituisce un elemento qualsiasi
print("popped:", popped, "remaining:", tags)

remove contro discard è la distinzione chiave: remove pretende che l'elemento sia presente; a discard non importa. Scegli in base a se l'assenza dell'elemento debba essere un errore.

Appartenenza veloce

Ecco dove i set si guadagnano davvero il loro posto. x in some_set viene eseguito in tempo costante, per quanto grande sia il set. x in some_list deve scorrere la lista, e diventa lento quando la lista è grande.

# Immagina che questa lista abbia 1.000.000 di elementi.
known_users = set(range(1_000_000))

# Ogni controllo è quasi istantaneo.
for user_id in [42, 999_999, 1_000_001]:
    if user_id in known_users:
        print(f"{user_id}: known")
    else:
        print(f"{user_id}: unknown")

Regola pratica: ogni volta che ti ritrovi a scrivere if x in some_list dentro un ciclo, e la lista ha più di qualche decina di elementi, converti prima la lista in un set.

Matematica degli insiemi

Qui i set diventano davvero divertenti. Puoi combinarli con operatori che rispecchiano le operazioni matematiche sugli insiemi:

frontend = {"html", "css", "javascript", "react"}
backend = {"python", "sql", "javascript", "docker"}

# Unione: tutto quello che c'è in entrambi.
all_skills = frontend | backend
print(all_skills)

# Intersezione: ciò che è in comune.
shared = frontend & backend
print(shared)

# Differenza: in frontend ma non in backend.
only_frontend = frontend - backend
print(only_frontend)

# Differenza simmetrica: in uno o nell'altro, ma non in entrambi.
unique_skills = frontend ^ backend
print(unique_skills)

Ogni operatore ha anche una forma come metodo (.union(), .intersection(), .difference(), .symmetric_difference()). Gli operatori sono più compatti; i metodi accettano qualsiasi iterabile, non solo un altro set.

Eliminare i duplicati da una lista

Uno degli usi più comuni dei set, anche al di fuori della "logica degli insiemi":

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_visitors = list(set(visits))
print(unique_visitors)

Una riga, e i duplicati spariscono. Una cosa da notare: l'ordine non viene mantenuto. Se ti servono l'unicità e l'ordine originale, usa invece dict.fromkeys():

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_in_order = list(dict.fromkeys(visits))
print(unique_in_order)

Nel Python moderno i dict mantengono l'ordine di inserimento, e dict.fromkeys ne costruisce uno usando come chiavi gli elementi dell'iterabile: in pratica un set ordinato.

Sottoinsiemi e sovrainsiemi

Verificare se un set è contenuto in un altro:

known = {"python", "bash", "sql"}
required = {"python", "bash"}

print(required.issubset(known))     # True: required è dentro known
print(known.issuperset(required))   # True
print(required <= known)            # come issubset, ma con un operatore
print(known >= required)            # come issuperset

Tornano utili in cose come i controlli dei permessi ("questo utente ha tutti i ruoli richiesti?").

Cosa può stare in un set

Solo elementi hashable. È un termine tecnico; in pratica significa:

• Le cose immutabili sono hashable: numeri, stringhe, tuple di elementi hashable, frozenset.
• Le cose mutabili no: liste, dict e altri set non possono essere membri di un set.

ok = {1, "hello", (1, 2), 3.14}
print(ok)

# {[1, 2]}  # TypeError: le liste non sono hashable

Se ti serve un set di set, usa frozenset: è una versione immutabile del set.

L'iterazione non ha un ordine

Scorrere un set con un ciclo ti dà gli elementi senza un ordine garantito:

for item in {"a", "b", "c", "d"}:
    print(item)

Eseguilo qualche volta e vedrai l'ordine cambiare. Se l'ordine conta, il set non è la struttura giusta: ordina il contenuto quando ti serve, oppure usa una lista.

Quando non usare un set

Se vale una di queste condizioni, probabilmente una lista o un dict fanno più al caso tuo:

• Ti interessa l'ordine.
• Devi memorizzare dei duplicati.
• Ogni elemento ha dei dati associati (usa un dict con l'elemento come chiave).

Andiamo avanti

I set gestiscono unicità e appartenenza. I dizionari, in arrivo nella prossima pagina, gestiscono lo schema più ampio del "cercare un valore tramite una chiave", probabilmente la struttura dati più utile di Python dopo la lista.