Cicli for 6 - iterare dizionari

Scarica zip esercizi

Naviga file online

Dato un dizionario, possiamo esaminare la sequenza di chiavi, di valori o entrambi con un ciclo for.

Iterare le chiavi

Per iterare solo le chiavi è sufficiente usare l’operatore in:

ATTENZIONE: l’ordine di iterazione delle chiavi non è prevedibile !

diz = {
    'bignè':5,
    'brioche':8,
    'krapfen':2
}

for chiave in diz:
    print('Trovata chiave', chiave)
    print('    con valore', diz[chiave])

Trovata chiave bignè
    con valore 5
Trovata chiave brioche
    con valore 8
Trovata chiave krapfen
    con valore 2

Ad ogni iterazione, alla variabile chiave che abbiamo dichiarato viene assegnata una chiave presa dal dizionario, in un ordine che possiamo considerare non prevedibile.

Iterare coppie chiave valore

Possiamo anche ottenere direttamente nel for sia la chiave che il valore corrispondente con questa notazione:

for chiave, valore in diz.items():
    print('Trovata chiave', chiave)
    print('    con valore', diz[chiave])

Trovata chiave bignè
    con valore 5
Trovata chiave brioche
    con valore 8
Trovata chiave krapfen
    con valore 2

.items() ritorna una lista di coppie chiave/valore, e ad ogni iterazione una coppia viene assegnata alle variabili chiave e valore.

Iterare valori

Possiamo iterare i valori chiamando il metodo .values()

ATTENZIONE: anche l’ordine di iterazione dei valori non è prevedibile !

for valore in diz.values():
    print('Trovato valore', valore)

Trovato valore 5
Trovato valore 8
Trovato valore 2

Domande - iterare

Guarda i seguenti frammenti di codice, e per ciascuno cerca di indovinare quale risultato produce (o se da errore):

ATTENZIONE: Ricordati che l’ordine è IMPOSSIBILE da prevedere, quello che è importante è indovinare tutto quello che verrà stampato

1. for x in {'a':1,'b':2,'c':3}:
       print(x)
   

2. for x in {1:'a',2:'b',3:'c'}:
       print(x)
   

3. diz = {'a':1,'b':2,'c':3}
   for x in diz:
       print(x[diz])
   

4. diz = {'a':1,'b':2,'c':3}
   for x in diz:
       print(diz[x])
   

5. diz = {'a':1,'b':2,'c':3}
   for x in diz:
       if x == 'b':
           print(diz[x])
   

6. for k,v in {1:'a',2:'b',3:'c'}:
       print(k,v)
   

7. for x in {1:'a',2:'b',3:'c'}.values():
       print(x)
   

8. for x in {1:'a',2:'b',3:'c'}.keys():
       print(x)
   

9. for x in {1:'a',2:'b',3:'c'}.items():
       print(x)
   

10. for x,y in {1:'a',2:'b',3:'c'}.items():
        print(x,y)
    

Domande - Sono equivalenti?

Guarda i seguenti frammenti di codice: in ciascuno, vi sono due parti, A e B. In ciascun frammento, cerca di indovinare se la parte A stamperà esattamente quello che stampa il codice nella parte B

• PRIMA pensa alla risposta

• POI prova ad eseguire

Sono equivalenti ? postin

diz = {
    'p':'t',
    'o':'i',
    's':'n',
}

print('A:')
for x in diz.keys():
    print(x)

print('\nB:')
for y in diz:
    print(y)

Sono equivalenti ? cortel

diz = {
    'c':'t',
    'o':'e',
    'r':'l',
}

print('A:')
for p,q in diz.items():
    print(q)

print('\nB:')
for x in diz.values():
    print(x)

Sono equivalenti ? - gel

diz = {
    'g':'l',
    'e':'e',
    'l':'g',
}

print('A:')
for x in diz.values():
    print(x)

print('\nB:')
for z in diz.items():
    print(z[0])

Sono equivalenti ? - giri

diz = {
    'p':'g',
    'e':'i',
    'r':'r',
    'i':'i',
}

print('A:')
for p,q in diz.items():
    if p == q:
        print(p)

print('\nB:')
for x in diz:
    if x == diz[x]:
        print(x)

Sono equivalenti? - Trovato

Prima pensa se sono equivalenti, poi verifica con tutti i valori di k proposti.

Fai bene attenzione a questo esercizio !

Capire questo vuol dire aver veramente capito i dizionari ;-)

k = 'p'
#k = 'e'
#k = 'r'
#k = 'z'

diz = {
    'p':'c',
    'e':'h',
    'r':'è',
}

print('A:')
for x in diz:
    if x == k:
        print('Trovato', diz[x])

print('\nB:')
if k in diz:
    print('Trovato', diz[k])

Mostra risposta

RISPOSTA: I due codici sopra riportati sono equivalenti, con una importante differenza: il codice A verrà eseguito in un tempo proporziale alla dimensione di diz (perchè deve scorrere tutto il dizionario), invece il codice B verrà sempre eseguito in un tempo costante breve che non dipende dalla dimensione di diz. Sia il comando if k in diz che l’espressione diz[k] che recupera il valore corrispondente alla chiave k sono estremamente veloci.

ATTENZIONE: assicurati di capire bene questo punto!

In tanti scrivono codice come nella parte A perdendo di fatto la principale utilità dei dizionari che è l’accesso veloce. Finchè i dati sono pochi è facile non accorgersene, ma quando abbiamo megabyte di coppie chiave / valore il tempo perso in cicli inutili si fa sentire! Per ulteriori chiarimenti puoi leggere (o rivedere) la sezione Disordine veloce nel foglio sui dizionari.

Esercizi iterazione

Esercizio - colore di cuori

✪ Scrivi del codice che dato un dizionario semi, per ogni seme stampa il suo colore.

Esempio - dato:

semi = {
    'cuori':'rosso',
    'picche':'nero',
    'quadri':'rosso',
    'fiori':'nero'
}

stampa:

ATTENZIONE: non ti preoccupare dell’ordine in cui vengono stampati i valori!

Sul tuo computer potresti vedere dei risultati diversi, l’importante è che vengano stampate tutte le righe.

Il colore di fiori è nero
Il colore di cuori è rosso
Il colore di picche è nero
Il colore di quadri è rosso

Mostra soluzione

semi = {
    'cuori':'rosso',
    'picche':'nero',
    'quadri':'rosso',
    'fiori':'nero'
}

# scrivi qui

for k in semi.keys():
    print('Il colore di', k, 'è', semi[k])

Il colore di cuori è rosso
Il colore di picche è nero
Il colore di quadri è rosso
Il colore di fiori è nero

semi = {
    'cuori':'rosso',
    'picche':'nero',
    'quadri':'rosso',
    'fiori':'nero'
}

# scrivi qui

Esercizio - preziosi

✪ Nel dizionario preziosi alcune chiavi sono uguali ai rispettivi valori. Scrivi del codice che trova tali chiavi e le stampa.

Esempio - dato:

preziosi = {
    'rubini'  : 'giada',
    'opali'   : 'topazi',
    'gemme'   : 'gemme',
    'diamanti': 'gemme',
    'rubini'  : 'rubini'
}

stampa

coppia di elementi uguali: rubini e rubini
coppia di elementi uguali: gemme e gemme

Mostra soluzione

preziosi = {
    'rubini'  : 'giada',
    'opali'   : 'topazi',
    'gemme'   : 'gemme',
    'diamanti': 'gemme',
    'rubini'  : 'rubini'
}

# scrivi qui
for k,v in preziosi.items():
    if k == v:
        print('coppia di elementi uguali:',k, 'e', v)

coppia di elementi uguali: rubini e rubini
coppia di elementi uguali: gemme e gemme

preziosi = {
    'rubini'  : 'giada',
    'opali'   : 'topazi',
    'gemme'   : 'gemme',
    'diamanti': 'gemme',
    'rubini'  : 'rubini'
}

# scrivi qui

Esercizio - potenze

✪ Dato un numero n, scrvi del codice che crea un NUOVO dizionario diz contenente come chiavi i numeri da 1 a n INCLUSI, associando ad ogni chiave il suo quadrato.

Esempio - dato:

n = 5

dopo il tuo codice, deve risultare:

>>> print(diz)
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Mostra soluzione

n = 5

# scrivi qui
diz = {}
for i in range(1,n+1):
    diz[i] = i*i

print(diz)

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

n = 5

# scrivi qui

Esercizio - fiori

✪ Data una lista fiori, scrivi del codice che crea un NUOVO dizionario diz che associa ad ogni fiore True se il nome del fiore è scritto tutto in maiuscolo, e False altrimenti

• SUGGERIMENTO: per verificare se una stringa è tutta in maiuscolo, usa il metodo .isupper()

fiori = ['girasole','GAROFANO', 'tulipano', 'VIOLA', 'ROSA', 'violetta']

stampa (sono in ordine alfabetico perchè stampiamo con pprint):

>>> from pprint import pprint
>>> pprint(diz)
{'GAROFANO': True,
 'ROSA': True,
 'VIOLA': True,
 'girasole': False,
 'tulipano': False,
 'violetta': False}

Mostra soluzione

fiori = ['girasole','GAROFANO', 'tulipano', 'VIOLA', 'ROSA', 'violetta']

# scrivi qui

diz = {}
for el in fiori:
    diz[el] = el.isupper()

from pprint import pprint
pprint(diz)

{'GAROFANO': True,
 'ROSA': True,
 'VIOLA': True,
 'girasole': False,
 'tulipano': False,
 'violetta': False}

fiori = ['girasole','GAROFANO', 'tulipano', 'VIOLA', 'ROSA', 'violetta']

# scrivi qui

Esercizio - arte

✪ Un artista ha dipinto una serie di opere con diverse tecniche. Nel dizionario prezzi per ciascuna tecnica segna il prezzo. L’artista intende fare una serie di esposizioni, e in ognuna presenterà una particolare tecnica. Supponendo che per ciascuna tecnica abbia prodotto q quadri, mostrare quanto guadagnerà in ciascuna esposizione (supponendo venda tutto).

Esempio - dati:

q = 20

esposizioni = ['acquerello', 'olio', 'murale', 'tempera', 'carboncino','inchiostro']

prezzi = {'acquerello': 3000,
          'olio'      : 6000,
          'murale'    : 2000,
          'tempera'   : 4000,
          'carboncino': 7000,
          'inchiostro': 1000
}

Stampa - questa volta l’ordine conta!!

Guadagni previsti:
  esposizione acquerello : 60000 €
  esposizione olio : 120000 €
  esposizione murale : 40000 €
  esposizione tempera : 80000 €
  esposizione carboncino : 140000 €
  esposizione inchiostro : 20000 €

Mostra soluzione

q = 20

esposizioni = ['acquerello', 'olio', 'murale', 'tempera', 'carboncino','inchiostro']

prezzi = {'acquerello': 3000,
          'olio'      : 6000,
          'murale'    : 2000,
          'tempera'   : 4000,
          'carboncino': 7000,
          'inchiostro': 1000
}


# scrivi qui

print('Guadagni previsti:')
for i in range(len(esposizioni)):
    tecnica = esposizioni[i]
    print('  esposizione', tecnica, ":", prezzi[tecnica]*q,  '€')

Guadagni previsti:
  esposizione acquerello : 60000 €
  esposizione olio : 120000 €
  esposizione murale : 40000 €
  esposizione tempera : 80000 €
  esposizione carboncino : 140000 €
  esposizione inchiostro : 20000 €

q = 20

esposizioni = ['acquerello', 'olio', 'murale', 'tempera', 'carboncino','inchiostro']

prezzi = {'acquerello': 3000,
          'olio'      : 6000,
          'murale'    : 2000,
          'tempera'   : 4000,
          'carboncino': 7000,
          'inchiostro': 1000
}


# scrivi qui

Esercizio - cartolerie

✪ Un proprietario di due negozi di cartoleria per riorganizzare il magazzino vuole sapere i materiali in comune disponibili nei negozi che possiede. Dati quindi due dizionari cartoleria1 e cartoleria2 che associano oggetti alla loro quantità, scrivi del codice che trova tutte le chiavi in comune e per ciascuna stampa la somma delle quantità trovate.

Esempio - dati:

cartoleria1 = {'penne':10,
               'cartelle':20,
               'carta':30,
               'forbici':40}

cartoleria2 = {'penne':80,
               'cartelle':90,
               'goniometri':130,
               'forbici':110,
               'righelli':120,
               }

