Dizionari - iterazione e funzioni

Scarica zip esercizi

Naviga file online

In questo foglio troviamo esercizi su iterazione in dizionari, e come usarli quando sono argomento di funzioni.

ATTENZIONE: Gli esercizi seguenti richiedono di conoscere:

Se sei alle prime armi con la programmazione, ti conviene saltarli e ripassare in seguito

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.ipynb
    dictionaries5-sol.ipynb
    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 dictionaries4.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. Gli esercizi sono graduati per difficoltà, da una stellina ✪ a quattro ✪✪✪✪

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

Esercizi con le funzioni

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
Mostra soluzione
[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
Mostra soluzione
[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
Mostra soluzione
[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']
Mostra soluzione
[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
Mostra soluzione
[5]:
# scrivi qui


Verifica comprensione

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

Mostra soluzione
[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

Mostra soluzione
[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

[8]:
def tcont(lst):
    ret = {}
    for c in lst:
        if c[0] in ret:
            ret[c[0]] += c[1]
        else:
            ret[c[0]] = c[1]
    return ret

# 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'}
Mostra soluzione
[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']
Mostra soluzione
[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()`
Mostra soluzione
[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
Mostra soluzione
[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
}
Mostra soluzione
[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]
}
Mostra soluzione
[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

Mostra soluzione
[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"]
Mostra soluzione
[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

Prosegui

Prosegui con Dizionari 5

[ ]: