Skip to content

Python Counter: Elemente zählen und auszählen mit collections.Counter

Soren Atelier
Name
Soren Atelier

Updated on

Das Zählen von Vorkommen von Elementen in einer Liste, Zeichen in einem String oder Wörtern in einem Dokument gehört zu den häufigsten Aufgaben in der Programmierung. Manuell bedeutet das Schleifen schreiben, Dictionaries initialisieren und fehlende Schlüssel mit Bedingungen oder .get()-Aufrufen behandeln. Dieser Boilerplate-Code verdeckt Ihre eigentliche Absicht, verursacht Bugs und bremst Sie jedes Mal aus, wenn Sie eine Häufigkeitszählung benötigen.

Pythons collections.Counter beseitigt diese Reibung vollständig. Er zählt hashbare Objekte in einer einzigen Zeile, bietet eingebaute Methoden zum Finden der häufigsten Elemente und unterstützt arithmetische Operationen zum Vergleichen von Häufigkeitsverteilungen. Dieser Leitfaden behandelt alles, was Sie brauchen, um Counter effektiv einzusetzen, von grundlegendem Zählen bis zu fortgeschrittenen Multiset-Operationen.

📚

    Was ist collections.Counter?

    Counter ist eine Dictionary-Unterklasse in Pythons collections-Modul, die speziell zum Zählen hashbarer Objekte entwickelt wurde. Jedes Element wird als Dictionary-Schlüssel gespeichert, und seine Anzahl wird als entsprechender Wert gespeichert.

    from collections import Counter
 
fruits = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
count = Counter(fruits)
print(count)
# Counter({'apple': 3, 'banana': 2, 'cherry': 1})

    Einen Counter erstellen

    Counter akzeptiert mehrere Eingabetypen, was ihn flexibel für verschiedene Datenquellen macht.

    from collections import Counter
 
# Aus einer Liste
colors = Counter(['red', 'blue', 'red', 'green', 'blue', 'red'])
print(colors)  # Counter({'red': 3, 'blue': 2, 'green': 1})
 
# Aus einem String (zählt jedes Zeichen)
letters = Counter('mississippi')
print(letters)  # Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})
 
# Aus einem Dictionary
inventory = Counter({'apples': 15, 'oranges': 10, 'bananas': 7})
 
# Aus Schlüsselwort-Argumenten
stock = Counter(laptops=5, monitors=12, keyboards=30)

    Auf Zählungen zugreifen

    Einfache Indizierung

    Greifen Sie auf Zählungen wie bei einem regulären Dictionary zu, aber fehlende Schlüssel geben 0 zurück statt KeyError auszulösen:

    from collections import Counter
 
c = Counter(['a', 'b', 'a'])
print(c['a'])  # 2
print(c['z'])  # 0 (kein KeyError!)
 
# Vergleich mit regulärem Dict-Verhalten
d = {'a': 2, 'b': 1}
# d['z']  # Würde KeyError auslösen

    Dieses Null-Standard-Verhalten eliminiert die Notwendigkeit von .get(key, 0) oder defaultdict(int) in vielen Zählszenarien.

    Alle Elemente abrufen

    Die Methode elements() gibt einen Iterator über Elemente zurück, wobei jedes so oft wiederholt wird wie seine Anzahl:

    from collections import Counter
 
c = Counter(a=3, b=2, c=1)
print(list(c.elements()))
# ['a', 'a', 'a', 'b', 'b', 'c']

    Die most_common()-Methode

    Die Methode most_common() gibt Elemente sortiert nach Häufigkeit zurück.

    from collections import Counter
 
text = "to be or not to be that is the question"
word_freq = Counter(text.split())
 
# Alle Elemente nach Häufigkeit sortiert
print(word_freq.most_common())
# [('to', 2), ('be', 2), ('or', 1), ('not', 1), ...]
 
# Nur die Top N Elemente
log_levels = Counter(['INFO', 'WARNING', 'INFO', 'ERROR', 'INFO', 'DEBUG',
                      'WARNING', 'INFO', 'ERROR', 'INFO'])
print(log_levels.most_common(2))
# [('INFO', 5), ('WARNING', 2)]
 
# Am seltensten (umgekehrtes Slice)
print(log_levels.most_common()[-2:])
# [('DEBUG', 1), ('ERROR', 2)]

    Counter-Arithmetik-Operationen

    Counter unterstützt arithmetische und Mengenoperationen zum Kombinieren und Vergleichen von Häufigkeitsverteilungen.

    from collections import Counter
 
morning = Counter(coffee=10, tea=5, juice=3)
afternoon = Counter(coffee=8, tea=7, water=4)
 
