# Python Counter: Elemente zählen mit der Unterklasse

Die Klasse Python `Counter` wird genutzt, um Elemente in einem Container zu zählen. Es handelt sich dabei um eine Dictionary-Unterklasse, die in Kombination mit unterschiedlichen Methoden zahlreiche denkbare Einsatzzwecke hat.

## Was ist Python `Counter`?

Bei Python `Counter` handelt es sich um ein nützliches Tool, das verschiedene Elemente in einer Liste zählen kann und anzeigt, **wie häufig diese Elemente vorkommen**. Es handelt sich dabei um eine Unterklasse von [Dictionary](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-dictionary/). Während diese Aufgabe bei einer kurzen Abfolge von Werten noch einfach und manuell erledigt werden kann, ist das bei langen Datensätzen deutlich komplizierter. Python `Counter` selbst ist eine integre Variable, die den Ausgangswert „Null“ hat. Ein einziger Counter gibt die Häufigkeit eines Objektes aus. Möchten Sie mehrere unterschiedliche Objekte berücksichtigen, nutzen Sie für jedes einzelne einen eigenen Zähler.

Die `Counter`-Klasse kann auf Listen, [Python-Tuples](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-tuples/), Dictionarys und [Python-Strings](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-string/) angewendet werden. Ihre Syntax sieht wie folgt aus:

```python
Counter(list)
```

In den folgenden Abschnitten zeigen wir Ihnen anhand einiger einfacher Beispiele, wie Sie Python `Counter` in der Praxis einsetzen können.

## Python `Counter` mit einer Liste

Im ersten Beispiel erstellen wir eine einfache Liste mit unterschiedlichen Werten. Diese sieht so aus:

```python
Liste = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c']
```

Die Liste hat drei verschiedene Elemente: ‘a’, ‘b’ und ‘c’. Um nun herauszufinden, wie häufig jedes dieser Elemente enthalten ist, wenden wir Python `Counter` an. Die Ausgabe würde dann folgendermaßen aussehen:

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

Um Python `Counter` einzusetzen, muss die Klasse zunächst importiert werden. Das Ergebnis wird mit `print` ausgegeben. Der komplette Code für dieses Beispiel wäre dann dieser:

```python
from collections import Counter
Liste = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c']
counter_liste = Counter(Liste)
print(Counter(Liste))
```

Die daraus resultierende Ausgabe sieht so aus:

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

## So funktioniert die `Counter`-Klasse mit einem Tuple

Im zweiten Beispiel gehen wir sehr ähnlich vor. Dieses Mal soll Python `Counter` auf ein Tuple angewendet werden. Tuples werden in Python genutzt, um **mehrere Werte in einer Variablen** abspeichern zu können. Da es sich um eine geordnete Zusammenfassung von Objekten handelt, wird die Reihenfolge berücksichtigt. Die Objekte werden in runde Klammern gesetzt und durch Kommata getrennt. Entsprechend hat der Code folgende Form:

```python
from collections import Counter
Tupel = ('a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c')
print(Counter(Tupel))
```

Die Ausgabe entspricht dem vorherigen Beispiel:

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

## Einsatz in der Klasse `Dictionary`

In einem Dictionary werden Elemente als **Schlüssel-Wert-Paare** gespeichert und in geschwungene Klammern gesetzt. Wenn Sie Python `Counter` für das Dictionary anwenden, wird dieses zu einem Hashtable-Objekt umgewandelt. Die Elemente werden dadurch zu Schlüsseln und ihre Werte zur Anzahl des ursprünglichen Dictionarys. Für unser Beispiel von oben könnte dies so aussehen:

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

Die Ausgabe ist dann erneut diese:

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

