notebook.community

Edit and run

Dizionari e insiemi

Indice

Definizione di dizionario

Costruzione di un dizionario

Dimensione di un dizionario

Accesso ai valori di un dizionario

Aggiornamento di un dizionario

Scansione delle chiavi di un dizionario

Tre metodi utili degli oggetti dizionario

Un dizionario particolare: il contatore

Costruzione di un contatore

Il metodo most_common() dei contatori

Definizione di insieme

Costruzione di un insieme tramite la funzione set()

Dimensione di un insieme

Scansione di un insieme

Operatori di confronto tra insiemi

Operazioni su un insieme

Definizione di dizionario

  • oggetto mutabile
  • oggetto di tipo dict
  • collezione di valori (anche di tipo diverso) indicizzati tramite una chiave (oggetto di tipo qualsiasi)

Tipicamente le chiavi di un dizionario sono stringhe (oggetti di tipo str).

Un dizionario può essere visto come una collezione di coppie chiave-valore.

NOTA BENE: le tuple (in quanto oggetti immutabili) possono essere le chiavi di un dizionario, al contrario di liste e dizionari che sono mutabili e quindi possono esserne solo i valori.

Costruzione di un dizionario

  • tramite letterale:
    • lista di coppie chiave-valore racchiuse tra parentesi graffe {} e separate da virgola; la chiave è separata dal suo valore dal simbolo :
  • tramite la funzione dict()

Costruzione di un dizionario tramite letterale

Dizionario vuoto:





In [98]:



    


{}



    


















    
Out[98]:








{}

Dizionario di quattro valori (oggetti di tipo int) indicizzati tramite quattro chiavi (oggetti di tipo str):





In [99]:



    


{'Silvia' : 45, 'Roberto': 47, 'Arianna' : 18, 'Tommaso' : 13}



    


















    
Out[99]:








{'Silvia': 45, 'Roberto': 47, 'Arianna': 18, 'Tommaso': 13}

Dizionario di due valori (un oggetto di tipo list e uno di tipo dict annidato) indicizzati tramite due chiavi (oggetti di tipo str):





In [100]:



    


{'pari' : [2, 4, 6, 8], 'dispari' : {'cinque' : 5, 'nove' : 9}}



    


















    
Out[100]:








{'pari': [2, 4, 6, 8], 'dispari': {'cinque': 5, 'nove': 9}}

Costruzione di un dizionario tramite la funzione dict()

Dizionario vuoto:





In [101]:



    


dict()



    


















    
Out[101]:








{}

Alla funzione dict() può essere passato come argomento una lista di tuple di dimensione due (chiave, valore).

Il seguente è il dizionario precedente di quattro valori (oggetti di tipo int) indicizzati tramite quattro chiavi (oggetti di tipo str) costruito con la funzione dict():





In [102]:



    


lista_delle_coppie_chiave_valore = [('Silvia', 45), ('Roberto', 47), ('Arianna', 18), ('Tommaso', 13)]
dict(lista_delle_coppie_chiave_valore)



    


















    
Out[102]:








{'Silvia': 45, 'Roberto': 47, 'Arianna': 18, 'Tommaso': 13}

Dimensione di un dizionario

La funzione len() restituisce la dimensione del dizionario passato come argomento, cioé il numero delle coppie (chiave, valore) contenute.





In [103]:



    


len({'uno' : 1, 'due' : 2, 'tre' : 3})



    


















    
Out[103]:








3

Accesso ai valori di un dizionario

L'istruzione:

my_dict[some_key]

restituisce il valore del dizionario my_dict che ha chiave some_key.





In [104]:



    


my_dict = {'Silvia' : 45, 'Roberto': 47, 'Arianna' : 18, 'Tommaso' : 13}
my_dict['Roberto']



    


















    
Out[104]:








47

Aggiornamento di un dizionario

Aggiornamento/Aggiunta di un valore di un dizionario

L'istruzione:

