Dizionari 3 - metodi

Scarica zip esercizi 

In questo foglio vedremo i metodi principali per estrarre dati e manipolare i dizionari.

Metodi:

Metodo	Ritorna	Descrizione
dict.keys()	`dict_keys`	Ritorna una vista di chiavi che sono presenti nel dizionario
dict.values()	`dict_values`	Ritorna una vista di valori presenti nel dizionario
dict.items()	`dict_items`	Ritorna una vista di coppie (chiave, valore) presenti nel dizionario
dict1.update(dict2)	`None`	MODIFICA il dizionario `dict1` con le coppie chiave / valore trovate in `dict2`

Che fare

scompatta lo zip in una cartella, dovresti ottenere qualcosa del genere:

dictionaries
    dictionaries1.ipynb
    dictionaries1-sol.ipynb
    dictionaries2.ipynb
    dictionaries2-sol.ipynb
    dictionaries3.ipynb
    dictionaries3-sol.ipynb
    dictionaries4.ipynb
    dictionaries4-sol.ipynb
    dictionaries5-chal.ipynb
    jupman.py    jupman.py

ATTENZIONE: Per essere visualizzato correttamente, il file del notebook DEVE essere nella cartella szippata.

apri il Jupyter Notebook da quella cartella. Due cose dovrebbero aprirsi, prima una console e poi un browser. Il browser dovrebbe mostrare una lista di file: naviga la lista e apri il notebook dictionaries3.ipynb
Prosegui leggendo il file degli esercizi, ogni tanto al suo interno troverai delle scritte ESERCIZIO, che ti chiederanno di scrivere dei comandi Python nelle celle successive.

Scorciatoie da tastiera:

Per eseguire il codice Python dentro una cella di Jupyter, premi Control+Invio
Per eseguire il codice Python dentro una cella di Jupyter E selezionare la cella seguente, premi Shift+Invio
Per eseguire il codice Python dentro una cella di Jupyter E creare una nuova cella subito dopo, premi Alt+Invio
Se per caso il Notebook sembra inchiodato, prova a selezionare Kernel -> Restart

keys

Chiamando il metodo .keys() possiamo ottenere tutte le chiavi del dizionario:

[2]:

verdure = {'carote':5,
           'pomodori':8,
           'cavoli':3}

[3]:

verdure.keys()

[3]:

dict_keys(['carote', 'pomodori', 'cavoli'])

ATTENZIONE: LA SEQUENZA RITORNATA E’ DI TIPO dict_keys

dict_keys potrebbe sembrare una lista ma è ben diversa !

In particolare, la sequenza dict_keys ritornata è una vista sul dizionario originale. In informatica, quando parliamo di viste di solito intendiamo collezioni che contengono una parte degli oggetti contenuti in un’altra collezione, e se la collezione originale viene modificata, si modifica contemporaneamente anche la vista.

Vediamo cosa vuol dire. Per prima cosa proviamo ad assegnare la sequenza di chiavi ad una variabile:

[4]:

chiavi = verdure.keys()

Poi modifichiamo il dizionario originale, aggiungendo una associazione:

[5]:

verdure['patate'] = 8

Se adesso stampiamo chiavi, dovremmo vedere la modifica:

[6]:

chiavi

[6]:

dict_keys(['carote', 'pomodori', 'cavoli', 'patate'])

La sequenza ritornata da ``.keys()`` può cambiare nel corso del tempo!

Quando riusi la sequenza ottenuta chiamando .keys() chiediti se nel frattempo può essere cambiata

Se vogliamo una versione stabile che sia una specie di ‘fotografia’ in un dato momento delle chiavi del dizionario, dobbiamo esplicitamente convertirle ad una altra sequenza, come per esempio list:

[7]:

come_lista = list(verdure.keys())

[8]:

come_lista

[8]:

['carote', 'pomodori', 'cavoli', 'patate']

[9]:

verdure['cetrioli'] = 9

[10]:

come_lista     # niente cetrioli

[10]:

['carote', 'pomodori', 'cavoli', 'patate']

Rivediamo l’esempio in Python Tutor:

[11]:

# AFFINCHE' PYTHON TUTOR FUNZIONI, RICORDATI DI ESEGUIRE QUESTA CELLA con Shift+Invio
#   (basta eseguirla una volta sola, la trovi anche all'inizio di ogni foglio)

import jupman

[12]:

verdure = {'carote':5,
           'pomodori':8,
           'cavoli':3}
chiavi = verdure.keys()
verdure['patate'] = 8
come_lista = list(verdure.keys())
verdure['cetrioli'] = 9
#print(come_lista)

jupman.pytut()

[12]:

Python Tutor visualization

ATTENZIONE: NON POSSIAMO ACCEDERE AD UA SPECIFICA POSIZIONE DI dict_keys

