In questo tutorial imparerai le basi dei set Python e i vari metodi di set che puoi usare per modificare i set Python.
I set sono una delle strutture dati integrate in Python. Quando devi lavorare con una raccolta di elementi non ripetuta, utilizzerai il set come struttura di dati di riferimento.
Nelle seguenti diverse sezioni, esamineremo le basi dei set di Python e i metodi di impostazione che puoi utilizzare per lavorarci. Impareremo quindi come eseguire operazioni di set comuni in Python.
Cominciamo!
Sommario:
Nozioni di base sui set Python
In Python, un set è una raccolta non ordinata di elementi non ripetuti. Ciò significa che gli elementi in un insieme dovrebbero essere tutti distinti.
Puoi aggiungere e rimuovere elementi da un set; pertanto, il set è una collezione mutevole. Può contenere elementi di diversi tipi di dati. Tuttavia, i singoli elementi in un set dovrebbero esserlo hashable.
In Python, un oggetto si dice hash se il suo valore hash non cambia mai. La maggior parte degli oggetti immutabili come stringhe Python, tuple e dizionari sono hashable.
Impareremo come creare set in dettaglio. Per ora, considera i seguenti due insiemi:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
Il primo set contiene tre numeri, una tupla e una stringa. L’inizializzazione del set viene eseguita senza errori. Considerando che il secondo set contiene una lista invece di una tupla. Un elenco è una raccolta mutabile, non può essere sottoposto a hash e l’inizializzazione genera un TypeError.
📑 Mettendo tutto insieme, possiamo definire un set Python come una raccolta mutevole di elementi distinti e hashable.
Come creare un set Python
Inizieremo imparando come creare un set in Python.
# 1. Utilizzo dell’inizializzazione esplicita
Puoi creare un set in Python specificando gli elementi del set, separati da virgole (,) e racchiusi tra un paio di parentesi graffe {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Se hai già lavorato con gli elenchi Python, lo sai [] inizializza un elenco vuoto. Anche se un set Python è racchiuso tra una coppia di parentesi graffe {}, non puoi usare una coppia {} per inizializzare un set. Questo perché {} inizializza un dizionario Python e non un set Python.
py_set2 = {}
type(py_set2)
# Output
dict
Puoi di nuovo chiamare la funzione type() per verificare che py_set sia un dizionario (dict).
#2. Usando la funzione set()
Se desideri inizializzare un set vuoto e quindi aggiungere elementi ad esso, puoi farlo utilizzando la funzione set().
py_set3 = set() type(py_set3) # Output set
#3. Casting di altri iterabili in un set
Un altro modo per creare insiemi è lanciare altri iterabili, come liste e tuple, in insiemi, usando set(iterable).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set
Nell’esempio sopra, py_list contiene due volte ‘C’. Ma in py_set4, ‘C’ appare solo una volta, poiché l’insieme è una raccolta di elementi distinti. Questa tecnica di casting nel set viene spesso utilizzata per rimuovere i duplicati dagli elenchi Python.
Come aggiungere elementi a un set Python
Iniziamo creando un set vuoto py_set e lavoriamo con esso per il resto di questo tutorial.
py_set = set() len(py_set) # returns the length of a set # Output 0
# 1. Utilizzando il metodo .add()
Per aggiungere elementi a un set, puoi usare il metodo .add(). set.add(elemento) aggiunge un elemento al set.
Per chiarezza, aggiungeremo elementi al set Python e stamperemo il set ad ogni passaggio.
▶️ Aggiungiamo la stringa ‘Python’ come elemento a py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Successivamente, aggiungeremo un altro elemento.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
È importante capire che il metodo .add() aggiunge un elemento al set solo se non è già presente. Se il set contiene già l’elemento che desideri aggiungere, l’operazione di aggiunta non ha effetto.
Per verificarlo, proviamo ad aggiungere ‘C++’ a py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Il set contiene ‘C++’, quindi l’operazione di aggiunta non ha effetto.
▶️ Aggiungiamo qualche elemento in più al set.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Utilizzando il metodo .update()
Finora, abbiamo visto come aggiungere elementi all’insieme esistente, un elemento alla volta.
Cosa succede se desideri aggiungere più di un elemento a una sequenza di elementi?
Puoi farlo usando il metodo .update() con la sintassi: set.update(raccolta) per aggiungere elementi nella collezione a un set. La raccolta può essere un elenco, una tupla, un dizionario e così via.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Questo metodo è utile quando si desidera aggiungere una raccolta di elementi a un set senza creare un altro oggetto in memoria.
Nella prossima sezione, impariamo come rimuovere elementi da un set.
Come rimuovere elementi da un set Python
Consideriamo il seguente set (py_set prima dell’operazione di aggiornamento).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
# 1. Utilizzando il metodo .pop()
set.pop() rimuove un elemento in modo casuale dal set e lo restituisce. Chiamiamo il metodo pop su py_set e vediamo cosa restituisce.
py_set.pop() # Output 'Rust'
Questa volta, la chiamata al metodo .pop() ha restituito la stringa ‘Rust’.
Nota: poiché il metodo .pop() restituisce un elemento a caso, quando esegui il codice alla tua estremità, potresti anche ottenere un altro elemento.
Quando esaminiamo il set, “Rust” non è più presente nel set.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Utilizzando i metodi .remove() e require()
In pratica, potresti voler rimuovere elementi specifici dal set. Per fare ciò, puoi usare i metodi .remove() e .discard().
set.remove(elemento) rimuove gli elementi dal set.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Se proviamo a rimuovere un elemento non presente nel set, ci imbatteremo in un KeyError.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Diamo un’occhiata a py_set di nuovo. Ora abbiamo tre elementi.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Con la sintassi set.discard(elemento), il metodo .discard() rimuove anche gli elementi dal set.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Tuttavia, differisce dal metodo .remove() in quanto non genera un KeyError quando si tenta di rimuovere un elemento che non è presente.
Se proviamo a rimuovere ‘Scala’ (che non esiste) dall’elenco utilizzando il metodo .discard(), non vediamo alcun errore.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Come accedere agli elementi di un set Python
Finora, abbiamo imparato come aggiungere e rimuovere elementi dai set Python. Tuttavia, non abbiamo ancora visto come accedere ai singoli elementi in un set.
Poiché un set è una raccolta non ordinata, non è indicizzabile. Pertanto, se provi ad accedere agli elementi di un set utilizzando l’indice, ti imbatterai in un errore, come mostrato.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Quindi, come si accede agli elementi in un set?
Ci sono due modi comuni per farlo:
- Scorri il set e accedi a ciascun elemento
- Controlla se un particolare elemento è un membro dell’insieme
▶️ Scorri il set e accedi agli elementi utilizzando un ciclo for.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
In pratica, potresti voler controllare se un dato elemento è presente nell’insieme usando l’operatore in.
Nota: l’elemento nell’insieme restituisce True se l’elemento è presente nell’insieme; altrimenti restituisce False.
In questo esempio, py_set contiene ‘C++’ e non contiene ‘Julia’ e l’operatore in restituisce rispettivamente True e False.
'C++' in py_set # True 'Julia' in py_set # False
Come trovare la lunghezza di un set Python
Come visto in precedenza, puoi usare la funzione len() per ottenere il numero di elementi presenti in un insieme.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Come cancellare un set Python
Per cancellare un set rimuovendo tutti gli elementi, puoi usare il metodo .clear().
Chiamiamo il metodo .clear() su py_set.
py_set.clear()
Se provi a stamparlo, otterrai set() – indicando che il set è vuoto. Puoi anche chiamare la funzione len() per verificare che la lunghezza dell’insieme sia zero.
print(py_set) # set() print(len(py_set)) # 0
Finora, abbiamo imparato come eseguire operazioni CRUD di base sui set Python:
- Crea: utilizzando la funzione set(), il casting del tipo e l’inizializzazione
- Leggi: Accedi agli elementi del set utilizzando i loop e nell’operatore per il test di appartenenza
- Aggiorna: aggiungi, rimuovi elementi dai set e aggiorna i set
- Elimina: cancella un set rimuovendo tutti gli elementi da esso
Operazioni comuni sugli insiemi, spiegate con il codice Python
I set Python ci consentono anche di eseguire le operazioni di base sugli insiemi. Impareremo su di loro in questa sezione.
# 1. Unione di insiemi in Python
Nella teoria degli insiemi, l’unione di due insiemi è l’insieme di tutti gli elementi in almeno uno dei due insiemi. Se ci sono due insiemi, A e B, allora l’unione contiene elementi che sono presenti solo in A, solo in B, e gli elementi presenti sia in A che in B.
Per trovare l’unione degli insiemi, puoi usare | operatore o .union() il metodo con la sintassi: setA.union(setB).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
L’unione degli insiemi è un’operazione commutativa; quindi AUB è uguale a BU A. Verifichiamo questo scambiando le posizioni di setA e setB nella chiamata al metodo .union().
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Intersezione di insiemi in Python
Un’altra operazione di insiemi congiunti è questa intersezione di due insiemi, A e B. L’operazione di intersezione di insiemi restituisce un insieme che contiene tutti gli elementi presenti sia in A che in B.
Per calcolare l’intersezione, puoi usare l’operatore & o il metodo .intersection(), come spiegato nel frammento di codice seguente.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
In questo esempio, l’elemento 9 è presente sia in setA che in setB; quindi l’insieme di intersezioni contiene solo questo elemento.
Come l’unione degli insiemi, anche l’intersezione degli insiemi è un’operazione commutativa.
setB.intersection(setA)
# Output
{9}
#3. Imposta la differenza in Python
Dati due insiemi qualsiasi, unione e intersezione ci aiutano a trovare gli elementi presenti rispettivamente in entrambi e almeno in uno degli insiemi. D’altra parte, la differenza di insiemi ci aiuta a trovare gli elementi presenti in un insieme ma non nell’altro.
– setA.difference(setB) fornisce l’insieme di elementi che sono presenti solo in setA e non in setB.
– setB.difference(setA) fornisce l’insieme di elementi che sono presenti solo in setB e non in setA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Chiaramente, AB non è uguale a BA, quindi la differenza di insieme non è un’operazione commutativa.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Differenza di insieme simmetrica in Python
Mentre l’intersezione degli insiemi ci fornisce elementi presenti in entrambi gli insiemi, la differenza simmetrica degli insiemi restituisce l’insieme degli elementi presenti esattamente in uno degli insiemi.
Considera il seguente esempio.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Per calcolare l’insieme di differenze simmetriche, puoi usare l’operatore ^ o il metodo .symmetric_difference().
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Gli elementi 10 e 12 sono presenti sia in setA che in setB. Quindi non sono presenti nell’insieme delle differenze simmetriche.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Poiché l’operazione di differenza di insiemi simmetrica raccoglie tutti gli elementi che appaiono esattamente in uno dei due insiemi, l’insieme risultante è lo stesso indipendentemente dall’ordine in cui gli elementi vengono raccolti. Pertanto, una differenza di insieme simmetrica è un’operazione commutativa.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Sottoinsiemi e Superinsiemi in Python
Nella teoria degli insiemi, sottoinsiemi e superinsiemi aiutano a comprendere la relazione tra due insiemi.
Dati due insiemi A e B, l’insieme B è un sottoinsieme dell’insieme A se tutti gli elementi dell’insieme B sono presenti anche nell’insieme A. E l’insieme A è il superinsieme dell’insieme B.
Considera l’esempio di due insiemi: lingue e lingue_estese.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
In Python, puoi usare il metodo .issubset() per verificare se un determinato insieme è un sottoinsieme di un altro insieme.
setA.issubset(setB) restituisce True se setA è un sottoinsieme di setB; altrimenti restituisce False.
In questo esempio, le lingue è un sottoinsieme di lingue_estese.
languages.issubset(languages_extended) # Output True
Allo stesso modo, puoi usare il metodo .issuperset() per verificare se un determinato insieme è un superinsieme di un altro insieme.
setA.issuperset(setB) restituisce True se setA è un superset di setB; altrimenti restituisce False.
languages_extended.issuperset(languages) # Output True
Poiché le lingue_estese è un superset di lingue, le lingue_estese.issuperset(lingue) restituisce True, come visto sopra.
Conclusione
Spero che questo tutorial ti abbia aiutato a capire il funzionamento degli insiemi Python, i metodi degli insiemi per le operazioni CRUD e le operazioni degli insiemi comuni. Come passaggio successivo, puoi provare a usarli nei tuoi progetti Python.
Puoi dare un’occhiata ad altre guide Python approfondite. Buon apprendimento!