# Addition: kombiniert Zählungen
total = morning + afternoon
print(total)  # Counter({'coffee': 18, 'tea': 12, 'water': 4, 'juice': 3})
 
# Subtraktion: behält nur positive Zählungen
stock = Counter(apples=20, oranges=15, bananas=10)
sold = Counter(apples=8, oranges=15, bananas=12)
remaining = stock - sold
print(remaining)  # Counter({'apples': 12})
 
# Schnittmenge (&): Minimum der entsprechenden Zählungen
a = Counter(apple=3, banana=2, cherry=5)
b = Counter(apple=1, banana=4, cherry=2)
print(a & b)  # Counter({'cherry': 2, 'banana': 2, 'apple': 1})
 
# Vereinigung (|): Maximum der entsprechenden Zählungen
print(a | b)  # Counter({'cherry': 5, 'banana': 4, 'apple': 3})
 
# Unäres +: Null- und negative Zählungen entfernen
c = Counter(a=3, b=0, c=-2)
print(+c)  # Counter({'a': 3})

    Aktualisieren und Subtrahieren

    from collections import Counter
 
# update() ADDIERT Zählungen (anders als dict.update, das ersetzt)
c = Counter(a=3, b=1)
c.update(['a', 'b', 'b', 'c'])
print(c)  # Counter({'a': 4, 'b': 3, 'c': 1})
 
# subtract() subtrahiert Zählungen (behält Null und negative)
c = Counter(a=4, b=2, c=0)
c.subtract(Counter(a=1, b=3, c=2))
print(c)  # Counter({'a': 3, 'b': -1, 'c': -2})
 
# total() gibt die Summe aller Zählungen zurück (Python 3.10+)
inventory = Counter(widgets=50, gadgets=30, gizmos=20)
print(inventory.total())  # 100

    Praktische Anwendungsfälle

    Wortfrequenz-Analyse

    from collections import Counter
import re
 
text = """
Python is a versatile programming language. Python is used for web development,
data science, machine learning, and automation. Python's simplicity makes it
a favorite among developers.
"""
 
words = re.findall(r'\b[a-z]+\b', text.lower())
word_freq = Counter(words)
 
print("Top 5 most frequent words:")
for word, count in word_freq.most_common(5):
    print(f"  {word}: {count}")

    Anagramm-Erkennung

    from collections import Counter
 
def are_anagrams(word1, word2):
    return Counter(word1.lower()) == Counter(word2.lower())
 
print(are_anagrams("listen", "silent"))  # True
print(are_anagrams("hello", "world"))    # False

    Abstimmungssystem

    from collections import Counter
 
votes = ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob', 'Alice',
         'Charlie', 'Alice', 'Bob', 'Alice']
 
results = Counter(votes)
winner, winning_votes = results.most_common(1)[0]
total_votes = sum(results.values())
 
print(f"Election Results (Total votes: {total_votes}):")
for candidate, count in results.most_common():
    percentage = (count / total_votes) * 100
    print(f"  {candidate}: {count} votes ({percentage:.1f}%)")
print(f"\nWinner: {winner} with {winning_votes} votes")

    Log-Datei-Analyse

    from collections import Counter
import re
 
log_entries = [
    "2026-02-10 08:15:00 ERROR Database connection failed",
    "2026-02-10 08:15:01 INFO Retrying connection",
    "2026-02-10 08:15:02 ERROR Database connection failed",
    "2026-02-10 08:16:00 WARNING Disk usage at 85%",
    "2026-02-10 08:17:00 INFO Request processed",
    "2026-02-10 08:18:00 ERROR API timeout",
]
 
levels = Counter(
    re.search(r'(INFO|WARNING|ERROR)', line).group()
    for line in log_entries
)
print("Log Level Distribution:")
for level, count in levels.most_common():
    print(f"  {level}: {count}")

    Counter vs defaultdict(int): Wann welchen verwenden

    EigenschaftCounterdefaultdict(int)
    ZweckSpeziell für Zählung gebautUniverselles Standard-Dictionary
    InitialisierungCounter(iterable) zählt in einem SchrittErfordert manuelle Schleife
    Fehlende SchlüsselGibt 0 zurückGibt 0 zurück
    most_common()Eingebaute MethodeMuss manuell sortiert werden
    Arithmetik (+, -)UnterstütztNicht unterstützt
    Mengenoperationen (&, |)UnterstütztNicht unterstützt
    elements()Gibt erweiterten Iterator zurückNicht verfügbar
    update() VerhaltenAddiert zu ZählungenErsetzt Werte
    LeistungOptimierte C-ImplementierungEtwas langsamer
    Am besten fürHäufigkeitsanalyse, Multiset-OpsBenutzerdefinierte Standardwert-Logik

    Verwenden Sie Counter, wenn Ihr primäres Ziel das Zählen von Elementen oder der Vergleich von Häufigkeitsverteilungen ist. Verwenden Sie defaultdict(int), wenn das Zählen nebensächlich zu einem breiteren Datenstrukturmuster ist.

    Häufigkeitsverteilungen visualisieren

    Nach dem Zählen von Elementen mit Counter möchten Sie die Verteilung oft visualisieren. Für interaktive Erkundung von Häufigkeitsverteilungen verwandelt PyGWalker (opens in a new tab) einen pandas DataFrame in eine Tableau-ähnliche interaktive Benutzeroberfläche direkt in Jupyter:

    from collections import Counter
