Insiemi¶

Riferimenti: SoftPython - insiemi 1

  • visualizza al meglio in
  • versione stampabile: clicca qua
  • per navigare nelle slide: premere Esc


Summer School Data Science 2023 - Modulo 1 informatica: Moodle

Docente: David Leoni david.leoni@unitn.it

Esercitatore: Luca Bosotti luca.bosotti@studenti.unitn.it

Insiemi - set¶

Un insieme è una collezione mutabile senza ordine di elementi immutabili e distinti
(cioè senza duplicati)

Riferimenti: SoftPython, insiemi

In [2]:
s = {'d','a','e','b','c'}
In [3]:
type(s)
Out[3]:
set
In [4]:
print(s)

{'b', 'a', 'd', 'c', 'e'}

ATTENZIONE: L'ORDINE NEGLI INSIEMI *NON* E' GARANTITO!

*NON* CREDERE A QUELLO CHE VEDI !!

Ordine stampa $\neq$ ordine creazione¶

Potrebbe anche variare:

  • a seconda della versione di Python
  • ad ogni esecuzione!!

Attenzione a s senza print in Jupyter:

In [5]:
s
Out[5]:
{'a', 'b', 'c', 'd', 'e'}

Ordine alfabetico!

  • Motivo: Jupyter stampa implicitamente con la pprint (pretty print)

Che succederà qui?¶

Un insieme è una collezione mutabile senza ordine di elementi immutabili e distinti (cioè senza duplicati)

s = { [1,2,3], [4,5] }

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_5526/4233786676.py in <module>
----> 1 s = { [1,2,3], [4,5] }

TypeError: unhashable type: 'list'

La funzione hash 1/2¶

Applicabile solo a oggetti immutabili

In [6]:
hash("pietra")
Out[6]:
707262961973574043

Dato un oggetto immutabile, lo analizza per calcolare un numero

In [7]:
hash("""
        Gli opposti sono frammenti di un'unica realtà 
        che permane immutabile e racchiude dentro di sé il cambiamento.
""")
Out[7]:
2199981108035071583

Tipicamente, la dimensione del numero è molto più piccola dell'oggetto

La funzione hash 2/2¶

In [8]:
hash(70)
In [9]:
Out[9]:
70
In [33]:
hash( (39,10,10,20,30,20,10,40,50,20,30,40,10,60,40,30,70,10,30,20,60,10) )
In [34]:
Out[34]:
-5434522281529851832
hash(  (10,[20,30],40,50)   )

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_5526/4244286395.py in <module>
----> 1 hash( (39,[10, 20  ]) )

TypeError: unhashable type: 'list'

Posso creare questo insieme?

{ {'n','a'}, {'s','t','y'} }

Rimuovere duplicati¶

Possiamo creare un set a partire da un'altra sequenza:

In [36]:
set( 'acacia' )
Out[36]:
{'a', 'c', 'i'}

Gli insiemi sono utili per rimuovere duplicati da una sequenza

In [38]:
set( [1,2,3,1,2,1,2,1,3,1] ) # da lista
Out[38]:
{1, 2, 3}

Law & order¶

Ha senso ricavare un elemento a partire da un indice?

