Metodi dei Set Python – Riferimento Completo con Esempi

I set Python sono collezioni non ordinate di elementi unici e hashable. Poiché i set implementano il concetto matematico di insieme, dispongono di una ricca raccolta di metodi integrati per combinarli, confrontarli e modificarli. Questo capitolo tratta ogni metodo integrato dei set con esempi chiari, output atteso e indicazioni su quando scegliere un metodo rispetto a un altro.

Se sei nuovo ai set, leggi prima Python Sets per capire come vengono creati e perché differiscono da liste e tuple.

Creazione dei set

Usa le parentesi graffe {} o il costruttore set() per creare un set. Il costruttore accetta anche qualsiasi iterabile — una lista, una tupla o una string — e rimuove automaticamente i duplicati.

fruits = {'apple', 'banana', 'cherry'}
colors = set(['red', 'green', 'blue'])   # from a list
vowels = set('aeiou')                    # from a string → {'a', 'e', 'i', 'o', 'u'}

empty = set()   # NOT {} — that creates an empty dict

I set non sono ordinati: l'ordine stampato degli elementi può variare tra esecuzioni diverse e versioni di Python.

Metodi per le operazioni sui set

Questi metodi combinano o confrontano due o più set senza modificare gli originali.

union()

union(*others) restituisce un nuovo set contenente ogni elemento che appare nel set corrente o in uno qualsiasi degli others.

L'operatore | è la scorciatoia equivalente per due set: A | B.

Quando usarlo: per unire più collezioni rimuovendo i duplicati in un solo passaggio.

intersection()

intersection(*others) restituisce un nuovo set contenente solo gli elementi che appaiono nel set corrente e in ognuno degli others.

L'operatore & è la scorciatoia per due set: A & B.

Quando usarlo: per trovare elementi comuni — ad esempio, utenti che hanno cliccato sia sull'annuncio A che sull'annuncio B.

difference()

difference(*others) restituisce un nuovo set di elementi che sono nel set corrente ma non in nessuno degli others.

L'operatore - è la scorciatoia: A - B.

Quando usarlo: per filtrare un gruppo da un altro — ad esempio, trovare prodotti in magazzino ma non ancora spediti.

symmetric_difference()

symmetric_difference(other) restituisce un nuovo set di elementi che appaiono in esattamente uno dei due set — gli elementi che non sono condivisi.

L'operatore ^ è la scorciatoia: A ^ B.

Quando usarlo: per rilevare cosa è cambiato tra due istantanee — ad esempio, file aggiunti o eliminati tra due elenchi di directory.

issubset()

issubset(other) restituisce True se ogni elemento del set corrente è presente anche in other.

L'operatore <= è equivalente; usa < per verificare un sottoinsieme proprio (A è più piccolo di B ed è completamente contenuto in esso).

issuperset()

issuperset(other) restituisce True se il set corrente contiene ogni elemento di other.

A = {1, 2, 3, 4, 5}
B = {2, 3}

print(A.issuperset(B))   # True
print(B.issuperset(A))   # False

L'operatore >= è equivalente; usa > per verificare un soprainsieme proprio.

isdisjoint()

isdisjoint(other) restituisce True se i due set non hanno elementi in comune — la loro intersezione è vuota.

A = {1, 2, 3}
B = {4, 5, 6}
C = {3, 4, 5}

print(A.isdisjoint(B))   # True  — no overlap
print(A.isdisjoint(C))   # False — 3 is in both

Quando usarlo: per validare categorie non sovrapposte, verificare che due insiemi di permessi siano mutuamente esclusivi.

Metodi di aggiornamento in-place

Questi metodi modificano il set in-place e restituiscono None — non creano un nuovo set.

update()

update(*others) aggiunge tutti gli elementi da uno o più iterabili nel set corrente, ignorando i duplicati.

update() accetta qualsiasi iterabile, non solo un altro set — anche una lista, una tupla o una string vanno bene. L'operatore |= è la scorciatoia per due set.

intersection_update()

intersection_update(*others) mantiene solo gli elementi presenti anche in ognuno degli others, eliminando tutto il resto.

A = {1, 2, 3, 4}
B = {2, 3, 4, 5}

A.intersection_update(B)
print(A)   # {2, 3, 4}

L'operatore &= è la scorciatoia.

difference_update()

difference_update(*others) rimuove dal set corrente ogni elemento che appare in uno qualsiasi degli others.

A = {1, 2, 3, 4}
B = {3, 4, 5}

A.difference_update(B)
print(A)   # {1, 2}

L'operatore -= è la scorciatoia.

symmetric_difference_update()

symmetric_difference_update(other) mantiene solo gli elementi che appaiono in esattamente uno dei due set, aggiornando in-place.

A = {1, 2, 3}
B = {2, 3, 4}

A.symmetric_difference_update(B)
print(A)   # {1, 4}

L'operatore ^= è la scorciatoia.

Metodi per la manipolazione degli elementi

add()

add(elem) inserisce elem nel set. Se elem è già presente, il set rimane invariato.

Vedi Adding Set Items per altri modi di popolare un set.

remove()

remove(elem) rimuove elem dal set. Solleva KeyError se elem non è presente.

Usa remove() quando l'elemento deve essere nel set e un'assenza inaspettata è un errore di programmazione che vale la pena segnalare.

discard()

discard(elem) rimuove elem dal set. Non solleva un errore se elem è assente.

Usa discard() quando l'elemento potrebbe o non potrebbe essere nel set e vuoi semplicemente che venga rimosso.

pop()

pop() rimuove e restituisce un elemento arbitrario. Poiché i set non sono ordinati, non è possibile prevedere quale elemento viene rimosso. Solleva KeyError se il set è vuoto.

Vedi Removing Set Items per un confronto di tutti gli approcci di rimozione.

clear()

clear() rimuove ogni elemento, lasciando un set vuoto.

Nota che print(set()) mostra set(), non {}, per distinguere un set vuoto da un dict vuoto.

copy()

copy() restituisce una copia superficiale del set. La modifica della copia non influisce sull'originale.

A = {1, 2, 3}
B = A.copy()

B.add(4)
print(A)   # {1, 2, 3}  — unchanged
print(B)   # {1, 2, 3, 4}

Questo è importante perché un'assegnazione semplice (B = A) crea un secondo riferimento allo stesso set — le modifiche a B influenzerebbero anche A.

Metodo vs. operatore: quale preferire?

La maggior parte delle operazioni sui set ha sia una forma con metodo che una forma con operatore:

Differenza chiave: i metodi accettano qualsiasi iterabile come argomento, mentre gli operatori richiedono che entrambi i lati siano set. Usa i metodi quando vuoi operare su una lista o una tupla direttamente senza convertirla prima:

tags = {'python', 'web'}
new_tags = ['python', 'ml', 'data']

tags.update(new_tags)         # works — list is fine
# tags |= new_tags            # TypeError — operator needs a set
print(tags)   # {'python', 'web', 'ml', 'data'}

Riferimento completo ai metodi dei set

Esercitazione