Funzioni 7 - esercizi coi dizionari

Scarica zip esercizi

Naviga file online

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

# scrivi qui

def stampa_val(d, key):
    return d[key]

#x = stampa_val({'a':5,'b':2}, 'a')
#x

# 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

# scrivi qui

def ha_chiave(d, chiave):
    if chiave in d:
        print("trovato")
    else:
        print("non trovato")


#ha_chiave({'a':5,'b':2}, 'a')
#ha_chiave({'a':5,'b':2}, 'b')
#ha_chiave({'a':5,'b':2}, 'z')

# 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

# scrivi qui

def dim(d):
    return len(d)

#x = dim({'a':5,'b':2,'c':9})
#x

# 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

# scrivi qui

def mazzol(d):
    la = list(d.keys())
    la.sort()  # RICORDA: .sort() NON ritorna nulla !
    return la


#x = mazzol({'a':5,'c':2,'b':9})
#x

# 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

# scrivi qui

def coppie(d):
    for chiave in d:
        print(chiave,d[chiave])

#coppie({'a':5,'b':2,'c':9})

# 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

Mostra soluzione

def istogramma(stringa):


    diz = {}
    for carattere in stringa:
        if carattere in diz:
            diz[carattere] += 1
        else:
            diz[carattere] = 1
    return diz


# 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}

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

def listifica(d, ordine):

    ret = list()
    for elemento in ordine:
        ret.append (d[elemento])
    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 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

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

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

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'}

Mostra soluzione

def inter(d1, d2):

    res = set()
    for chiave in d1:
        if chiave in d2:
            if d1[chiave] == d2[chiave]:
                 res.add(chiave)
    return res



# 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

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

def valori_unici(d):

    s = set(d.values())
    ret = list(s)  # possiamo solo ordinare liste (gli insiemi non hanno ordine)
    ret.sort()
    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 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

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

def maiuscole(lista):

    diz = {}
    for stringa in lista:
        diz[stringa] = stringa.upper()
    return diz



# 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

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

def filtraz(diz):


    ret = {}
    for chiave in diz:
        if 'z' in chiave:
            ret[chiave] = diz[chiave]
    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 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

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

def powers(n):

    d=dict()
    for i in range(1,n+1):
        d[i]=i**2
    return d


# 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

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

def dilist(n):

    ret = dict()
    for i in range(1,n+1):
        lista = []
        for j in range(1,i+1):
            lista.append(j)
        ret[i] = lista
    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 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

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

def prefissi(diz, province):


    ret = []
    for provincia in province:
        ret.append(diz[provincia])

    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 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

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

def traduci(lista, inglesismi):

    ret = []
    for parola in lista:
        if parola in inglesismi:
            ret.append(inglesismi[parola])
        else:
            ret.append(parola)
    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 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

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

Mostra soluzione

def dopocar(stringa):

    diz = {}
    for i in range(len(stringa) - 1):
        diz[stringa[i]] = stringa[i + 1]
    return diz



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'}

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

Mostra soluzione

def bestmecha(diz):

    ret = [None]*len(diz)
    for k in diz:
        ret[diz[k] - 1] = k

    return ret



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']

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