# Python Counter: la sottoclasse per contare gli elementi

La classe Python `Counter` si usa per contare gli elementi all’interno di un container. Si tratta di una sottoclasse di dictionary (dizionario) e può essere usata assieme a diversi metodi per realizzare diverse operazioni.

## Cos’è Python `Counter`?

Python Counter è uno strumento utile che consente di contare diversi elementi all’interno di una lista e di analizzare la **frequenza con cui questi elementi compaiono**. È una sottoclasse di [dizionario](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/dizionari-in-python/). Mentre per brevi sequenze è possibile eseguire un conteggio manuale, Counter diventa indispensabile 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 considerazione più oggetti diversi, è possibile usare `Counter` per ciascuno di essi.

La classe `Counter` può essere usata su liste, [tuple di Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tuple-in-python/), dizionari e [stringhe di Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/stringhe-in-python/). La sintassi è la seguente:

```python
Counter(list)
```

Nei prossimi paragrafi ti mostreremo 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 contenente valori diversi. La sintassi è la seguente:

```python
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:

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

Per poter impiegare Python `Counter`, anzitutto è necessario importare la classe. Il risultato viene visualizzato con `print`. Il codice completo per questo esempio sarebbe:

```python
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:

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

## Funzionamento 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 rappresenta una lista ordinata di oggetti, tale ordine viene preservato. Gli elementi sono racchiusi tra parentesi tonde e separati da virgole. Di conseguenza, il codice si scrive così:

```python
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 precedente:

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

## Uso nella classe `Dictionary`

In un dizionario gli elementi vengono salvati sottoforma di **coppie chiave-valore** e racchiusi tra parentesi tonde. Utilizzando Counter di Python su un dizionario, questo viene internamente convertito in un oggetto hashtable. In questo processo, gli elementi del dizionario originale diventano le chiavi di Counter, mentre i calcoli associati diventano i valori corrispondenti. Facendo riferimento al conteggio precedente, la sintassi si presenterebbe così:

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

Questo l’output:

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

Consiglio Bastano tre passaggi per raggiungere i tuoi obiettivi: con [Deploy Now](https://www.ionos.it/hosting/deploy-now "Deploy Now di IONOS") di IONOS non devi far altro che connettere il tuo repository, configurare automaticamente la tua build e accedere a un’infrastruttura robusta e affidabile. Approfitta di prezzi convenienti e della consulenza di esperti.

## Python `Counter` in combinazione con una semplice stringa

L’efficienza 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 virgolette. Per il nostro esempio scegliamo la seguente stringa:

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

Ora ciascun carattere viene contato come sottostringa. L’output potrebbe essere il seguente:

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

## Estensioni con `.update()`

Python `Counter` può essere usato per numerosi scopi diversi. Uno di questi è la possibilità di ampliare un conteggio esistente. A tal proposito si utilizza il metodo `.update()`, che permette di aggiungere nuovi elementi o incrementare il conteggio di quelli esistenti. Di seguito abbiamo creato un semplice esempio basato sul principio descritto sopra, senza modificare la stringa originale:

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

Il risultato ottenuto è il seguente:

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

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

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

L’output viene aggiornato come segue:

```python
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).

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

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

Di seguito presentiamo un possibile esempio con il metodo `.keys()`:

```python
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()`:

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

Infine, questo è il metodo `.items()`:

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

## Cancellare elementi dalla classe

Se vuoi cancellare un elemento da Python `Counter`, puoi usare il comando `del`:

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

Questo è il nuovo output:

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

## Determinare gli elementi più frequenti con `most_common(n)`

Con `most_common(n)` per Python `Counter` puoi determinare quali elementi ricorrono con maggiore e minore frequenza. Nell’esempio sottostante immaginiamo un prodotto disponibile in diverse varianti di colore, dove per ciascuna variante è indicata la quantità presente in magazzino. Un valore positivo rappresenta la disponibilità effettiva, mentre un valore negativo indica articoli prenotati ma non ancora in magazzino. Per determinare quale variante di colore ha la maggiore disponibilità in magazzino, usiamo il seguente codice:

```python
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 è:

```python
[('rosa' : 2)]
```

Possiamo anche cercare gli articoli di cui sono disponibili pochi pezzi. Per farlo modifichiamo il codice come segue:

```python
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:

```python
[('nero' : -1)]
```

## Operazione aritmetica con Python `Counter`

Con Python `Counter` è anche possibile realizzare **operazioni aritmetiche**. Tuttavia, è bene notare che l’output può contenere solo valori positivi. Nel seguente codice è possibile testare vari tipi di operazione.

Una semplice addizione:

```python
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)
```

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

Una sottrazione:

```python
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)
```

```python
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 immaginiamo una cartella denominata “immagini”, contenente numerosi file con diversi tipi di dati. Per creare una lista usiamo il seguente codice:

```python
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:

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

L’output è il seguente:

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

Consiglio Nella nostra Digital Guide trovi tanti altri articoli su questo linguaggio di programmazione. Nei seguenti articoli ti spieghiamo quali [operatori Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-python/) esistono, come [installare Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/installare-python/) e ti mostriamo le principali [basi di Python corredate di tutorial](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tutorial-python/).


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-counter/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-counter/) for AI/LLM consumption.