my_dict[some_key] = new_value

aggiorna il valore del dizionario my_dict che corrisponde alla chiave some_key con il nuovo valore new_value, se some_key esiste nel dizionario, altrimenti aggiunge la nuova coppia (chiave, valore) (some_key, new_value).

Esempio di aggiornamento di un valore esistente:





In [105]:



    


my_dict['Arianna'] = 19
my_dict



    


















    
Out[105]:








{'Silvia': 45, 'Roberto': 47, 'Arianna': 19, 'Tommaso': 13}

Esempio di aggiunta di un valore nuovo:





In [106]:



    


my_dict['Andrea'] = 12
my_dict



    


















    
Out[106]:








{'Silvia': 45, 'Roberto': 47, 'Arianna': 19, 'Tommaso': 13, 'Andrea': 12}

Aggiornamento di un dizionario con il metodo update()

Il metodo update() degli oggetti di tipo dict permette di aggiornare il dizionario invocante con

una lista di tuple (chiave, valore):





In [107]:



    


my_dict.update([('Chiara', 17), ('Silvia', 46)])
my_dict



    


















    
Out[107]:








{'Silvia': 46,
 'Roberto': 47,
 'Arianna': 19,
 'Tommaso': 13,
 'Andrea': 12,
 'Chiara': 17}

oppure un dizionario:





In [108]:



    


my_dict.update({'Alessandro' : 3, 'Sofia' : 15})
my_dict



    


















    
Out[108]:








{'Silvia': 46,
 'Roberto': 47,
 'Arianna': 19,
 'Tommaso': 13,
 'Andrea': 12,
 'Chiara': 17,
 'Alessandro': 3,
 'Sofia': 15}

Cancellazione in un dizionario con il metodo pop()

Il metodo pop() cancella dal dizionario invocante il valore associato alla chiave passata come argomento, e lo restituisce.





In [109]:



    


my_dict.pop('Arianna')



    


















    
Out[109]:








19

















In [110]:



    


my_dict



    


















    
Out[110]:








{'Silvia': 46,
 'Roberto': 47,
 'Tommaso': 13,
 'Andrea': 12,
 'Chiara': 17,
 'Alessandro': 3,
 'Sofia': 15}

Cancellazione in un dizionario con l'operatore del

L'istruzione:

del my_dict[some_key]

rimuovere dal dizionario my_dict il valore con chiave some_key.





In [111]:



    


del my_dict['Tommaso']
my_dict



    


















    
Out[111]:








{'Silvia': 46,
 'Roberto': 47,
 'Andrea': 12,
 'Chiara': 17,
 'Alessandro': 3,
 'Sofia': 15}

Svuotamento di un dizionario con il metodo clear()

Il metodo clear() svuota il dizionario.





In [112]:



    


my_dict.clear()
my_dict



    


















    
Out[112]:








{}

Scansione delle chiavi di un dizionario

Operatore in

L'espressione:

my_key in my_dict

restituisce il valore True (di tipo bool) se la chiave my_key è presente nel dizionario my_dict.





In [113]:



    


'Tommaso' in my_dict



    


















    
Out[113]:








False

Scansione delle chiavi con operatore in

Sintassi di scansione di un dizionario:

for key in my_dict:
    do_something

dove:

  • my_dict è il dizionario le cui chiavi sono da considerare una dopo l'altra
  • key è la variabile che durante la scansione assume il valore della chiave di volta in volta considerata
  • do_something sono le istruzioni da eseguire per ogni chiave considerata

Regole:

  • le istruzioni in do_something devono essere indentate 4 volte rispetto alla riga di intestazione
  • una riga vuota è necessaria dopo l'ultima istruzione




In [114]:



    


for key in my_dict:
    print(key)

Tre metodi utili degli oggetti dizionario

  • il metodo values() restituisce la lista (oggetto di tipo list) dei valori del dizionario invocante




In [115]:



    


