Dizionari 3 - metodi
Scarica zip esercizi
In questo foglio vedremo i metodi principali per estrarre dati e manipolare i dizionari.
Metodi:
Metodo |
Ritorna |
Descrizione |
---|---|---|
|
Ritorna una vista di chiavi che sono presenti nel dizionario |
|
|
Ritorna una vista di valori presenti nel dizionario |
|
|
Ritorna una vista di coppie (chiave, valore) presenti nel dizionario |
|
|
MODIFICA il dizionario
|
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]:
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
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
[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
[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
ediz2
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']
[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
[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']
[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
[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 = {
12:1,
11:9,
7:3,
2:5,
9:1
}
dopo il tuo codice, deve stampare False
(perchè chiave minima 2
è diversa da valore massimo 9
):
False
[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
ediz2
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}
[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 listas
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'}
[34]:
diz = {
'a':'x',
'b':'y',
'c':'z',
'd':'w'
}
s = "bx;cw;ex"
# scrivi qui
Prosegui
Prosegui con Dizionari 4: Classi speciali