s = {'d','u','b','b','i','o','s','o'}
s[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_7970/446717835.py in <module>
      1 s = {'d','u','b','b','i','o','s','o'}
----> 2 s[0]

TypeError: 'set' object is not subscriptable
In [45]:
print(s)

{'i', 'u', 'b', 'd', 's', 'o'}

Se proprio, proprio, PROPRIO vi serve qualcosa di indicizzabile..

In [51]:
la = list(s)
la[0]
Out[51]:
'i'

Insieme vuoto¶

Per creare un insieme vuoto dobbiamo chiamare la funzione set():

In [14]:
s = set()

ATTENZIONE: Se scrivi {} otterrai un dizionario, NON un insieme !!!

Operatori insiemi¶

Operatore Esempio Risultato Descrizione
lunghezza len(set) int il numero di elementi nel set
appartenenza object in set bool verifica se elemento è contenuto nel set
unione set | set set crea un NUOVO set
intersezione set & set set crea un NUOVO set
differenza set - set set crea un NUOVO set
differenza simmetrica set ^ set set crea un NUOVO set
uguaglianza ==,!= bool Controlla se due insiemi sono uguali o differenti

Riferimento: SoftPython - Insiemi

Appartenenza¶

Un elemento IMMUTABILE è contenuto in un insieme?

In [15]:
'a' in {'m','e','n','t','a'}
Out[15]:
True

Negli insiemi: la velocità dell'operatore in NON dipende dalla dimensione della collezione

in NEGLI INSIEMI E' UN'OPERAZIONE MOLTO VELOCE

Per stringhe, liste e tuple: la velocità di in dipende dalla dimensione -> molto più lenta

ATTENZIONE: Cercare elementi mutabili in insiemi non è consentito:

['e','f'] in { ('c','d'), ('a','b')}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_29295/1711245333.py in <module>
----> 1 ['a','b'] in { ('c','d'), ('a','b'), ('e','f') }

TypeError: unhashable type: 'list'

Possiamo cercare una tupla?¶

In [16]:
('a','b') in { 'ab', 'cd' }
In [17]:
Out[17]:
False
In [18]:
('a','b') in { ('a','b'), ('c','d') }
In [19]:
Out[19]:
True

non appartenza¶

Due forme

In [20]:
not "carota" in {"anguria", "banana", "mela"}
Out[20]:
True
In [21]:
"carota" not in {"anguria","banana","mela"}
Out[21]:
True

Sono uguali?¶

In [22]:
{1,2,3} == {3,1,2}
In [23]:
{1,2,3} == {3,3,1,1,2,2}

Metodi simili agli operatori 1/2¶

Metodi che creano un NUOVO set e sono analoghi agli operatori |, &, -, ^

NOTA: diversamente dagli operatori, questi metodi accettano come parametro una qualsiasi sequenza, non solo insiemi:

Metodo Risultato Descrizione Operatore analogo
set.union(seq) set unione, crea un NUOVO set |
set.intersection(seq) set intersezione, crea un NUOVO set &
set.difference(seq) set differenza, crea un NUOVO set -
set.symmetric_difference(seq) set differenza simmetrica, crea un NUOVO set ^

Riferimenti: SoftPython - Insiemi

Metodi simili agli operatori 2/2¶

Metodi che MODIFICANO il primo insieme su cui sono chiamati (e ritornano None!):

Metodo Risultato Descrizione
setA.update(setB) None unione, MODIFICA setA
setA.intersection_update(setB) None intersezione, MODIFICA setA
setA.difference_update(setB) None differenza, MODIFICA setA
setA.symmetric_difference_update(setB) None differenza simmetrica, MODIFICA setA

Riferimenti: SoftPython - Insiemi

Altri metodi¶

Metodo Risultato Descrizione
set.add(el) None aggiunge l'elemento specificato - se già presente non fa nulla)
set.remove(el) None rimuove l'elemento specificato - se non presente solleva errore
set.discard(el) None rimuove l'elemento specificato - se non presente non fa nulla
set.pop() object rimuove un elemento arbitrario dall'insieme e lo ritorna
set.clear() None rimuove tutti gli elementi
setA.issubset(setB) bool verifica se setA è un sottoinsieme di setB
setA.issuperset(setB) bool verifica se setA contiene tutti gli elementi di setB
setA.isdisjoint(setB) bool verifica se setA non ha elementi in comune con setB

Riferimenti: SoftPython - Insiemi

add¶

Dato un insieme, possiamo aggiungergli un elemento con il metodo .add:

In [24]:
s = {3,7,4}
In [25]:
s.add(5)
In [26]:
s
Out[26]:
{3, 4, 5, 7}

Se aggiungiamo lo stesso elemento due volte, non accade nulla:

In [27]:
s.add(5)
In [28]:
s
Out[28]:
{3, 4, 5, 7}

remove¶

Il metodo remove toglie un elemento specificato dall'insieme. Se non esiste, produce un errore:

In [29]:
s = {'a','b','c'}
In [30]:
s.remove('b')
In [31]:
s
Out[31]:
{'a', 'c'}
s.remove('z')

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-266-a9e7a977e50c> in <module>
----> 1 s.remove('z')

KeyError: 'z'
In [32]: