In Python, set è una raccolta di elementi non sovrapposti (elementi univoci). Può eseguire sugli insiemi come unione, intersezione, differenza, operazioni differenza simmetrica e così via.
In questo articolo vengono descritti i seguenti contenuti.
Operazioni di base:
- Crea un oggetto impostato:
{}, set() - Stabilisci le comprensioni
- Ottieni il numero di elementi nel set:
len() - Aggiungi un elemento al set:
add() - Rimuovere un elemento dal set:
discard(), remove(), pop(), clear()
Operazioni matematiche:
- Unione:
| operator, union() - Intersezione:
& operator, intersection() - Differenza:
- operator, difference() - Differenza simmetrica:
^ operator, symmetric_difference() - Verifica se A è un sottoinsieme di B:
<= operator, issubset() - Verifica se A è un superinsieme di B:
>= operator, issuperset() - Verifica se A e B sono disgiunti:
isdisjoint()
Il tipo set è un tipo mutabile che può aggiungere e rimuovere elementi. Python fornisce anche il tipo frozenset, che ha metodi per operazioni di set come set ma è immutabile. frozenset non può essere modificato aggiungendo o rimuovendo elementi.
Crea un oggetto impostato:{}, set()
Crea un oggetto impostato con parentesi graffe {}
gli oggetti set possono essere creati racchiudendo gli elementi tra parentesi graffe {}.
Se sono presenti valori duplicati, vengono ignorati e solo i valori univoci come rimanere elementi.
s = {1, 2, 2, 3, 1, 4}
print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>
set può avere elementi di tipo diverso ma non può avere oggetti mutabili come list.
Il tipo di set non è ordinato, quindi l’ordine in cui è stato creato non viene mantenuto.
s = {1.23, 'abc', (0, 1, 2), 'abc'}
print(s)
# {(0, 1, 2), 1.23, 'abc'}
# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'
Anche se i tipi sono diversi, come int e float, sono considerati duplicati se i valori sono uguali.
s = {100, 100.0}
print(s)
# {100}
Poiché un {} vuoto è considerato un dizionario dict, è possibile creare un insieme vuoto utilizzando set() di seguito.
s = {}
print(s)
print(type(s))
# {}
# <class 'dict'>
Crea un oggetto impostato con set()
gli oggetti set possono anche essere creati con set().
Specificando un oggetto iterabile come un elenco o una tupla come argomento, viene creato un oggetto impostato in cui vengono esclusi gli elementi duplicati e rimangono solo valori univoci.
l = [1, 2, 2, 3, 1, 4]
print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>
s_l = set(l)
print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>
Per un frozenset immutabile, usa frozenset().
fs_l = frozenset(l)
print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>
Se l’argomento viene omesso, viene generato un set vuoto.
s = set()
print(s)
print(type(s))
# set()
# <class 'set'>
È possibile utilizzare set() per rimuovere elementi da un elenco o da tupla, ma l’ordine originale non viene mantenuto.
Usa list() e tuple() per un set in una lista o in una tupla.
l = [2, 2, 3, 1, 3, 4]
l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]
Vedere l’articolo seguente per rimuovere elementi duplicati nell’ordine originale o estrarre solo elementi duplicati.
Stabilisci le comprensioni
Python fornisce comprensioni di insiemi e comprensioni di elenchi. Usa parentesi graffe {} invece di parentesi quadre [].
s = {i**2 for i in range(5)}
print(s)
# {0, 1, 4, 9, 16}
Vedere l’articolo seguente per ulteriori informazioni sulla comprensione degli elenchi.
Ottieni il numero di elementi nel set:len()
Il numero di elementi dell’insieme può essere ottenuto con la funzione incorporata len().
s = {1, 2, 2, 3, 1, 4}
print(s)
print(len(s))
# {1, 2, 3, 4}
# 4
Se vuoi contare il numero occorrenze in un elenco con elementi duplicati, consulta il seguente articolo.
Aggiungi un elemento al set:add()
Utilizzare il metodo add() per aggiungere un elemento all’insieme.
s = {0, 1, 2}
s.add(3)
print(s)
# {0, 1, 2, 3}
Rimuovere un elemento dal set:discard(), remove(), pop(), clear()
Utilizzare i metodi disget(), remove(), pop() e clear() per rimuovere un elemento dall’insieme.
Il metodo require() elimina l’elemento specificato dall’argomento. Se viene specificato un valore che non esiste nel set, non viene eseguita alcuna azione.
s = {0, 1, 2}
s.discard(1)
print(s)
# {0, 2}
s = {0, 1, 2}
s.discard(10)
print(s)
# {0, 1, 2}
Il metodo remove() rimuove anche l’elemento specificato dall’argomento, ma genera un errore KeyError se viene specificato un valore che non esiste nel set.
s = {0, 1, 2}
s.remove(1)
print(s)
# {0, 2}
# s = {0, 1, 2}
# s.remove(10)
# KeyError: 10
Il metodo pop() rimuove un elemento dall’insieme e ne restituisce il valore. Non puoi scegliere quali valori rimuovere. Genera un errore KeyError se il set è vuoto.
s = {2, 1, 0}
v = s.pop()
print(s)
print(v)
# {1, 2}
# 0
s = {2, 1, 0}
print(s.pop())
# 0
print(s.pop())
# 1
print(s.pop())
# 2
# print(s.pop())
# KeyError: 'pop from an empty set'
Il metodo clear() rimuove tutti gli elementi dal set e lo svuota.
s = {0, 1, 2}
s.clear()
print(s)
# set()
Unione:| operator, union()
È possibile ottenere l’unione con il | operatore o il metodo union().
s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}
s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}
s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}
È possibile specificare più argomenti per unione().
Inoltre, non solo set, ma anche elenchi e tuple che possono essere convertiti in set da set() possono essere specificati come argomenti. Lo stesso vale per i seguenti metodi.
s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}
s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}
Intersezione:& operator, intersection()
È possibile ottenere l’intersezione con l’operatore & o il metodo intersezione().
s_intersection = s1 & s2
print(s_intersection)
# {1, 2}
s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}
s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}
Differenza:- operator, difference()
Puoi ottenere la differenza con l’operatore – o il metodo Difference().
s_difference = s1 - s2
print(s_difference)
# {0}
s_difference = s1.difference(s2)
print(s_difference)
# {0}
s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}
Differenza simmetrica:^ operator, symmetric_difference()
Puoi ottenere la differenza simmetrica con l’operatore ^ o symmetric_difference().
s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}
s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
Verifica se A è un sottoinsieme di B:<= operator, issubset()
Per verificare se A è un sottoinsieme di B, cioè se tutti gli elementi di A sono contenuti in B, utilizzare l’operatore <= o il metodo issubset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s1 <= s2)
# True
print(s1.issubset(s2))
# True
Sia l’operatore <= che il metodo issubset() restituiscono True per gli insiemi equivalenti.
Per verificare se un insieme è un sottoinsieme, utilizzare l’operatore <, che richiede False per gli insiemi equivalenti.
print(s1 <= s1)
# True
print(s1.issubset(s1))
# True
print(s1 < s1)
# False
Verifica se A è un superinsieme di B:>= operator, issuperset()
Per verificare se A è un superinsieme di B, cioè se tutti gli elementi di B sono contenuti in A, usa l’operatore >= o issuperset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s2 >= s1)
# True
print(s2.issuperset(s1))
# True
Sia l’operatore >= che il metodo issuperset() restituiscono True per gli insiemi equivalenti.
Per verificare se un insieme è un superinsieme, utilizzare l’operatore >, che richiede False per gli insiemi equivalenti.
print(s1 >= s1)
# True
print(s1.issuperset(s1))
# True
print(s1 > s1)
# False
Verifica se A e B sono disgiunti:isdisjoint()
Per verificare se A e B sono disgiunti, cioè se A e B non hanno elementi comuni, utilizzare il metodo isdisjoint().
s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}
print(s1.isdisjoint(s2))
# False
print(s1.isdisjoint(s3))
# True