Funzioni 7 - esercizi coi dizionari
Scarica zip esercizi
stampa_val
✪ Scrivi la funzione stampa_val(d,chiave)
che RITORNA il valore associato a chiave
>>> x = stampa_val({'a':5,'b':2}, 'a')
>>> x
5
>>> y = stampa_val({'a':5,'b':2}, 'b')
>>> y
2
[1]:
# scrivi qui
ha_chiave
Scrivi la funzione ha_chiave(d,chiave)
che STAMPA "trovate"
se diz
contiene la chiave chiave
, altrimenti STAMPA "non trovato"
.
>>> ha_chiave({'a':5,'b':2}, 'a')
trovato
>>> ha_chiave({'a':5,'b':2}, 'z')
non trovato
[2]:
# scrivi qui
dim
✪ Scrivi la funzione dim(d)
che RITORNA le associazioni chiave valore presenti nel dizionario
>>> x = dim({'a':5,'b':2,'c':9})
>>> x
3
[3]:
# scrivi qui
mazzol
✪ Dato un dizionario, scrivi una funzione mazzol
che RITORNA una LISTA ORDINATA con tutte le chiavi, una alla volta.
NOTA: l’ordine delle chiavi in questa lista E’ importante !
>>> x = mazzol({'a':5,'c':2,'b':9})
>>> x
['a','b','c']
[4]:
# scrivi qui
coppie
✪ Dato un dizionario, scrivi una funzione coppie
che STAMPA tutte le coppie chiave/valore, una per riga
NOTA: l’ordine di stampa NON è importante, è sufficiente stampare tutte le coppie !
>>> coppie({'a':5,'b':2,'c':9})
a 5
c 9
b 2
[5]:
# scrivi qui
Funzioni con assert
ATTENZIONE
Gli esercizi che segueno contengono dei test con gli assert. Per capire come svolgerli, leggi prima Gestione errori e testing
istogramma
✪✪ RITORNA un NUOVO dizionario. contenente una chiave per ogni carattere di stringa. A ciascuna chiave sarà associato come valore il numero di occorrenze del relativo carattere in stringa
Ingredienti:
variabile dizionario da ritornare
ciclo for (dobbiamo iterare su stringa)
NON usare
Counter
[6]:
def istogramma(stringa):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert istogramma("") == {}
assert istogramma("a") == {'a':1}
assert istogramma("aa") == {'a':2}
assert istogramma("aaa") == {'a':3}
assert istogramma("ba") == {'a':1,
'b':1}
assert istogramma("aba") == {'a':2,
'b':1}
assert istogramma("abc") == {'a':1,
'b':1,
'c':1}
assert istogramma("acccbb") == {'a':1,
'b':2,
'c':3}
listifica
✪✪ Prende un dizionario d
come input e RITORNA una LISTA con soli i valori dal dizionario (quindi nessuna chiave)
Per avere un ordine prevedibile, la funzione prende anche come input una lista ordine
dove vi sono chiavi dal primo dizionario ordinate come le vorremmo vedere nella lista risultante
[7]:
def listifica(d, ordine):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError
assert listifica({}, []) == []
assert listifica({'ciao':123}, ['ciao']) == [123]
assert listifica({'a':'x','b':'y'}, ['a','b']) == ['x','y']
assert listifica({'a':'x','b':'y'}, ['b','a']) == ['y','x']
assert listifica({'a':'x','b':'y','c':'x'}, ['c','a','b']) == ['x','x','y']
assert listifica({'a':'x','b':'y','c':'x'}, ['b','c','a']) == ['y','x','x']
assert listifica({'a':5,'b':2,'c':9}, ['b','c','a']) == [2,9,5]
assert listifica({6:'x',8:'y',3:'x'}, [6,3,8]) == ['x','x','y']
# FINE TEST
tcont
✪✪ Prende una lista di tuple. Ogni tupla ha due valori, il primo è un oggetto immutabile e il secondo un numero intero (il conteggio dell’oggetto). RITORNA un dizionario che per ogni oggetto immutabile trovato nelle tuple, associa il conteggio totale trovato.
Per esempi vedere gli assert
Mostra soluzione[8]:
def tcont(lst):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert tcont([]) == {}
assert tcont([('a',3)]) == {'a':3}
assert tcont([('a',3),('a',4)]) == {'a':7}
assert tcont([('a',3),('b',8), ('a',4)]) == {'a':7, 'b':8}
assert tcont([('a',5), ('c',8), ('b',7), ('a',2), ('a',1), ('c',4)]) == {'a':5+2+1, 'b':7, 'c': 8 + 4}
# FINE TEST
✪✪ Scrivi una funzione inter(d1,d2)
che prende due dizionari e RITORNA un SET di chiavi per le quali la coppia è la stessa in entrambi i dizionari
Esempio:
>>> a = {'chiave1': 1, 'chiave2': 2 , 'chiave3': 3}
>>> b = {'chiave1': 1 ,'chiave2': 3 , 'chiave3': 3}
>>> inter(a,b)
{'chiave1','chiave3'}
[9]:
def inter(d1, d2):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert inter({'key1': 1, 'key2': 2 , 'key3': 3}, {'key1':1 ,'key2':3 , 'key3':3}) == {'key1', 'key3'}
assert inter(dict(), {'key1':1 ,'key2':3 , 'key3':3}) == set()
assert inter({'key1':1 ,'key2':3 , 'key3':3}, dict()) == set()
assert inter(dict(),dict()) == set()
# FINE TEST
valori_unici
✪✪ Scrivi una funzione valori_unici(d)
che RITORNA una lista di valori unici dal dizionario. La lista DEVE essere ordinata alfanumericamente.
Domanda: ci serve ordinata per fini di test. Come mai?
per ordinare la lista, usa il metodo
.sort()
Esempio:
>>> valori_unici({'a':'y','b':'x','c':'x'})
['x','y']
[10]:
def valori_unici(d):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert valori_unici({}) == []
assert valori_unici({'a':'y','b':'x','c':'x'}) == ['x','y']
assert valori_unici({'a':4,'b':6,'c':4,'d':8}) == [4,6,8]
# FINE TEST
maiuscole
✪✪ RITORNA un dizionario che associa ad ogni stringa nella lista fornita la stessa stringa ma con tutte le lettere in maiuscolo
Esempio:
>>> `maiuscole(["ciao", "mondo", "come va?"])`
{"ciao":"CIAO", "mondo":"MONDO", "come va?":"COME VA?"}
Ingredienti:
- ciclo `for`
- metodo `.upper()`
[11]:
def maiuscole(lista):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert maiuscole([]) == {}
assert maiuscole(["ciao"]) == {"ciao":"CIAO"}
assert maiuscole(["ciao", "mondo"]) == {"ciao":"CIAO", "mondo":"MONDO"}
assert maiuscole(["ciao", "mondo", "ciao"]) == {"ciao":"CIAO", "mondo":"MONDO"}
assert maiuscole(["ciao", "mondo", "come va?"]) == {"ciao":"CIAO", "mondo":"MONDO", "come va?":"COME VA?"}
# FINE TEST
filtraz
✪✪ RITORNA un NUOVO dizionario, che contiene solo le chiavi/valori del dizionario diz in ingresso nella cui chiave è presente la lettera ‘z’
Esempio:
filtraz({'zibibbo':'da bere',
'mc donald': 'da evitare',
'liquirizia': 'ze best',
'burger king': 'zozzerie'
})
deve RITORNARE il NUOVO dizionario
{
'zibibbo':'da bere',
'liquirizia': 'ze best'
}
In altre parole, abbiamo solo tenuto quelle chiavi che contenevano almeno una 'z'
. Se nei valori ci sono z
non ce ne curiamo.
Ingredienti:
Per vedere se ‘z’ è nella chiave, usare l’operatore in
per es
'z' in 'zibibbo' == True
'z' in 'mc donald' == False
[12]:
def filtraz(diz):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert filtraz({}) == {}
assert filtraz({'az':'t'}) == {'az':'t'}
assert filtraz({'zc':'w'}) == {'zc':'w'}
assert filtraz({'b':'h'}) == {}
assert filtraz({'b':'hz'}) == {}
assert filtraz({'az':'t','b':'hz'}) == {'az':'t'}
assert filtraz({'az':'t','b':'hz','zc':'w'}) == {'az':'t', 'zc':'w'}
# FINE TEST
powers
✪✪ RITORNA un dizionario in cui le chiavi sono numeri interi da 1 a n
inclusi, e i rispettivi valori sono i quadrati delle chiavi
Esempio:
powers(3)
Ritorna
{
1:1,
2:4,
3:9
}
[13]:
def powers(n):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert powers(1) == {1:1}
assert powers(2) == {
1:1,
2:4
}
assert powers(3) == {
1:1,
2:4,
3:9
}
assert powers(4) == {
1:1,
2:4,
3:9,
4:16
}
# FINE TEST
dilist
✪✪ Restituisce un dizionario con n
coppie chiave-valore, dove le chiavi sono numeri interi da 1
a n
incluso, e ad ogni chiave i
è associata una lista di numeri da 1
a i
NOTA: le chiavi sono numeri interi, NON stringhe !!!!!
Esempio:
dilist(3)
deve dare:
{
1:[1],
2:[1,2],
3:[1,2,3]
}
[14]:
def dilist(n):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert dilist(0) == dict()
assert dilist(1) == {
1:[1]
}
assert dilist(2) == {
1:[1],
2:[1,2]
}
assert dilist(3) == {
1:[1],
2:[1,2],
3:[1,2,3]
}
# FINE TEST
prefissi
✪✪ Scrivere una funzione prefissi
che dati:
un dizionario
diz
avente come chiavi province italiane e come valori i loro prefissi telefonici (nota: anche i prefissi sono stringhe!)una lista
province
con le province italiane
RITORNA una lista di prefissi corrispondenti alle province della lista passata
Esempio:
prefissi({
'tn':'0461',
'bz':'0471',
'mi':'02',
'to':'011',
'bo':'051'
},
['tn','to', 'mi'])
deve ritornare
['0461', '011', '02']
SUGGERIMENTI:
inizializzare lista vuota da ritornare
scorrere la lista di province e pescarsi i corrispondenti prefissi dal dizionario
[15]:
def prefissi(diz, province):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert prefissi({'tn':'0461'}, []) == []
assert prefissi({'tn':'0461'}, ['tn']) == ['0461']
assert prefissi({'tn':'0461', 'bz':'0471'}, ['tn']) == ['0461']
assert prefissi({'tn':'0461', 'bz':'0471'}, ['bz']) == ['0471']
assert prefissi({'tn':'0461', 'bz':'0471'}, ['tn','bz']) == ['0461', '0471']
assert prefissi({'tn':'0461', 'bz':'0471'}, ['bz','tn']) == ['0471', '0461']
assert prefissi({'tn':'0461',
'bz':'0471',
'mi':'02',
'to':'011',
'bo':'051'
},
['tn','to', 'mi']) == ['0461', '011', '02']
# FINE TEST
traduci
✪✪ L’italiano è oramai una lingua obsoleta, perciò va soppiantata dall’inglese che è più trendy. A tal fine, scrivere una funzione che prende una frase come lista di parole e un dizionario di traduzioni italiano-inglese, e RITORNA una NUOVA lista in cui tutte le parole della lista originale e che sono presenti come chiavi nel dizionario sono sostituite con la corrispondente voce in inglese.
Se non c’è traduzione, viene messa la parola in italiano.
Esempio:
lista = ["Oggi", "ho", "una riunione", "dove", "discuteremo", "gli obiettivi", "da", "raggiungere", "per", "soddisfare", "i nostri clienti" ]
inglesismi={
"una riunione": "un meeting",
"gli obiettivi" : "i goal",
"i nostri clienti" : "il nostro target"
}
traduci(lista, inglesismi)
deve ritornare
["Oggi", "ho", "un meeting", "dove", "discuteremo", "i goal", "da", "raggiungere", "per", "soddisfare", "il nostro target"]
[16]:
def traduci(lista, inglesismi):
raise Exception('TODO IMPLEMENT ME !')
# INIZIO TEST: NON TOCCARE QUESTA PARTE !
# se hai scritto tutto il codice giusto, ed esegui la cella, Python non dovrebbe lanciare AssertionError
assert traduci([], {}) == []
assert traduci(['a'], {}) == ['a']
assert traduci(['a'], {'a':'x'}) == ['x']
assert traduci(['a b'], {'a b':'x'}) == ['x']
assert traduci(['a','b'], {'a':'x'}) == ['x','b']
assert traduci(['a','b'], {'a':'x','b':'y'}) == ['x','y']
assert traduci(["Oggi", "ho", "una riunione", "dove", "discuteremo",
"gli obiettivi", "da", "raggiungere", "per", "soddisfare", "i nostri clienti"],
{
"una riunione": "un meeting",
"gli obiettivi" : "i goal",
"i nostri clienti" : "il nostro target"
}) == ["Oggi", "ho", "un meeting", "dove", "discuteremo", "i goal", "da",
"raggiungere", "per", "soddisfare", "il nostro target"]
# FINE TEST
dopocar
Data una stringa di almeno due lettere, RITORNA un NUOVO dizionario in cui ogni lettera è associata alla lettera successiva
NOTA: si suppone che la stringa abbia tutti i caratteri diversi
[17]:
def dopocar(stringa):
raise Exception('TODO IMPLEMENT ME !')
assert dopocar('ab') == {'a':'b'}
assert dopocar('cera') == {'c':'e',
'e':'r',
'r':'a'}
assert dopocar('orchestra') == {'o': 'r',
'c': 'h',
'h': 'e',
'e': 's',
's': 't',
't': 'r',
'r': 'a'}
bestmecha
✪✪✪ Dato un dizionario che assegna a n
nomi di anime giapponesi una preferenza da 1 a n
(1=più favorito n=meno favorito), RITORNA una NUOVA lista con i nomi in ordine di preferenza dal più al meno preferito.
NON usare
lambda
[18]:
def bestmecha(diz):
raise Exception('TODO IMPLEMENT ME !')
assert bestmecha( {'Macross' : 1} ) == ['Macross']
assert bestmecha( {'Patlabor' : 2,
'Evangelion' : 1} ) == ['Evangelion','Patlabor']
assert bestmecha( {'Gundam' : 3,
'Evangelion': 2,
'Patlabor' : 4,
'Macross' : 1} ) == ['Macross', 'Evangelion', 'Gundam', 'Patlabor']
Prosegui
Continua con le challenge