stampa (l’ordine non importa):

materiali in comune:
   penne : 90
   cartelle : 110
   forbici : 150

Mostra soluzione

cartoleria1 = {'penne':10,
        'cartelle':20,
        'carta':30,
        'forbici':40}

cartoleria2 = {'penne':80,
        'cartelle':90,
        'goniometri':130,
        'forbici':110,
        'righelli':120,
        }

# scrivi qui

print('materiali in comune:')
for k in cartoleria1:
    if k in cartoleria2:
        print('  ',k, ':', cartoleria1[k] + cartoleria2[k])

materiali in comune:
   penne : 90
   cartelle : 110
   forbici : 150

cartoleria1 = {'penne':10,
        'cartelle':20,
        'carta':30,
        'forbici':40}

cartoleria2 = {'penne':80,
        'cartelle':90,
        'goniometri':130,
        'forbici':110,
        'righelli':120,
        }

# scrivi qui

Esercizio - legumi

✪ Un magazzino ha scaffali numerati, ciascuno contenente una quantità di legumi espressa in chili. Rappresentiamo magazzino come una lista. E’ disponibile anche un registro come dizionario che associa ai nomi dei legumi il numero dello scaffale in cui sono contenuti nel magazzino.

Scrivi del codice che data una lista di nomi di legumi, mostra la somma dei chili presenti in magazzino per quei legumi.

Esempio - dati

legumi = ['ceci', 'soia']

#            0  1  2  3  4  5
magazzino = [50,90,70,10,20,50]

registro = {'piselli'   : 3,
            'soia'      : 1,
            'lenticchie': 5,
            'ceci'      : 4,
            'fave'      : 2,
            'fagioli'   : 0
}

dopo il tuo codice, deve stampare (l’ordine non importa):

Cerco ceci e soia ...
Trovati 20 kg di ceci
Trovati 90 kg di soia
Totale: 110 kg

Mostra soluzione

legumi = ['ceci', 'soia']     # 110
#legumi = ['fagioli', 'fave', 'lenticchie']   # 170

#            0  1  2  3  4  5
magazzino = [50,90,70,10,20,50]

registro = {'piselli'   : 3,
            'soia'      : 1,
            'lenticchie': 5,
            'ceci'      : 4,
            'fave'      : 2,
            'fagioli'   : 0
}

# scrivi qui
print('Cerco', ' e '.join(legumi), '...')
somma = 0
for leg in legumi:
    print('Trovati', magazzino[registro[leg]], 'kg di', leg)
    somma += magazzino[registro[leg]]

print('Totale:',somma, 'kg')

Cerco ceci e soia ...
Trovati 20 kg di ceci
Trovati 90 kg di soia
Totale: 110 kg

legumi = ['ceci', 'soia']     # 110
#legumi = ['fagioli', 'fave', 'lenticchie']   # 170

#            0  1  2  3  4  5
magazzino = [50,90,70,10,20,50]

registro = {'piselli'   : 3,
            'soia'      : 1,
            'lenticchie': 5,
            'ceci'      : 4,
            'fave'      : 2,
            'fagioli'   : 0
}

# scrivi qui

Esercizio - smog

✪ Scrivi del codice che dati due dizionari smog e preposizioni che associano a luoghi rispettivamente valori di smog e preposizioni, stampa tutti i luoghi indicando:

• ‘PREPOSIZIONE LUOGO l’inquinamento è eccessivo’ se il valore di smog è superiore a 30

• ‘PREPOSIZIONE LUOGO l’inquinamento è tollerabile’ altrimenti

• NOTA: nella stampa la prima lettera delle preposizioni deve essere maiuscola: per trasformare la stringa puoi usare il metodo .capitalize()

Esempio - dati:

smog = {'strada'    : 40,
        'ciclabile' : 20,
        'autostrada': 90,
        'parco'     : 15,
        'lago'      : 5
       }

preposizioni = {
    'autostrada': 'in',
    'ciclabile' : 'alla',
    'lago'      : 'al',
    'parco'     : 'al',
    'strada'    : 'in',
}

stampa (l’ordine non importa):