my_dict = {'Silvia': 46, 'Roberto': 47, 'Andrea': 12, 'Chiara': 17}



    











In [116]:



    


my_dict.values()



    


















    
Out[116]:








dict_values([46, 47, 12, 17])
  • il metodo keys() restituisce la lista (oggetto di tipo list) delle chiavi del dizionario invocante.




In [117]:



    


my_dict.keys()



    


















    
Out[117]:








dict_keys(['Silvia', 'Roberto', 'Andrea', 'Chiara'])
  • il metodo items() restituisce la lista (oggetto di tipo list) delle tuple (chiave, valore) del dizionario invocante.




In [127]:



    


my_dict.items()



    


















    
Out[127]:








dict_items([('Silvia', 46), ('Roberto', 47), ('Andrea', 12), ('Chiara', 17)])

Un dizionario particolare: il contatore

Un contatore è un dizionario in cui valori sono oggetti di tipo int che esprimono dei conteggi. Un contatore è un oggetto di tipo Counter.

Per usare costruire e usare un contatore occorre importare l'oggetto di tipo Counter dal modulo collections:

from collections import Counter

Costruzione di un contatore

Un contatore viene costruito con il costruttore Counter() a cui viene passata come argomento una sequenza. Si ottiene un dizionario con chiavi gli elementi non duplicati della sequenza e per valori il loro numero di volte con cui sono presenti nella sequenza.





In [153]:



    


from collections import Counter

c1 = Counter('abbcdaddb')
c1



    


















    
Out[153]:








Counter({'a': 2, 'b': 3, 'c': 1, 'd': 3})

















In [154]:



    


c2 = Counter([1, 1, 1, 2, 2, 5, 6, 7, 1])
c2



    


















    
Out[154]:








Counter({1: 4, 2: 2, 5: 1, 6: 1, 7: 1})

NOTA BENE: non si può costruire un contatore su una sequenza di oggetti di tipo list in quanto le le liste sono oggetti mutabili e non possono quindi essere chiavi in un dizionario.





In [155]:



    


c3 = Counter([[1, 2], [1, 2], [3, 4]])
c3



    


















    






---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-155-b57a88019430> in <module>
----> 1 c3 = Counter([[1, 2], [1, 2], [3, 4]])
      2 c3

/anaconda3/lib/python3.7/collections/__init__.py in __init__(*args, **kwds)
    564             raise TypeError('expected at most 1 arguments, got %d' % len(args))
    565         super(Counter, self).__init__()
--> 566         self.update(*args, **kwds)
    567 
    568     def __missing__(self, key):

/anaconda3/lib/python3.7/collections/__init__.py in update(*args, **kwds)
    651                     super(Counter, self).update(iterable) # fast path when counter is empty
    652             else:
--> 653                 _count_elements(self, iterable)
    654         if kwds:
    655             self.update(kwds)

TypeError: unhashable type: 'list'

Il metodo most_common() dei contatori

Il metodo most_common() restituisce una lista di tuple di dimensione due contenenti le coppie (chiave, valore) ordinate per valore (conteggio) decrescente.





In [131]:



    


c1.most_common()



    


















    
Out[131]:








[('b', 3), ('d', 3), ('a', 2), ('c', 1)]

Definizione di insieme

  • oggetto mutabile
  • oggetto di tipo set
  • collezione di valori (anche di tipo diverso) non indicizzati (né per posizione né per chiave) e non duplicati

Costruzione di un insieme tramite la funzione set()

Qualche esempio di costruzione di un insieme con la funzione set().

Insieme vuoto:





In [162]:



    


set()



    


















    
Out[162]:








set()

Insieme delle chiavi di un dizionario:





In [163]:



    


set(my_dict)



    


















    
Out[163]:








{'Andrea', 'Chiara', 'Roberto', 'Silvia'}

Insieme dei caratteri di una stringa:





In [164]:



    


set('aaaabbbaacbaa')



    


















    
Out[164]:








{'a', 'b', 'c'}