Se ci proviamo, otterremo un errore:

>>> verdure = {'carote':5,
               'pomodori':8,
               'cavoli':3}
>>> chiavi = verdure.keys()
>>> chiavi[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-90-c888bf602918> in <module>()
----> 1 chiavi[0]

TypeError: 'dict_keys' object does not support indexing

ATTENZIONE: NON POSSIAMO MODIFICARE DIRETTAMENTE dict_keys

Non vi sono operazioni o metodi che ci permettono di cambiare gli elementi di dict_keys, si può solo agire sul dizionario originale.

DOMANDA: Guarda questi frammenti di codice. Per ciascuno, prova a indovinare se può funzionare, e quale risultato produce.

diz = {'a':4,
       'b':5}

chiavi = diz.keys()
chiavi.append('c')

diz = {'a':4,
       'b':5}

chiavi = diz.keys()
chiavi.add('c')

diz = {'a':4,
       'b':5}

chiavi = diz.keys()
chiavi['c'] = 3

Mostra risposta

DOMANDA: Guarda questi frammenti di codice. Per ciascuno, prova a indovinare che risultato produce (o se da errore)

diz = {'a':1,'b':2}
s = set(diz.keys())
s.add(('c',3))
print(diz)
print(s)

diz = {'a':3,'b':4}
k = diz.keys()
diz['c'] = 5
print(len(k))

diz = {'a':'x',
       'b':'y'}
print('a' in diz.keys())

diz1 = {'a':1,'b':2}
chiavi = diz1.keys()
diz2 = dict(diz1)
diz2['c'] = 3
print('diz1=',diz1)
print('diz2=',diz2)
print('chiavi=',chiavi)

diz1 = {'a':'b','c':'d'}
diz2 = {'a':'b','b':'c'}
print( set(diz1.keys()) - set(diz2.keys())  )

diz1 = {'a':'b','c':'d'}
diz2 = {'e':'a','f':'c'}
chiavi = diz1.keys()
del diz1[diz2['e']]
del diz1[diz2['f']]
print(len(chiavi))

Esercizio - chiavi disordinate

✪ STAMPA una LISTA con tutte le chiavi del dizionario.

NOTA 1: NON è necessario che la lista sia ordinata
NOTA 2: per convertire una qualsiasi sequenza a lista, usa la funzione predefinita list

Mostra soluzione

[13]:

diz = {'c':6, 'b':2,'a':5}

# scrivi qui

Esercizio - chiavi ordinate

✪ STAMPA una LISTA con tutte le chiavi del dizionario.

NOTA 1: Adesso E’ necessario che la lista sia ordinata
NOTA 2: per convertire una qualsiasi sequenza a lista, usa la funzione predefinita list

Mostra soluzione

[14]:

diz = {'c':6, 'b':2,'a':5}

# scrivi qui

Esercizio - chiavistello

Dati i dizionari diz1 e diz2, scrivi del codice che mette in una lista chiavi tutte le chiavi dei due dizionari, senza duplicati e ordinate alfabeticamente, e infine stampa la lista.

il tuo codice deve funzionare per qualunque diz1 e diz2

Esempio - dati:

diz1 = {
    'a':5,
    'b':9,
    'e':2,

}
diz2 = {'a':9,
        'c':2,
        'e':2,
        'f':6}

dopo il tuo codice, deve risultare:

>>> print(chiavi)
['a', 'b', 'c', 'e', 'f']

Mostra soluzione

[15]:

diz1 = {
    'a':5,
    'b':9,
    'e':2,

}
diz2 = {'a':9,
        'c':2,
        'e':2,
        'f':6}


# scrivi qui

values

Dato un dizionario, è possibile ottenere tutti i valori chiamando il metodo .values()

Supponiamo di avere un dizionario veicoli che ad ogni targa di automobile assegna un proprietario:

[16]:

veicoli = {
    'AA111AA' : 'Mario',
    'BB222BB' : 'Lidia',
    'CC333CC' : 'Mario',
    'DD444DD' : 'Gino',
    'EE555EE' : 'Gino'
}

proprietari = veicoli.values()

ATTENZIONE: LA SEQUENZA RITORNATA E’ DI TIPO dict_values

dict_values può sembrare una lista ma non lo è !

Come nel caso di dict_keys, anche dict_values è una vista sul dizionario originale, quindi aggiungendo un’associazione a veicoli:

[17]:

veicoli['FF666FF'] = 'Paola'

Anche la vistaproprietari risulterà automaticamente cambiata:

[18]:

proprietari

[18]:

dict_values(['Mario', 'Lidia', 'Mario', 'Gino', 'Gino', 'Paola'])

Notiamo anche che essendo valori di un dizionario, sono ammessi duplicati.

ATTENZIONE: NON POSSIAMO ACCEDERE AD UNA SPECIFICA POSIZIONE DI dict_values

Se ci proviamo, otterremo un errore:

>>> proprietari[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-90-c888bf602918> in <module>()
----> 1 proprietari[0]

TypeError: 'dict_values' object does not support indexing

ATTENZIONE: NON POSSIAMO MODIFICARE DIRETTAMENTE dict_values

Non vi sono operazioni o metodi che ci permettono di cambiare gli elementi di dict_values, si può solo agire sul dizionario originale.

DOMANDA: Guarda questi frammenti di codice. Per ciascuno, prova a indovinare se può funzionare, e quale risultato produce.

diz = {'a':4,
       'b':5}

valori = diz.values()
valori.append(4)

d = {0:'a',
     1:'b',
     2:'b'}
vs = d.values()
d[2]='c'
print(vs)

diz = {'a':4,
       'b':5}

valori = diz.values()
valori.add(5)

diz = {0:1,
       1:2,
       2:3}

diz[list(diz.values())[0]-1]

diz = {'a':4,
       'b':5}

valori = diz.values()
valori['c'] = 6

diz = {'a':4,
       'b':5}

valori = diz.values()
valori[6] = 'c'

Esercizio - uno a uno

Dato un dizionario diz, scrivi del codice che stampa True se ad ogni chiave corrisponde un valore diverso dai valori corrispondenti a tutte le altre chiavi, altrimenti stampa False.

Esempio 1 - dati

diz = {'a' : 3,
       'c' : 6,
       'g' : 8}

Dopo il tuo codice, deve stampare True (perchè 3,6 e 8 sono tutti diversi)

True

Esempio 2 - dati

diz = {'x' : 5,
       'y' : 7,
       'z' : 5}

deve stampare

False

Mostra soluzione

[19]:

diz = {'a' : 3,
       'c' : 6,
       'g' : 8}

"""
diz = {'x' : 5,
       'y' : 7,
       'z' : 5}
"""

# scrivi qui

Esercizio - borsa

Dato un dizionario diz di associazioni tra caratteri, scrivi del codice che mette nella variabile borsa la lista ordinata di tutte le chiavi e i valori.

Esempio - dato

diz = {
    'a':'b',
    'b':'f',
    'c':'b',
    'd':'e'
}

Dopo il tuo codice, deve stampare:

>>> print(borsa)
['a', 'b', 'c', 'd', 'e', 'f']

Mostra soluzione

[20]:

diz = {
    'a':'b',
    'b':'f',
    'c':'b',
    'd':'e'
}

# scrivi qui

Esercizio - valori comuni

Dati due dizionari diz1 e diz2, scrivere del codice che STAMPA True se hanno almeno un valore in comune (senza considerare le chiavi).

Esempio 1 - dati:

diz1 = {
    'a':4,
    'k':2,
    'm':5
}

diz2 = {
    'b':2,
    'e':4,
    'g':9,
    'h':1
}

dopo il tuo codice, deve stampare True (perchè hanno i valori 2 e 4 in comune):

Hanno valori in comune? True

Esempio 2 - dati:

diz1 = {
    'd':1,
    'e':2,
    'f':6
}

diz2 = {
    'a':3,
    'b':5,
    'c':9,
    'd':7
}

dopo il tuo codice, deve stampare:

Hanno valori in comune? False

Mostra soluzione

[21]:

diz1 = {
    'a':4,
    'k':2,
    'm':5
}

diz2 = {
    'b':2,
    'e':4,
    'g':9,
    'h':1
}

"""
diz1 = {
    'd':1,
    'e':2,
    'f':6
}

diz2 = {
    'a':3,
    'b':5,
    'c':9,
    'd':7
}
"""

# scrivi qui

Esercizio - piccolo grande

Dato un dizionario diz che ha interi come chiavi e valori, stampa True se la chiave più piccola è uguale al valore più grande.

Esempio 1 - dato:

diz = {
    14:1,
    11:7,
    7:3,
    70:5
}

dopo il tuo codice, deve stampare True (perchè chiave minima 7 è uguale a valore massimo 7)

True

Esempio 2 - dato:

diz = {
1,
9,
3,
5,
1
}

dopo il tuo codice, deve stampare False (perchè chiave minima 2 è diversa da valore massimo 9):

False

Mostra soluzione

[22]:

diz = {
    14:1,
    11:7,
    7:3,
    70:5
}

"""
diz = {
    12:1,
    11:9,
    7:3,
    2:5,
    9:1
}
"""

# scrivi qui

items

Possiamo ricavare tutte le associazioni chiave/valore come lista di coppie di tipo tupla con il metodo .items(). Vediamo un esempio che associa attrazioni da visitare alla città dove si trovano:

[23]:

vacanza = {'Piazza S.Marco':'Venezia',
           'Fontana di Trevi':'Roma',
           'Uffizi':'Firenze',
           'Colosseo':'Roma',
}

[24]:

vacanza.items()

[24]:

dict_items([('Piazza S.Marco', 'Venezia'), ('Fontana di Trevi', 'Roma'), ('Uffizi', 'Firenze'), ('Colosseo', 'Roma')])

In questo caso vediamo che ci è ritornato un oggetto di tipo dict_items. Come nei precedenti casi, è una vista che non possiamo modificare direttamente. Se il dizionario originale viene cambiato, la mutazione si rifletterà sulla vista:

[25]:

attrazioni = vacanza.items()

[26]:

vacanza['Palazzo Ducale'] = 'Venezia'

[27]:

attrazioni

[27]:

dict_items([('Piazza S.Marco', 'Venezia'), ('Fontana di Trevi', 'Roma'), ('Uffizi', 'Firenze'), ('Colosseo', 'Roma'), ('Palazzo Ducale', 'Venezia')])

DOMANDA: Guarda questi frammenti di codice. Per ciascuno, prova a indovinare se può funzionare, e quale risultato produce.

```
{'a':7, 'b':9}.items()[0] = ('c',8)
```
```
dict({'a':7,'b':5}.items())['a']
```
```
len(set({'a':'b', 'a':'B'}.items()))
```
```
{'a':2}.items().find(('a',2))
```
```
{'a':2}.items().index(('a',2))
```
```
list({'a':2}.items()).index(('a',2))
```

diz1 = {'a':7,
        'b':5}
diz2 = dict(diz1.items())
diz1['a'] = 6
print(diz1 == diz2)

('a','b') in {'a':('a','b'), 'b':('a','b')}.items()

('a','b') in list({'a':('a','b'), 'b':('a','b')}.items())[0]

Esercizio - unione senza update

Dati i dizionari diz1 e diz2, scrivi del codice che crea un NUOVO dizionario diz3 contenente tutte le coppie chiave/valore da diz1 e diz2.

si suppone che tutte le coppie chiave/valore siano distinte
NON usare cicli
NON usare .update()
il tuo codice deve funzionare per qualsiasi diz1 e diz2

Esempio - dati:

diz1 = {'a':4,
        'b':7}
diz2 = {'c':5,
        'd':8,
        'e':2}

dopo il tuo codice, deve risultare (l’ordine non è importante):

>>> print(diz3)
{'a': 4, 'b': 7, 'c': 5, 'd': 8, 'e': 2}

Mostra soluzione

[28]:

diz1 = {'a':4,
        'b':7}
diz2 = {'c':5,
        'd':8,
        'e':2}

# scrivi qui

update

Avendo un dizionario di partenza, è possibile MODIFICARLO unendone un’altro con il metodo .update():

[29]:

diz1 = {'capre':6,
        'cavoli':9,
        'pastori':1}


diz2 = {'capre':12,
        'cavoli':15,
        'panche':3,
        'fieno':7}

[30]:

diz1.update(diz2)

[31]:

diz1

[31]:

{'capre': 12, 'cavoli': 15, 'pastori': 1, 'panche': 3, 'fieno': 7}

Notare come le chiavi in comune tra i dizionari come 'capre' e 'cavoli' e abbiano valori dal secondo.

Volendo, si può anche passare una sequenza di coppie così:

[32]:

diz1.update([('fieno',3),('panche',18), ('stalle',4)])

[33]:

diz1

[33]:

{'capre': 12,
 'cavoli': 15,
 'pastori': 1,
 'panche': 18,
 'fieno': 3,
 'stalle': 4}

Esercizio - axby

Dato un dizionario diz che associa caratteri a caratteri ed una stringa s formattata con coppie di caratteri come ax separate da punto e virgola ;, sostituire tutti i valori in diz con i corrispondenti valori indicati nella stringa

il tuo codice deve funzionare per qualsiasi dizionario diz e lista s

Esempio - dati

diz = {
    'a':'x',
    'b':'y',
    'c':'z',
    'd':'w'
}
s = "bx;cw;ex"

dopo il tuo codice, deve risultare

>>> diz
{'a': 'x', 'b': 'x', 'c': 'w', 'd': 'w', 'e': 'x'}

Mostra soluzione

[34]:

diz = {
    'a':'x',
    'b':'y',
    'c':'z',
    'd':'w'
}
s = "bx;cw;ex"

# scrivi qui

Prosegui

Prosegui con Dizionari 4: Classi speciali

Dizionari 3 - metodi

Scarica zip esercizi

Che fare

keys

Esercizio - chiavi disordinate

Esercizio - chiavi ordinate

Esercizio - chiavistello

values

Esercizio - uno a uno

Esercizio - borsa

Esercizio - valori comuni

Esercizio - piccolo grande

items

Esercizio - unione senza update

update

Esercizio - axby

Prosegui

Scarica zip esercizi 