In strada l'inquinamento è eccessivo
Al parco l'inquinamento è tollerabile
In autostrada l'inquinamento è eccessivo
Al lago l'inquinamento è tollerabile
Alla ciclabile l'inquinamento è tollerabile

Mostra soluzione

smog = {'strada'    : 40,
        'ciclabile' : 20,
        'autostrada': 90,
        'parco'     : 15,
        'lago'      : 5
       }

preposizioni = {
    'autostrada': 'in',
    'ciclabile' : 'alla',
    'lago'      : 'al',
    'parco'     : 'al',
    'strada'    : 'in',
}

# scrivi qui
for x in smog:
    if smog[x] > 30:
        print(preposizioni[x].capitalize(),x, "l'inquinamento è eccessivo")
    else:
        print(preposizioni[x].capitalize(),x,"l'inquinamento è tollerabile")

In strada l'inquinamento è eccessivo
Alla ciclabile l'inquinamento è tollerabile
In autostrada l'inquinamento è eccessivo
Al parco l'inquinamento è tollerabile
Al lago l'inquinamento è tollerabile

smog = {'strada'    : 40,
        'ciclabile' : 20,
        'autostrada': 90,
        'parco'     : 15,
        'lago'      : 5
       }

preposizioni = {
    'autostrada': 'in',
    'ciclabile' : 'alla',
    'lago'      : 'al',
    'parco'     : 'al',
    'strada'    : 'in',
}

# scrivi qui

Esercizio - sport

✪✪ Scrivi del codice che dato un dizionario sport in cui persone sono associate allo sport che preferiscono, crea un NUOVO dizionario conteggi che associa ad ogni sport il numero di persone che lo preferiscono.

Esempio - dato:

sport = {'Gianni' : 'calcio',
         'Paolo'  : 'tennis',
         'Sara'   : 'pallavolo',
         'Elena'  : 'tennis',
         'Roberto': 'calcio',
         'Carla'  : 'calcio',
}

Dopo il tuo codice, deve risultare:

>>> print(conteggi)
{'calcio': 3, 'pallavolo': 1, 'tennis': 2}

Mostra soluzione

sport = {'Gianni' : 'calcio',
         'Paolo'  : 'tennis',
         'Sara'   : 'pallavolo',
         'Elena'  : 'tennis',
         'Roberto': 'calcio',
         'Carla'  : 'calcio',
}

# scrivi qui

conteggi = {}

for k,v in sport.items():
    if v in conteggi:
        conteggi[v] += 1
    else:
        conteggi[v] = 1

print(conteggi)

{'calcio': 3, 'tennis': 2, 'pallavolo': 1}

sport = {'Gianni' : 'calcio',
         'Paolo'  : 'tennis',
         'Sara'   : 'pallavolo',
         'Elena'  : 'tennis',
         'Roberto': 'calcio',
         'Carla'  : 'calcio',
}

# scrivi qui

Esercizio - ramarro

✪✪ Scrivi del codice che dato un insieme cerca di caratteri da cercare, per ciascuno conta quanti ce ne sono nella stringa testo e mette il numero nel dizionario conteggi

Esempio - dati:

cerca = {'t','r','z'}
testo = "Il ramarro orientale è un sauro della famiglia dei Lacertidi, di colore verde brillante"
conteggi = {}

dopo il tuo codice, deve risultare:

>>> conteggi
{'z': 0, 't': 3, 'r': 9}

Mostra soluzione

#jupman-ignore-output
cerca = {'t','r','z'}
testo = "Il ramarro orientale è un sauro della famiglia dei Lacertidi, di colore verde brillante"
conteggi = {}

# scrivi qui

# soluzione 1, più efficente
for lettera in cerca:
    conteggi[lettera] = 0
for lettera in testo:
    if lettera in cerca:
        if lettera in conteggi:
            conteggi[lettera] += 1

print(conteggi)

# soluzione 2, meno efficente (scansioniamo testo n volte con count)
for lettera in cerca:
    conteggi[lettera] = testo.count(lettera)

print(conteggi)

{'t': 3, 'r': 9, 'z': 0}
{'t': 3, 'r': 9, 'z': 0}

#jupman-ignore-output
cerca = {'t','r','z'}
testo = "Il ramarro orientale è un sauro della famiglia dei Lacertidi, di colore verde brillante"
conteggi = {}

# scrivi qui

{'t': 3, 'r': 9, 'z': 0}
{'t': 3, 'r': 9, 'z': 0}

Modificare un dizionario durante l’iterazione

Supponi di avere un dizionario delle province

province = {'tn': 'Trento',
            'mi':'Milano',
            'na':'Napoli',
}

e di volerlo MODIFICARE in modo che dopo il tuo codice risultino aggiunte le sigle in maiuscolo:

>>> print(province)
{'tn' : 'Trento',
 'mi' : 'Milano',
 'na' : 'Napoli',
 'TN' : 'Trento',
 'MI' : 'Milano',
 'NA' : 'Napoli',
}

Potrebbe venirti l’idea di scrivere qualcosa del genere:

for chiave in province:
    province[chiave.upper()] = province[chiave]    # ATTENZIONE !

DOMANDA: Vedi forse un problema?

Mostra risposta

RISPOSTA: se mentre scorriamo il dizionario, continuiamo al contempo ad aggiungere pezzi, c’è il rischio concreto che non termineremo mai di esaminare le chiavi !

Perciò leggi bene quanto segue:

X COMANDAMENTO: Non aggiungerai o toglierai mai elementi da una sequenza su cui stai iterando con un for!

In questo caso, se proviamo ad eseguire il codice, otterremo un errore esplicito:

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-26-9b20900057e8> in <module>()
----> 1 for chiave in province:
      2     diz['chiave'.upper()] = diz[chiave]    # ATTENZIONE !

RuntimeError: dictionary changed size during iteration

ma in altri casi (come per esempio con le liste) effettuare modifiche può produrre comportamenti del tutto imprevedibili (conosci forse l’espressione tirare il tappeto da sotto i piedi?)

E rimuovere? Abbiamo visto che aggiungere è pericoloso, ma lo è anche togliere.

Supponiamo di voler togliere qualunque coppia che abbia come valore 'Trento'

province = {
    'tn': 'Trento',
    'mi':'Milano',
    'na':'Napoli',
}

affinchè risulti

>>> print(province)
{'mi':'Milano',
 'na':'Napoli'}

Se proviamo ad eseguire qualcosa del genere per fortuna Python si accorge e ci lancia un’eccezione:

province = {
    'tn': 'Trento',
    'mi': 'Milano',
    'na': 'Napoli',
}

for chiave in province:
    if province[chiave] == 'Trento':
        del province[chiave]   # PESSIMA IDEA

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-23-5df0fd659120> in <module>()
      5     'na':'Napoli'
      6 }
----> 7 for chiave in province:
      8     if province[chiave] == 'Trento':
      9         del province[chiave]   # PESSIMA IDEA

RuntimeError: dictionary changed size during iteration

Se proprio devi rimuovere elementi dalla sequenza su cui stai iterando, usa un ciclo while o effettua prima una copia della sequenza originale.

Esercizio - zazb

✪✪ Scrivere del codice che dato un dizionario diz con caratteri come chiavi, MODIFICA il dizionario affinchè gli vengano aggiunte chiavi uguali a quelle esistenti ma precedute dal carattere 'z' - come valore associato alle nuove chiavi, poni l’intero 10

Esempio - dato:

diz = {
    'a':3,
    'b':8,
    'c':4
}

dopo il tuo codice, diz dovrebbe risultare MODIFICATO così:

>>> diz
{   'a':3,
    'b':8,
    'c':4,
    'za':10,
    'zb':10,
    'zc':10
}

DOMANDA: E’ forse il caso di scrivere una soluzione come quella qua sotto? Leggi bene questo:

diz = {
    'senso'          : 1,
    'di'             : 2,
    'inquietudine...': 3
}

for chiave in diz:
    diz['z'+chiave] = 4    # ATTENZIONE !! GUAI IN VISTA !!

Mostra risposta

RISPOSTA: Assolutamente no - in questo caso siamo fortunati e otterremo un errore esplicito, in altri potremmo ottenere cicli infiniti o risultati incomprensibili:

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-36-550c4c302120> in <module>()
      5 }
      6
----> 7 for chiave in diz:
      8     diz['z'+chiave] = 10

RuntimeError: dictionary changed size during iteration

Fai di meglio: ora prova a scrivere una versione del programma che non abbia questo problema

