Python Counter: la sot­to­clas­se per contare gli elementi

La classe Python Counter si usa per contare gli elementi all’interno di un container. Si tratta di una sot­to­clas­se di dic­tio­na­ry (di­zio­na­rio) e può essere usata assieme a diversi metodi per rea­liz­za­re diverse ope­ra­zio­ni.

Cos’è Python Counter?

Python Counter è uno strumento utile che consente di contare diversi elementi all’interno di una lista e di ana­liz­za­re la frequenza con cui questi elementi compaiono. È una sot­to­clas­se di di­zio­na­rio. Mentre per brevi sequenze è possibile eseguire un conteggio manuale, Counter diventa in­di­spen­sa­bi­le quando si ha a che fare con record di dati più estesi. Counter in Python è una variabile intera e presenta un valore iniziale “null”. Usando Counter una volta è possibile stabilire la frequenza di un oggetto. Se, invece, di desidera prendere in con­si­de­ra­zio­ne più oggetti diversi, è possibile usare Counter per ciascuno di essi.

La classe Counter può essere usata su liste, tuple di Python, dizionari e stringhe di Python. La sintassi è la seguente:

Counter(list)

Nei prossimi paragrafi ti mo­stre­re­mo alcuni semplici esempi per aiutarti a capire come usare Python Counter nella pratica.

Python Counter con una lista

Nel primo esempio ci limitiamo a creare una semplice lista con­te­nen­te valori diversi. La sintassi è la seguente:

Lista = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c']

La lista presenta tre elementi diversi ‘a’, ‘b’ e ‘c’. Per scoprire la frequenza con cui ricorre ciascuno di questi elementi, usiamo Counter in Python. L’output sarà il seguente:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Per poter impiegare Python Counter, anzitutto è ne­ces­sa­rio importare la classe. Il risultato viene vi­sua­liz­za­to con print. Il codice completo per questo esempio sarebbe:

from collections import Counter
Lista = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c']
counter_lista = Counter(Lista)
print(Counter(Lista))

L’output è il seguente:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Fun­zio­na­men­to della classe Counter con una tupla

Il secondo esempio è molto simile al primo. Questa volta usiamo Python Counter con una tupla. In Python le tuple servono a salvare più valori di una variabile. Poiché Counter rap­pre­sen­ta una lista ordinata di oggetti, tale ordine viene pre­ser­va­to. Gli elementi sono racchiusi tra parentesi tonde e separati da virgole. Di con­se­guen­za, il codice si scrive così:

from collections import Counter
Tupla = ('a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c')
print(Counter(Tupla))

L’output è uguale all’esempio pre­ce­den­te:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Uso nella classe Dictionary

In un di­zio­na­rio gli elementi vengono salvati sot­to­for­ma di coppie chiave-valore e racchiusi tra parentesi tonde. Uti­liz­zan­do Counter di Python su un di­zio­na­rio, questo viene in­ter­na­men­te con­ver­ti­to in un oggetto hashtable. In questo processo, gli elementi del di­zio­na­rio originale diventano le chiavi di Counter, mentre i calcoli associati diventano i valori cor­ri­spon­den­ti. Facendo ri­fe­ri­men­to al conteggio pre­ce­den­te, la sintassi si pre­sen­te­reb­be così:

from collections import Counter
Dictionary = {'a' : 4, 'b' : 4, 'c' : 5}
counter_dictionary = Counter(Dictionary)
print(Counter(Dictionary))

Questo l’output:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Python Counter in com­bi­na­zio­ne con una semplice stringa

L’ef­fi­cien­za e la praticità di Counter in Python diventano evidenti quando si applica questa classe a una stringa. Una stringa, in termini tecnici, è una sequenza ordinata di caratteri spazi compresi, racchiusa fra vir­go­let­te. Per il nostro esempio scegliamo la seguente stringa:

from collections import Counter
String = "Questo è un esempio."
counter_string = Counter(String)
print(Counter(String))

Ora ciascun carattere viene contato come sot­to­strin­ga. L’output potrebbe essere il seguente:

Counter({'u': 2, 'e': 3, 's': 2, ' ': 3, 't': 1, 'Q': 1, 'o': 2, 'è': 1, 'p': 1, 'n': 1, 'm': 1, '.': 1, 'i':
1})

Esten­sio­ni con .update()

Python Counter può essere usato per numerosi scopi diversi. Uno di questi è la pos­si­bi­li­tà di ampliare un conteggio esistente. A tal proposito si utilizza il metodo .update(), che permette di ag­giun­ge­re nuovi elementi o in­cre­men­ta­re il conteggio di quelli esistenti. Di seguito abbiamo creato un semplice esempio basato sul principio descritto sopra, senza mo­di­fi­ca­re la stringa originale:

from collections import Counter
Counter("rosa")
print(Counter(String))

Il risultato ottenuto è il seguente:

Counter({'r' : 1, 'o' : 1, 's' : 1, 'a' : 1})

Se ora usiamo .update(), il codice si scriverà nel seguente modo:

from collections import Counter
colori = Counter({'r' : 1, 'o' : 1, 's' : 1, 'a' : 1})
colori.update("nero")
print(colori)

L’output viene ag­gior­na­to come segue:

Counter({'r' : 2, 'o' : 2, 's' : 1, 'a' : 1, 'n' : 1, 'e' : 1})

Accedere ai valori di Python Counter

Poiché la classe Counter di Python funziona in modo simile a Dictionary ti consente di accedere ai valori. Nell’esempio di seguito ti mostriamo alcune varianti e i relativi risultati. A tal proposito “letters” funge da chiavi (keys) e “counts” da valori (values).

from collections import Counter
letters = Counter("pensilina")
letters["n"]
2
letters["i"]
2

for letter in letters:
	print(letter, letters[letter])
p 1
e 1
n 2
s 1
i 2
l 1
a 1

Di seguito pre­sen­tia­mo un possibile esempio con il metodo .keys():

for letter in letters.keys():
	print(letter, letters[letter])
p 1
e 1
n 2
s 1
i 2
l 1
a 1

Questo invece è un esempio con .values():

for count in letters.values():
	print(count)
1
1
2
1
2
1
1

Infine, questo è il metodo .items():

for letter, count in letters.items():
	print(letter, count)
p 1
e 1
n 2
s 1
i 2
l 1
a 1

Can­cel­la­re elementi dalla classe

Se vuoi can­cel­la­re un elemento da Python Counter, puoi usare il comando del:

from collections import Counter
esempio = {'r' : 1, 'o' : 1, 's' : 1, 'a' : 1}
del esempio["r"]
print(Counter(esempio))

Questo è il nuovo output:

Counter({'o' : 1, 's' : 1, 'a' : 1})

De­ter­mi­na­re gli elementi più frequenti con most_common(n)

Con most_common(n) per Python Counter puoi de­ter­mi­na­re quali elementi ricorrono con maggiore e minore frequenza. Nell’esempio sot­to­stan­te im­ma­gi­nia­mo un prodotto di­spo­ni­bi­le in diverse varianti di colore, dove per ciascuna variante è indicata la quantità presente in magazzino. Un valore positivo rap­pre­sen­ta la di­spo­ni­bi­li­tà effettiva, mentre un valore negativo indica articoli prenotati ma non ancora in magazzino. Per de­ter­mi­na­re quale variante di colore ha la maggiore di­spo­ni­bi­li­tà in magazzino, usiamo il seguente codice:

from collections import Counter
varianti_di_colore = Counter({'rosa' : 2, 'nero' : -1, 'arancione' : 0})
più_articoli = varianti_di_colore.most_common(1)
print(più_articoli)

In questo caso l’output è:

[('rosa' : 2)]

Possiamo anche cercare gli articoli di cui sono di­spo­ni­bi­li pochi pezzi. Per farlo mo­di­fi­chia­mo il codice come segue:

from collections import Counter
varianti di colore = Counter({'rosa' : 2, 'nero' : -1, 'arancione' : 0})
meno_articoli = varianti_di_colore.most_common()[:-2:-1]
print(meno_articoli)

Questo è il relativo output:

[('nero' : -1)]

Ope­ra­zio­ne arit­me­ti­ca con Python Counter

Con Python Counter è anche possibile rea­liz­za­re ope­ra­zio­ni arit­me­ti­che. Tuttavia, è bene notare che l’output può contenere solo valori positivi. Nel seguente codice è possibile testare vari tipi di ope­ra­zio­ne.

Una semplice addizione:

from collections import Counter
x = Counter(a=4, b=2, c=1)
y = Counter(a=2, b=1, c=2)
z = x + y
print(z)

Counter({'a' : 6, 's' : 3, 'c' : 3})

Una sot­tra­zio­ne:

from collections import Counter
x = Counter(a=4, b=2, c=1)
y = Counter(a=2, b=1, c=2)
z = x - y
print(z)

Counter({'a' : 2, 's' : 1})

Poiché il valore ‘c’ è negativo, non viene incluso nella lista.

Ordinare tipi di dati per frequenza

Questa classe consente anche di contare i tipi di dati all’interno di una cartella. A tal proposito im­ma­gi­nia­mo una cartella de­no­mi­na­ta “immagini”, con­te­nen­te numerosi file con diversi tipi di dati. Per creare una lista usiamo il seguente codice:

import pathlib
from collections import Counter
ordner_pfad = pathlib.Path("Bilder/")
extensions = [entry.suffix for entry in ordner_pfad.iterdir() if entry.is_file()]
extension_counter = Counter(extensions)
print(extension_counter)

Escludere valori negativi e nulli

Per eliminare valori negativi e nulli con Counter, puoi usare il seguente codice:

from collections import Counter
valori = Counter(a=6, b=0, c=1, d=-4)
valori = +valori
print(valori)

L’output è il seguente:

Counter({'r' : 6, 'c' : 1})