Ottenere un sottoinsieme

4.1 Ottenere un sottoinsieme tramite regola

Un sottoinsieme è un insieme in cui tutti gli elementi appartengono a un altro insieme più grande. In Python ci sono diversi metodi e operatori integrati per lavorare con i sottoinsiemi. Di seguito, ti spiegherò come ottenere i sottoinsiemi, come verificare se un insieme è sottoinsieme di un altro, e come utilizzare queste conoscenze in vari scenari.

Uso del ciclo for

Puoi creare un insieme vuoto e aggiungere elementi che soddisfano la condizione usando un ciclo for.

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set()
            
for x in my_set:
    if x % 2 == 0:
        even_set.add(x)
            
print(even_set)  # Risultato: {2, 4, 6, 8, 10}
        

Questo è il modo più semplice e diretto per creare un sottoinsieme. Ma ci sono anche altri metodi più compatti.

Uso della funzione filter()

La funzione filter() applica una funzione a ogni elemento e restituisce solo quegli elementi per i quali la funzione restituisce True. Il risultato deve essere convertito nuovamente in un insieme.

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set(filter(lambda x: x % 2 == 0, my_set))
print(even_set)  # Risultato: {2, 4, 6, 8, 10}
        

All'interno della funzione filter() si usa un'espressione lambda – è un modo breve per definire una funzione o regola per il filtraggio. Parlerò delle lambda tra poche lezioni.

4.2 Uso di generatori di insiemi

Ricordi List Comprehension? Quando usavamo le parentesi quadre per generare rapidamente una lista e i suoi elementi? Questo strumento sintattico aveva questo aspetto:

[espressione for variabile in sequenza]

Dove:

• variabile — identificatore di una variabile,
• sequenza — sequenza di valori che la variabile assume (può essere una lista, una stringa o un oggetto ottenuto con la funzione range),
• espressione — un'espressione generalmente dipendente dalla variabile usata nel generatore, che popolerà gli elementi della lista.

Per gli insiemi c'è una funzione analoga, ma bisogna usare le parentesi graffe:

{espressione for variabile in sequenza}

I generatori di insiemi permettono di creare facilmente e concisamente nuovi insiemi basati su insiemi esistenti, applicando condizioni di filtraggio.

Ecco come puoi selezionare solo gli elementi pari da un insieme:

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = {x for x in my_set if x % 2 == 0} 
print(even_set)  # Risultato: {2, 4, 6, 8, 10} 

Ecco come selezionare solo le stringhe:

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, "apple", "banana"}
even_set = {x for x in my_set if type(x) == str}
print(even_set)  # Risultato: {"apple", "banana"}

4.3 Verifica della presenza di un elemento

Una delle operazioni principali che si possono eseguire con gli insiemi è la verifica della presenza di un elemento nell'insieme. In Python ci sono diversi modi per farlo. Esaminiamo i vari metodi per controllare se un elemento è presente in un insieme.

Uso dell'operatore in

Il modo più comune e conveniente per verificare la presenza di un elemento in un insieme è usare l'operatore in. Questo metodo restituisce True se l'elemento è presente nell'insieme, e False altrimenti.

my_set = {1, 2, 3, 4, 5}
print(3 in my_set)  # Risultato: True
print(6 in my_set)  # Risultato: False
            

Uso dell'operatore not in

L'operatore not in è l'opposto dell'operatore in e viene utilizzato per verificare che un elemento non sia presente in un insieme. Restituisce True se l'elemento non è presente nell'insieme, e False altrimenti.

my_set = {1, 2, 3, 4, 5}
print(6 not in my_set)  # Risultato: True
print(3 not in my_set)  # Risultato: False

Uso dei cicli

Sebbene l'uso dei cicli per verificare la presenza di un elemento in un insieme non sia il metodo più efficiente, può essere utile in situazioni in cui si lavora con strutture dati più complesse o si eseguono operazioni aggiuntive.

my_set = {1, 2, 3, 4, 5}
element = 3
found = False
            
for item in my_set:
    if item == element:
        found = True
        break
            
print(found)  # Risultato: True
        

4.4 Verifica dell'inclusione degli insiemi

Python fornisce l'operatore <= e il metodo issubset() per verificare se un insieme è sottoinsieme di un altro.

Uso dell'operatore <=

L'operatore <= consente di verificare facilmente se un insieme è sottoinsieme di un altro.

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
            
print(set_a <= set_b)  # Risultato: True
print(set_b <= set_a)  # Risultato: False
            
        

Uso del metodo issubset()

Il metodo issubset() svolge la stessa funzione dell'operatore <=, e restituisce True se tutti gli elementi di un insieme sono contenuti in un altro.

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
            
print(set_a.issubset(set_b))  # Risultato: True
print(set_b.issubset(set_a))  # Risultato: False
        

Verifica del sovrainsieme

Analogamente ai sottoinsiemi, puoi verificare se un insieme è sovrainsieme di un altro, utilizzando l'operatore >= e il metodo issuperset().

Uso dell'operatore >=

set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
            
print(set_a >= set_b)  # Risultato: True
print(set_b >= set_a)  # Risultato: False
            
        

Uso del metodo issuperset()

set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
            
print(set_a.issuperset(set_b))  # Risultato: True
print(set_b.issuperset(set_a))  # Risultato: False