Dizionari 3 - metodi e classi

Scarica zip esercizi

Naviga file online

In questo foglio vedremo i metodi principali per estrarre informazioni e manipolare i dizionari, assieme a delle classi di dizionari speciali

Metodi:

Metodo

Ritorna

Descrizione

dict.keys()

dict_keys

Ritorna una vista di chiavi che sono presenti nel dizionario

dict.values()

dict_values

Ritorna una vista di valori presenti nel dizionario

dict.items()

dict_items

Ritorna una vista di coppie (chiave, valore) presenti nel dizionario

diz1.update(diz2)

None

MODIFICA il dizionario diz1 con le coppie chiave / valore trovate in diz2

Classi:

Classe

Descrizione

OrderedDict

Dizionario che permette di mantenere l’ordine di inserimento delle chiavi

Counter

Dizionario che permette di calcolare rapidamente istogrammi

Che fare

  • scompatta lo zip in una cartella, dovresti ottenere qualcosa del genere:

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

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(['cavoli', 'pomodori', 'carote'])

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(['patate', 'cavoli', 'pomodori', 'carote'])

Quando riusi la sequenza da .keys() poni attenzione ad eventuali modifiche successive al dizionario di partenza

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]:
['patate', 'cavoli', 'pomodori', 'carote']
[9]:
verdure['cetrioli'] = 9
[10]:
come_lista     # niente cetrioli
[10]:
['patate', 'cavoli', 'pomodori', 'carote']

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()
['patate', 'cavoli', 'pomodori', 'carote']
[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.

  1. diz = {'a':4,
           'b':5}
    
    chiavi = diz.keys()
    chiavi.append('c')
    
  2. diz = {'a':4,
           'b':5}
    
    chiavi = diz.keys()
    chiavi.add('c')
    
  3. diz = {'a':4,
           'b':5}
    
    chiavi = diz.keys()
    chiavi['c'] = 3
    
Mostra risposta

DOMANDA: Guarda questi frammenti di codice. Per ciascuno, prova a indovinare che risultato produce (o se da errore)

  1. diz = {'a':1,'b':2}
    s = set(diz.keys())
    s.add(('c',3))
    print(diz)
    print(s)
    
  2. diz = {'a':3,'b':4}
    k = diz.keys()
    diz['c'] = 5
    print(len(k))
    
  3. diz = {'a':'x',
           'b':'y'}
    print('a' in diz.keys())
    
  4. diz1 = {'a':1,'b':2}
    chiavi = diz1.keys()
    diz2 = dict(diz1)
    diz2['c'] = 3
    print('diz1=',diz1)
    print('diz2=',diz2)
    print('chiavi=',chiavi)
    
  5. diz1 = {'a':'b','c':'d'}
    diz2 = {'a':'b','b':'c'}
    print( set(diz1.keys()) - set(diz2.keys())  )
    
  6. 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

Mostra soluzione
[13]:
diz = {'c':6, 'b':2,'a':5}

# scrivi qui


[13]:
['b', 'a', 'c']

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

Mostra soluzione
[14]:
diz = {'c':6, 'b':2,'a':5}

# scrivi qui


['a', 'b', 'c']

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

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']
Mostra soluzione
[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(['Lidia', 'Mario', 'Gino', 'Gino', 'Mario', '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.

  1. diz = {'a':4,
           'b':5}
    
    valori = diz.values()
    valori.append(4)
    
  2. d = {0:'a',
         1:'b',
         2:'b'}
    vs = d.values()
    d[2]='c'
    print(vs)
    
  3. diz = {'a':4,
           'b':5}
    
    valori = diz.values()
    valori.add(5)
    
  4. diz = {0:1,
           1:2,
           2:3}
    
    diz[list(diz.values())[0]-1]
    
  5. diz = {'a':4,
           'b':5}
    
    valori = diz.values()
    valori['c'] = 6
    
  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
Mostra soluzione
[19]:
diz = {'a' : 3,
       'c' : 6,
       'g' : 8}

"""
diz = {'x' : 5,
       'y' : 7,
       'z' : 5}
"""

# scrivi qui


True

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']
Mostra soluzione
[20]:
diz = {
    'a':'b',
    'b':'f',
    'c':'b',
    'd':'e'
}

# scrivi qui


['a', 'b', 'c', 'd', 'e', 'f']

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


Hanno valori in comune? True

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
Mostra soluzione
[22]:
diz = {
    14:1,
    11:7,
    7:3,
    70:5
}

"""
diz = {
    12:1,
    11:9,
    7:3,
    2:5,
    9:1
}
"""

# scrivi qui


[22]:
True

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([('Uffizi', 'Firenze'), ('Piazza S.Marco', 'Venezia'), ('Colosseo', 'Roma'), ('Fontana di Trevi', '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([('Uffizi', 'Firenze'), ('Piazza S.Marco', 'Venezia'), ('Palazzo Ducale', 'Venezia'), ('Colosseo', 'Roma'), ('Fontana di Trevi', 'Roma')])

DOMANDA: Guarda questi frammenti di codice. Per ciascuno, prova a indovinare se può funzionare, e quale risultato produce.

  1. {'a':7, 'b':9}.items()[0] = ('c',8)
    
  2. dict({'a':7,'b':5}.items())['a']
    
  3. len(set({'a':'b', 'a':'B'}.items()))
    
  4. {'a':2}.items().find(('a',2))
    
  5. {'a':2}.items().index(('a',2))
    
  6. list({'a':2}.items()).index(('a',2))
    
  7. diz1 = {'a':7,
            'b':5}
    diz2 = dict(diz1.items())
    diz1['a'] = 6
    print(diz1 == diz2)
    
  8. ('a','b') in {'a':('a','b'), 'b':('a','b')}.items()
    
  9. ('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 e diz2

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, 'e': 2, 'd': 8, 'c': 5, 'b': 7}
Mostra soluzione
[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, 'fieno': 7, 'panche': 3, 'pastori': 1}

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,
 'fieno': 3,
 'panche': 18,
 'pastori': 1,
 '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 lista s

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'}
Mostra soluzione
[34]:
diz = {
    'a':'x',
    'b':'y',
    'c':'z',
    'd':'w'
}
s = "bx;cw;ex"

# scrivi qui


[34]:
{'a': 'x', 'b': 'x', 'c': 'w', 'd': 'w', 'e': 'x'}

Classi - OrderedDict

Come abbiamo detto in precedenza, quando stampiamo un dizionario con print o lasciamo la visualizzazione a Jupyter, l’ordine il più delle volte non è lo stesso di quello d’inserimento. Affinchè sia predicibile, devi usare un OrderedDict

Per poterlo usare, per prima cosa devi importarlo dal modulo delle collezioni:

[35]:
from collections import OrderedDict
[36]:
od = OrderedDict()

Un OrderedDict appare e si comporta come dizionari regolari:

[37]:
od['qualche chiave'] = 5
od['qualche altra chiave'] = 7
od[('una', 'tupla', 'immutabile','come chiave')] = 3
od["un'altra chiave"] = 'adesso una stringa!'
od[123] = 'hello'

La visualizzazione con Jupyter mantiene l’ordine:

[38]:
od
[38]:
OrderedDict([('qualche chiave', 5),
             ('qualche altra chiave', 7),
             (('una', 'tupla', 'immutabile', 'come chiave'), 3),
             ("un'altra chiave", 'adesso una stringa!'),
             (123, 'hello')])

Così come la print:

[39]:
print(od)
OrderedDict([('qualche chiave', 5), ('qualche altra chiave', 7), (('una', 'tupla', 'immutabile', 'come chiave'), 3), ("un'altra chiave", 'adesso una stringa!'), (123, 'hello')])

Vediamo come appare in Python Tutor:

[40]:
from collections import OrderedDict
od = OrderedDict()
od['qualche chiave'] = 5
od['qualche altra chiave'] = 7
od[('una', 'tupla', 'immutabile','come chiave')] = 3
od["un'altra chiave"] = 'adesso una stringa!'
od[123] = 'hello'

jupman.pytut()
[40]:

Esercizio: agenda OrderedDict

Scrivi del codice che date tre tuple come le seguenti, STAMPA un OrderedDict che associa nomi a numeri di telefono, nell’ordine in cui sono proposti

  • Il tuo codice deve funzionare con tuple qualsiasi

  • Non dimenticarti di importare l’OrderedDict dalle collections

Esempio:

t1 = ('Alice', '143242903')
t2 = ('Bob', '417483437')
t3 = ('Carlo', '423413213')

dopo il tuo codice, dovrebbe risultare:

OrderedDict([('Alice', '143242903'), ('Bob', '417483437'), ('Charles', '423413213')])
Mostra soluzione
[41]:
t1 = ('Alice', '143242903')
t2 = ('Bob', '417483437')
t3 = ('Charles', '423413213')

# scrivi qui


Esercizio - copia di OrderedDict

Dato un OrderedDict od1 contenente traduzioni Inglese -> Italiano, crea un NUOVO OrderedDict chiamato od2 che contiene le stesse traduzioni come input PIU’ la traduzione 'water' : 'acqua'

  • NOTA 1: il tuo codice dovrebbe funzionare con qualsiasi ordered dict di input

  • NOTA 2: od2 DEVE essere associata ad un NUOVO OrderedDict !!

Esempio - dato:

od1 = OrderedDict()
od1['dog'] = 'cane'
od1['home'] = 'casa'
od1['table'] = 'tavolo'

dopo il tuo codice, dovresti ottenere:

>>> print(od1)
OrderedDict([('dog', 'cane'), ('home', 'casa'), ('table', 'tavolo')])
>>> print(od2)
OrderedDict([('dog', 'cane'), ('home', 'casa'), ('table', 'tavolo'), ('water', 'acqua')])
Mostra soluzione
[42]:
from collections import OrderedDict

od1 = OrderedDict()
od1['dog'] = 'cane'
od1['home'] = 'casa'
od1['table'] = 'tavolo'

# scrivi qui


od1= OrderedDict([('dog', 'cane'), ('home', 'casa'), ('table', 'tavolo')])
od2= OrderedDict([('dog', 'cane'), ('home', 'casa'), ('table', 'tavolo'), ('water', 'acqua')])

Classi - Counter

Se abbiamo bisogno di contare quanti elementi diversi si trovano in una sequenza (in altre parole, se dobbiamo calcolare un istogramma delle frequenze), la classe Counter ci può tornare molto utile. Counter è un tipo di dizionario speciale. Prima di tutto, dobbiamo dichiarare a Python la nostra intenzione di usarlo, recuperandolo dal modulo collections:

[43]:
from collections import Counter

Supponiamo di voler contare quanti elementi diversi ci sono nella lista

['c', 'a', 'n', 't', 'a', 'r', 'e', 'l', 'l', 'a', 'n', 'd', 'o']

Possiamo inizializzare Counter così:

[44]:
istogramma = Counter(['c', 'a', 'n', 't', 'a', 'r', 'e', 'l', 'l', 'a', 'n', 'd', 'o'])

Se lo stampiamo, vediamo che per primi sono messi gli elementi più frequenti:

[45]:
print(istogramma)
Counter({'a': 3, 'n': 2, 'l': 2, 't': 1, 'e': 1, 'o': 1, 'd': 1, 'c': 1, 'r': 1})

ATTENZIONE: SE NON SI USA LA print JUPYTER STAMPERA’ IN ORDINE ALFABETICO!

[46]:
istogramma    # occhio !
[46]:
Counter({'a': 3,
         'c': 1,
         'd': 1,
         'e': 1,
         'l': 2,
         'n': 2,
         'o': 1,
         'r': 1,
         't': 1})

Possiamo ottenere una lista con gli n più frequenti col metodo most_common, che ritorna una lista di tuple:

[47]:
istogramma.most_common(5)
[47]:
[('a', 3), ('n', 2), ('l', 2), ('t', 1), ('e', 1)]

Counter si può inizializzare con una sequenza qualsiasi, per esempio con tuple:

[48]:
ct = Counter((50,70,40,60,40,50,40,70,50,50,50,60,50,30,50,30,40,50,60,70))
print(ct)
Counter({50: 8, 40: 4, 60: 3, 70: 3, 30: 2})

o stringhe:

[49]:
cs = Counter('rabbrividirai')
[50]:
print(cs)
Counter({'i': 4, 'r': 3, 'b': 2, 'a': 2, 'v': 1, 'd': 1})

Vi sono altri metodi che si possono usare, ma per quelli facciamo riferimento alla documentazione di Python

Esercizio - frequenti

Dato una stringa s, scrivi del codice che stampa

  • il carattere più frequente

  • quello meno frequente

  • quante e quali frequenze diverse vi sono

  • Il tuo codice deve funzionare con qualsiasi stringa s

  • Ignora la possibilità che vi siano pari merito tra i più/meno frequenti

  • ricordati di importare Counter da collections

Esempio - data:

s = 'rattristato'

il tuo codice deve stampare:

Tra i più frequenti troviamo ('t', 4)
Tra i meno frequenti troviamo ('i', 1)
Vi sono  3 frequenze diverse: {1, 2, 4}
Mostra soluzione
[51]:

s = 'rattristato'

# scrivi qui


Prosegui

Prosegui con Dizionari 4

[ ]: