Operazioni sugli insiemi (ad esempio, determinare insiemi di unione, insiemi di prodotti e sottoinsiemi) con il tipo di insiemi di Python

Attività commerciale

Python fornisce un tipo di dati built-in, set, che gestisce gli insiemi.

Il tipo set è una collezione di elementi non duplicati (elementi che non hanno lo stesso valore, elementi unici) e può eseguire operazioni di set come set di unione, set di prodotti e set di differenze.

In questa sezione, le operazioni di base nelle operazioni di tipo set sono spiegate con codice di esempio.

  • Creazione di oggetti set: {},set()
  • notazione di inclusione degli insiemi
  • Numero di elementi nell'insieme:len()
  • Aggiungere un elemento a un insieme:add()
  • Rimuovere un elemento da un insieme: discard(),remove(),pop(),clear()
  • Wasset (fusione, unione):|operatore,union()
  • Insiemi di prodotti (parti comuni, intersezioni, incroci):& operatore,intersection()
  • complemento relativo:-operatore,difference()
  • set di differenze di simmetria:^ operatore,symmetric_difference()
  • sottoinsieme o no:<= operatore,issubset()
  • Set superiore o no:>= operatore,issuperset()
  • Determinazione se sono reciprocamente primi o no:isdisjoint()

Il tipo set è un tipo mutabile che può aggiungere e cancellare elementi, e c'è anche un tipo frozenset che ha la stessa operazione set e altri metodi del tipo set ma è immutabile (non può essere modificato aggiungendo, cancellando o modificando in altro modo gli elementi).

Creazione dell'oggetto set:: {}, set()

Generato da parentesi d'onda {}

Gli oggetti di tipo set possono essere creati racchiudendo gli elementi tra parentesi graffe {}.

Se ci sono valori duplicati, vengono ignorati e solo i valori unici rimangono come elementi.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

È possibile avere diversi tipi come elementi. Tuttavia, gli oggetti aggiornabili come i tipi di lista non possono essere registrati. Le tuple sono permesse.

Inoltre, poiché i tipi di set non sono ordinati, l'ordine in cui sono generati non viene memorizzato.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Tipi diversi, come int e float, sono considerati duplicati se i loro valori sono equivalenti.

s = {100, 100.0}

print(s)
# {100}

Poiché una parentesi vuota {} è considerata un tipo di dizionario, un oggetto di tipo set vuoto (empty set) può essere creato usando il costruttore descritto qui di seguito.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Generato dal costruttore set()

Gli oggetti di tipo set possono anche essere creati con il costruttore set().

Specificando un oggetto iterabile come una lista o una tupla come argomento si genera un oggetto set i cui elementi sono solo valori unici, con elementi duplicati esclusi.

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

I tipi frozenset immutabili sono creati con il costruttore 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 creato un oggetto di tipo set vuoto (set vuoto).

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

Gli elementi duplicati possono essere rimossi da una lista o tupla usando set(), ma l'ordine della lista originale non viene conservato.

Per convertire un tipo di insieme in una lista o tupla, usate list(),tuple().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

Vedi il seguente articolo per informazioni su come rimuovere elementi duplicati preservando l'ordine, estrarre solo elementi duplicati ed elaborare elementi duplicati in un array bidimensionale (lista di liste).

notazione di inclusione degli insiemi

Oltre alle comprensioni di liste, ci sono le comprensioni di insiemi. Basta sostituire le parentesi quadre [] con le parentesi graffe {} nelle comprensioni di lista.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

Vedi il seguente articolo per maggiori informazioni sulla notazione di comprensione della lista.

Numero di elementi nell'insieme: len()

Il numero di elementi in un insieme può essere ottenuto con la funzione built-in len().

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

Se volete contare il numero di elementi in ogni lista che ha elementi con valori duplicati, ecc.

Aggiungere un elemento a un insieme: add()

Per aggiungere un elemento a un insieme, usate il metodo add().

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Rimuovere un elemento da un insieme: discard(),remove(),pop(),clear()

Per rimuovere un elemento da un insieme, usate i metodi discard(), remove(), pop() e clear().

Il metodo discard() elimina l'elemento specificato nell'argomento. Se viene specificato un valore che non esiste nell'insieme, non viene fatto nulla.

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 nell'argomento, ma viene restituito un errore KeyError se viene specificato un valore che non esiste nell'insieme.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Il metodo pop() rimuove elementi da un insieme e restituisce i loro valori. Non è possibile selezionare quali valori rimuovere. Un insieme vuoto risulterà in un errore KeyError.

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 e rende l'insieme vuoto.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (fusione, unione): |operatore, union()

L'insieme di unione (merger, union) può essere ottenuto con l'operatore | o con 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}

Si possono specificare più argomenti per un metodo. Oltre al tipo set, anche le liste e le tuple che possono essere convertite al tipo set da set() possono essere specificate come argomenti. Lo stesso vale per gli operatori e i metodi successivi.

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}

Insiemi di prodotti (parti comuni, intersezioni, incroci): & operatore, intersection()

L'insieme dei prodotti (parte comune, intersezione e intersezione) può essere ottenuto con l'operatore & o il metodo intersection().

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}

complemento relativo: -operatore, difference()

L'insieme delle differenze può essere ottenuto con l'operatore – o con 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}

set di differenze di simmetria: ^ operatore, symmetric_difference()

L'insieme delle differenze simmetriche (l'insieme degli elementi contenuti in uno solo dei due) può essere ottenuto con l'operatore ^ o con symmetric_difference().

Equivalente alla disgiunzione esclusiva (XOR) nelle operazioni logiche.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

sottoinsieme o no: <= operatore, issubset()

Per determinare se un insieme è un sottoinsieme di un altro insieme, usate 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 vero per insiemi equivalenti.

Per determinare se è un vero sottoinsieme, usate l'operatore <=, che restituisce falso per gli insiemi equivalenti.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Set superiore o no: >= operatore, issuperset()

Per determinare se un insieme è un superset di un altro, usate 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 vero per gli insiemi equivalenti.

Per determinare se è un vero superset, usate l'operatore >=, che restituisce falso per gli insiemi equivalenti.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Determinazione se sono reciprocamente primi o no: isdisjoint()

Per determinare se due insiemi sono primi l'uno dell'altro, usate il metodo isdisjoint().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True