Tipp In nur drei Schritten ans Ziel: Mit [Deploy Now](https://www.ionos.at/hosting/deploy-now "Deploy Now von IONOS") von IONOS verbinden Sie Ihr Repository einfach, führen den Build automatisch durch und greifen anschließend auf eine zuverlässige Infrastruktur zu. Profitieren Sie dabei von passenden Tarifen und einer fachkundigen Beratung!

## Python `Counter` in Kombination mit einem einfachen String

Einen Eindruck davon, welche Zeitersparnis und Arbeitserleichterung Python `Counter` bieten kann, bekommen Sie, wenn Sie die Klasse auf einen String anwenden. Ein String ist die **Abfolge von Zeichen**, die durch Anführungsstriche markiert werden. Auch Leerzeichen werden dabei berücksichtigt. Wir wählen den folgenden String für unser Beispiel:

```python
from collections import Counter
String = "Dies ist ein Beispiel."
counter_string = Counter(String)
print(Counter(String))
```

Nun wird jedes Zeichen als Substring gezählt. Die Ausgabe könnte also so aussehen:

```python
Counter({'i': 4, 'e': 3, 's': 3, ' ': 3, 't': 2, 'D': 1, 'n': 1, 'B': 1, 'j': 1, 'p': 1, 'l': 1, '.': 1})
```

## Erweiterungen mit `.update()`

Die Optionen, die Python `Counter` bietet, sind vielfältig. So ist es zum Beispiel auch möglich, eine bestehende Zählung zu erweitern. Dafür nutzen Sie `.update()` und verbinden diese Erweiterung mit dem Counter. Dabei erstellen wir zunächst einen einfachen Code nach dem obigen Prinzip, wobei wir den String zur Abwechslung nicht extra auszeichnen:

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

Unsere Ausgabe ist dann diese:

```python
Counter({'b' : 1, 'l' : 1, 'a' : 1, 'u' : 1})
```

Wenden wir nun `.update()` an, sieht der Code so aus:

```python
from collections import Counter
farben = Counter({'b' : 1, 'l' : 1, 'a' : 1, 'u' : 1})
farben.update("grau")
print(farben)
```

Dadurch erhalten wir auch eine aktualisierte Ausgabe:

```python
Counter({'a' : 2, 'u' : 2, 'b' : 1, 'l' : 1, 'g' : 1, 'r' : 1})
```

## Auf die Werte von Python `Counter` zugreifen

Sie haben die Möglichkeit, auf die Werte von Python `Counter` zuzugreifen, da diese Klasse **ähnlich wie `Dictionary` funktioniert**. Im folgenden Codebeispiel zeigen wir Ihnen einige Variationen und die dazugehörigen Ausgaben. Hierbei fungieren „letters“ als Schlüssel (keys) und „counts“ als Werte (values).

```python
from collections import Counter
letters = Counter("flachdach")
letters["a"]
2
letters["h"]
2
```

```python
for letter in letters:
	print(letter, letters[letter])
f 1
l 1
a 2
c 2
h 2
d 1
```

So sähe ein Beispiel mit der Methode `.keys()` aus:

```python
for letter in letters.keys():
	print(letter, letters[letter])
f 1
l 1
a 2
c 2
h 2
d 1
```

Dies ist ein Beispiel mit `.values()`:

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

Dies ist die Methode `.items()`:

```python
for letter, count in letters.items():
	print(letter, count)
f 1
l 1
a 2
c 2
h 2
d 1
```

## Elemente aus der Klasse löschen

Wenn Sie ein Element aus Python `Counter` löschen möchten, ist dafür `del` die richtige Wahl:

```python
from collections import Counter
beispiel = {'b' : 1, 'l' : 1, 'a' : 1, 'u' : 1}
del beispiel["b"]
print(Counter(beispiel))
```

Ihre neue Ausgabe sieht dann folgendermaßen aus:

```python
Counter({'l' : 1, 'a' : 1, 'u' : 1})
```

## Größte Anhäufung bestimmen mit `most_common(n)`

Mit `most_common(n)` für Python `Counter` können Sie herausfinden, welche Elemente am häufigsten und am seltensten vertreten sind. Dafür überlegen wir uns ein Beispiel, bei dem ein Produkt in verschiedenen Farben aufgelistet ist. Neben den Farben ist hinterlegt, wie häufig sich das Produkt in der entsprechenden Variante noch im Lager befindet. Ein negativer Wert bedeutet, dass sich kein entsprechender Artikel mehr im Lager befindet, diese Variante aber trotzdem vorbestellt wurde. Möchten wir nun überprüfen, von welcher Variante es noch die meisten Artikel gibt, nutzen wir dafür diesen Code:

```python
from collections import Counter
farbvarianten = Counter({'blau' : 2, 'grau' : -1, 'schwarz' : 0})
meiste_artikel = farbvarianten.most_common(1)
print(meiste_artikel)
```

Die Ausgabe ist dann diese:

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

Auch die kleinste Artikelanzahl können wir uns anzeigen lassen. Dafür ändern wir den Code folgendermaßen ab:

```python
from collections import Counter
farbvarianten = Counter({'blau' : 2, 'grau' : -1, 'schwarz' : 0})
wenigste_artikel = farbvarianten.most_common()[:-2:-1]
print(wenigste_artikel)
```

Die entsprechende Ausgabe:

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

## Arithmetische Rechnung mit Python `Counter`

Auch **arithmetische Rechnungen** sind mit der Hilfe von Python `Counter` möglich. Wichtig zu beachten ist dabei allerdings, dass nur positive Werte ausgegeben werden. Im folgenden Code probieren wir einige Rechenarten aus.

Eine einfache Addition:

```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, 'b' : 3, 'c' : 3})
```

So sieht die Subtraktion aus:

```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, 'b' : 1})
```

Da der Wert von ‘c’ nun negativ wäre, wird er nicht mit ausgegeben.

## Datentypen nach Häufigkeit sortieren

Eine weitere Option, die Ihnen die Klasse bietet, ist eine **Aufzählung von Datentypen** in einem Ordner. Dafür stellen wir uns beispielhaft einen Ordner vor, der „Bilder“ heißt und zahlreiche unterschiedliche Dateien mit verschiedenen Datentypen enthält. Für eine Auflistung verwenden wir den folgenden Code:

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

## Negative und Nullwerte ausschließen

Um Nullwerte oder negative Werte mit Python `Counter` zu entfernen, nutzen Sie diesen Code:

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

Die entsprechende Ausgabe ist dann diese:

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

Tipp In unserem Digital Guide finden Sie noch zahlreiche weitere Artikel rund um die beliebte Programmiersprache. Hier erklären wir, welche [Python-Operatoren](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-operatoren/) es gibt, führen Sie durch die [Installation von Python](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-installieren/) und zeigen Ihnen die wichtigsten [Python-Grundlagen und wertvolle Tipps](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-tutorial/).


This is a markdown version of: [https://www.ionos.at/digitalguide/websites/web-entwicklung/python-counter/](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-counter/) for AI/LLM consumption.