Mostra soluzione

diz = {
    'a':3,
    'b':8,
    'c':4
}

# scrivi qui

for el in list(diz.keys()):  # list 'fotografa' lo stato delle chiavi
    diz['z'+el] = 10

diz

{'a': 3, 'b': 8, 'c': 4, 'za': 10, 'zb': 10, 'zc': 10}

diz = {
    'a':3,
    'b':8,
    'c':4
}

# scrivi qui

Esercizio - brico

✪✪ Un magazzino per appassionati del fai da te dispone di un catalogo che associa tipologie di oggetti agli scaffali dove posizionarli. Ogni giorno, una lista di arrivi viene popolata con le tipologie di oggetti arrivati. Tali tipologie vanno collocate nel magazzino, un dizionario che associa ad ogni scaffale la tipologia di oggetto prescritta dal catalogo. Scrivi del codice che data la lista di arrivi e il catalogo, popola il dizionario magazzino.

Esempio - dati:

arrivi = ['sedie', 'lampade', 'cavi']

catalogo = {'stufe' : 'A',
            'sedie' : 'B',
            'caraffe' : 'D',
            'lampade' : 'C',
            'cavi' : 'F',
            'giardinaggio' : 'E'}

magazzino = {}

dopo il tuo codice deve risultare:

>>> magazzino
{'B': 'sedie', 'C': 'lampade', 'F': 'cavi'}

Mostra soluzione

arrivi = ['sedie', 'lampade', 'cavi']  # magazzino diventa: {'B': 'sedie', 'C': 'lampade', 'F': 'cavi'}
#arrivi = ['caraffe', 'giardinaggio']  # magazzino diventa: {'D': 'caraffe', 'E': 'giardinaggio'}
#arrivi = ['stufe']                    # magazzino diventa: {'A': 'stufe'}

catalogo = {'stufe' : 'A',
            'sedie' : 'B',
            'caraffe' : 'D',
            'lampade' : 'C',
            'cavi' : 'F',
            'giardinaggio' : 'E'}

# scrivi qui

magazzino = {}

for consegna in arrivi:
    magazzino[ catalogo[consegna] ] = consegna

magazzino

{'B': 'sedie', 'C': 'lampade', 'F': 'cavi'}

arrivi = ['sedie', 'lampade', 'cavi']  # magazzino diventa: {'B': 'sedie', 'C': 'lampade', 'F': 'cavi'}
#arrivi = ['caraffe', 'giardinaggio']  # magazzino diventa: {'D': 'caraffe', 'E': 'giardinaggio'}
#arrivi = ['stufe']                    # magazzino diventa: {'A': 'stufe'}

catalogo = {'stufe' : 'A',
            'sedie' : 'B',
            'caraffe' : 'D',
            'lampade' : 'C',
            'cavi' : 'F',
            'giardinaggio' : 'E'}

# scrivi qui

Esercizio - miniera

✪✪ Dato un dizionario miniera che associa chiavi a numeri, MODIFICA il dizionario estratto associando le stesse chiavi di miniera a liste con le chiavi ripetute il numero di volte indicato.

Esempio - dati:

miniera = {'ottone': 5,
           'rame'  : 8,
           'ferro' : 1}
estratto = {}

dopo il tuo codice deve risultare:

>>> print(estratto)
{'ottone': ['ottone', 'ottone', 'ottone', 'ottone', 'ottone'],
 'rame'  : ['rame', 'rame', 'rame', 'rame', 'rame', 'rame', 'rame', 'rame'],
 'ferro' : ['ferro']}

Mostra soluzione

miniera = {'ottone' : 5,
           'rame' : 8,
           'ferro' : 1}

estratto = {}

# scrivi qui

for chiave in miniera:
    estratto[chiave] = [chiave] * miniera[chiave]

estratto

{'ottone': ['ottone', 'ottone', 'ottone', 'ottone', 'ottone'],
 'rame': ['rame', 'rame', 'rame', 'rame', 'rame', 'rame', 'rame', 'rame'],
 'ferro': ['ferro']}

miniera = {'ottone' : 5,
           'rame' : 8,
           'ferro' : 1}

estratto = {}

# scrivi qui

Prosegui

Continua con cicli for annidati