import pandas as pd
import pygwalker as pyg
 
# Counter in DataFrame umwandeln
data = Counter("abracadabra")
df = pd.DataFrame(data.items(), columns=['Character', 'Count'])
 
# Interaktive Visualisierung starten
walker = pyg.walk(df)

    Dies ist besonders nützlich, wenn Sie große Counter haben und Häufigkeitsverteilungen interaktiv filtern, sortieren und erkunden möchten.

    FAQ

    Was macht collections.Counter in Python?

    collections.Counter ist eine Dictionary-Unterklasse, die hashbare Objekte zählt. Sie übergeben ihr ein beliebiges Iterable und sie gibt ein dictionary-ähnliches Objekt zurück, bei dem die Schlüssel die Elemente und die Werte deren Anzahl sind. Sie bietet Methoden wie most_common() für Häufigkeitsanalyse, arithmetische Operatoren zum Kombinieren von Zählungen und gibt Null für fehlende Schlüssel zurück, anstatt einen KeyError auszulösen.

    Wie zähle ich Vorkommen von Elementen in einer Liste mit Python Counter?

    Importieren Sie Counter aus collections und übergeben Sie Ihre Liste direkt: Counter(['a', 'b', 'a', 'c']) gibt Counter({'a': 2, 'b': 1, 'c': 1}) zurück. Für bestimmte Zählungen indizieren Sie mit dem Element: counter['a'] gibt 2 zurück. Für die häufigsten Elemente verwenden Sie counter.most_common(n).

    Was ist der Unterschied zwischen Counter und einem regulären Dictionary zum Zählen?

    Counter ist speziell für das Zählen gebaut: Er zählt ein komplettes Iterable in einem Aufruf, gibt 0 für fehlende Schlüssel zurück statt KeyError, hat most_common() für sortierte Häufigkeiten, unterstützt arithmetische Operationen (+, -, &, |) und enthält update(), das zu Zählungen addiert statt sie zu ersetzen. Ein reguläres Dictionary erfordert manuelle Schleifenkonstruktion und hat diese Funktionen nicht.

    Kann ich zwei Counter-Objekte subtrahieren oder addieren?

    Ja. Der +-Operator kombiniert Zählungen: Counter(a=3) + Counter(a=1) ergibt Counter({'a': 4}). Der --Operator subtrahiert Zählungen und verwirft Null- oder negative Ergebnisse. Der &-Operator gibt das Minimum (Schnittmenge) und | das Maximum (Vereinigung) der entsprechenden Zählungen. Für Subtraktion, die negative Zählungen beibehält, verwenden Sie stattdessen die Methode subtract().

    Ist Python Counter effizient für große Datensätze?

    Ja. Counter ist in optimiertem C-Code in CPython implementiert, was ihn schneller macht als manuelle Python-Schleifen zum Zählen. Das Erstellen eines Counter aus einem Iterable ist O(n). Der Zugriff auf einzelne Zählungen ist O(1). Die most_common(k)-Operation verwendet intern einen Heap für O(n log k) Effizienz, wenn Sie nur die Top-k-Elemente benötigen.

    Fazit

    Pythons collections.Counter ist das Standardwerkzeug zum Zählen von Elementen und zur Häufigkeitsanalyse. Er ersetzt manuelles Dictionary-Zählen durch einen einzigen Konstruktoraufruf, bietet most_common() für sofortige Rangfolge und unterstützt arithmetische Operationen, die Multiset-Vergleiche trivial machen. Ob Sie Wortfrequenzen analysieren, Stimmen auszählen, Inventar verwalten oder Log-Dateien auswerten -- Counter übernimmt das Zählen, damit Sie sich auf die Logik konzentrieren können, die zählt.

    📚