Insieme dei valori di una lista:





In [165]:



    


set([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])



    


















    
Out[165]:








{1, 2, 3, 4, 5}

Dimensione di un insieme

La funzione len() restituisce la dimensione dell'insieme passato come argomento, cioé il numero dei valori contenuti.





In [166]:



    


len(set('aaaabbbaacbaa'))



    


















    
Out[166]:








3

Scansione di un insieme

Operatore in

L'espressione:

my_value in my_set

restituisce il valore True (di tipo bool) se il valore my_value è presente nell'insieme my_set.





In [167]:



    


'a' in set('abbacca')



    


















    
Out[167]:








True

Scansione dei valori con l'operatore in

Sintassi di scansione di un insieme:

for value in my_set:
    do_something

dove:

  • my_set è l'insieme i cui valori sono da considerare una dopo l'altro
  • value è la variabile che durante la scansione assume il valore di volta in volta considerato
  • do_something sono le istruzioni da eseguire per ogni valore considerato

Regole:

  • le istruzioni in do_something devono essere indentate 4 volte rispetto alla riga di intestazione
  • una riga vuota è necessaria dopo l'ultima istruzione




In [168]:



    


for value in set([1, 1, 2, 3, 3, 4]):
    print(value)



    


















    






1
2
3
4

Operatori di confronto tra insiemi

Le espressioni

my_set1 == my_set2
my_set1 < my_set2
my_set1 > my_set2

restituiscono True se (rispettivamente):

  • l'insieme my_set1 coincide con my_set2
  • l'insieme my_set1 è un sottoinsieme di my_set2
  • l'insieme my_set1 è un superinsieme di my_set2




In [169]:



    


set('abbbabbaba') < set('abbbaaccccaaa')



    


















    
Out[169]:








True

















In [170]:



    


set('abbbabbaba') == set('abbbaaccccaaa')



    


















    
Out[170]:








False

















In [171]:



    


set('abbbabbaba') == set('aaaaaabbbabbababbbb')



    


















    
Out[171]:








True

Operazioni su un insieme

  • il metodo add() aggiunge all'insieme invocante il valore passato come argomento




In [172]:



    


my_set = set('abbbaaccccaaa')
my_set



    


















    
Out[172]:








{'a', 'b', 'c'}

















In [173]:



    


my_set.add('d')
my_set



    


















    
Out[173]:








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

















In [174]:



    


my_set.add('a')
my_set



    


















    
Out[174]:








{'a', 'b', 'c', 'd'}
  • il metodo discard() rimuove dall'insieme invocante il valore passato come argomento (se questo è presente)




In [175]:



    


my_set.discard('a')
my_set



    


















    
Out[175]:








{'b', 'c', 'd'}

NOTA BENE: esiste anche il metodo remove() che rimuove il valore e se questo non è presente lancia un'eccezione di tipo KeyError.

  • il metodo union() restituisce l'unione tra l'insieme invocante l'insieme passato come argomento




In [176]:



    


my_set.union(set('dddeefffeffegg'))



    


















    
Out[176]:








{'b', 'c', 'd', 'e', 'f', 'g'}
  • il metodo intersection() restituisce l'intersezione tra l'insieme invocante l'insieme passato come argomento




In [177]:



    


my_set.intersection(set('dddeefffeffegg'))



    


















    
Out[177]:








{'d'}
  • il metodo difference() restituisce la differenza tra l'insieme invocante l'insieme passato come argomento (cioé tutti i valori dell'insieme invocante che non stanno nell'insieme passato come argomento)




In [178]:



    


my_set.difference(set('dddeefffeffegg'))



    


















    
Out[178]:








{'b', 'c'}
  • il metodo clear() svuota l'insieme invocante




In [179]:



    


my_set.clear()
my_set



    


















    
Out[179]:








set()

















In [ ]:

Content source: bioinformatica-corso/lezioni

Similar notebooks:

notebook.community | gallery | about