Python-Anzahl: Moderne Muster, Fallstricke und praktische Beispiele

Zählen klingt einfach, bis die Ergebnisse ein bisschen – oder ganz schön – daneben liegen. Ich habe schon gesehen, dass Frequenzprüfungen mit wiederholten „ list.count() “-Aufrufen oder falsch verwendeten Pandas-Methoden durchgeführt wurden, die fehlende Werte einfach ignorieren. Das Ergebnis: langsamer Code und falsche Zahlen. Die Lösung ist, das richtige Tool für die Aufgabe zu nehmen: collections.Counter für Häufigkeitskarten, das eingebaute count() für schnelle Einzelwertabfragen und pandas' value_counts(), wenn du in einem DataFrame bist.

Was ist ein Zähler und wie funktioniert er?

collections.Counter ist eine Unterklasse von Wörterbüchern zum Zählen von hashbaren Objekten (eine Multimenge). Du kannst ein „ Counter “ aus einer iterierbaren Struktur oder einer Zuordnung erstellen. Fehlende Schlüssel werden standardmäßig auf 0 gesetzt; Zählungen können erhöht oder verringert werden; und mehrere praktische Methoden machen häufige Aufgaben einfach.

from collections import Counter

# From an iterable (one pass over the data)
nyc_eatery_types = [
    "Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant", "Food Cart",
    "Restaurant", "Mobile Food Truck", "Snack Bar", "Mobile Food Truck"
]
eatery_type_counts = Counter(nyc_eatery_types)
print(eatery_type_counts)  # dict-like view
print(eatery_type_counts["Restaurant"])  # missing keys return 0 instead of KeyError
print(eatery_type_counts["Kiosk"])

Counter({'Mobile Food Truck': 3, 'Food Cart': 2, 'Snack Bar': 2, 'Restaurant': 2})
2
0

Verlass dich nicht auf die Reihenfolge, in der die Elemente in einem „ Counter “ durchlaufen werden. Wenn du eine Rangliste brauchst, schau mal bei most_common() vorbei.

Finde die häufigsten Werte mit most_common()

Counter.most_common(n) gibt eine Liste von „ (item, count) “-Paaren in absteigender Reihenfolge zurück. Gib „ n “ an, um das Ergebnis einzuschränken, oder lass es weg, um alle Paare zu bekommen.

top_3 = eatery_type_counts.most_common(3)
print(top_3)

[('Mobile Food Truck', 3), ('Food Cart', 2), ('Snack Bar', 2)]

Benutz das, wenn du Häufigkeitsanalysen, Ranglisten oder schnelle Plausibilitätsprüfungen für kategoriale Daten brauchst.

Mach mehr mit Counter

Zählungen aktualisieren und subtrahieren

Die Geschäftsdaten ändern sich. update() erhöht die Zahlen, während subtract() sie verringert. Beide nehmen Iterables oder Mappings an.

new_permits = ["Restaurant", "Food Cart", "Restaurant"]
eatery_type_counts.update(new_permits)  # add 1 for each occurrence
print(eatery_type_counts)

closures = {"Snack Bar": 1}
eatery_type_counts.subtract(closures)   # reduce counts (can go negative)
print(eatery_type_counts)

Counter({'Mobile Food Truck': 3, 'Restaurant': 4, 'Food Cart': 3, 'Snack Bar': 2})
Counter({'Restaurant': 4, 'Mobile Food Truck': 3, 'Food Cart': 3, 'Snack Bar': 1})

Wenn ein Zähler auf 0 oder darunter fällt, wird er von Methoden wie „ elements() “ und „ most_common() “ einfach ignoriert. Um einen Schlüssel komplett zu löschen, mach das mit „ del counter[key] “.

Summen und Top-N berechnen

Ab Python 3.10 gibt „ Counter.total() “ die Summe aller Zählungen zurück. Das ist praktisch, wenn du Proportionen oder Anteile brauchst.

total_permits = eatery_type_counts.total()
for eatery, count in eatery_type_counts.most_common(3):
    share = count / total_permits
    print(f"{eatery}: {count} ({share:.1%})")

Sequenzen mit elements() neu aufbauen

elements() liefert jedes Element so oft, wie es gezählt wird. Die Reihenfolge ist beliebig.

expanded = list(eatery_type_counts.elements())
print(len(expanded), "items reconstructed from counts")

Mathematik und Mengenoperationen benutzen

Du kannst Zähler mit arithmetischen Operationen und Min/Max-Operationen kombinieren. Die Ergebnisse lassen Null- und negative Werte weg.

from collections import Counter

a = Counter({"Food Cart": 5, "Restaurant": 2})
b = Counter({"Food Cart": 3, "Snack Bar": 4})

print(a + b)   # add counts
print(a - b)   # subtract (keeps positives only)
print(a & b)   # intersection: min of counts
print(a | b)   # union: max of counts

Counter({'Food Cart': 8, 'Snack Bar': 4, 'Restaurant': 2})
Counter({'Food Cart': 2, 'Restaurant': 2})
Counter({'Food Cart': 3})
Counter({'Food Cart': 5, 'Snack Bar': 4, 'Restaurant': 2})

Wann sollte man list.count(), Counter oder pandas verwenden?

Such dir das einfachste Tool aus, das deinen Anforderungen und Leistungsbeschränkungen entspricht.

Einzelwertprüfungen mit count()

Benutz die eingebaute Funktion „ count() “, wenn du nur wissen willst, wie oft ein Wert in einer Sequenz vorkommt oder wie oft eine nicht überlappende Teilzeichenfolge in einer Zeichenfolge vorkommt.

numbers = [1, 2, 2, 3, 2]
print(numbers.count(2))  # 3

word = "banana"
print(word.count("a"))   # 3

text = "aaa"
print(text.count("aa"))  # 1: non-overlapping matches only
print("cat".count(""))   # 4: empty string counts len(s)+1 positions

Pass auf mit Booleschen Werten und Ganzzahlen: True == 1 und False == 0. Das kann die Zahlen in die Höhe treiben, wenn du verschiedene Typen mischst.

mixed = [1, True, 0, False, True]
print(mixed.count(1))  # 3 (counts 1 and True)
print(mixed.count(0))  # 2 (counts 0 and False)

Vermeide es, „ count() “ in Schleifen mit großen Datenmengen immer wieder aufzurufen; jeder Aufruf durchsucht die ganze Sequenz.

# Inefficient: O(n^2) for large lists
# freq = {x: numbers.count(x) for x in numbers}

# Efficient: one pass
from collections import Counter
freq = Counter(numbers)

mehrere Frequenzen mit Zähler

Wenn du die Anzahl vieler eindeutiger Werte brauchst, erstelle einmalig einen „ Counter “ und frag ihn bei Bedarf ab. Es ist übersichtlich, schnell und genau für diesen Anwendungsfall gemacht.

Tabellendaten mit Pandas

Bei Pandas berechnen die Funktionen „ DataFrame.count() “ und „ Series.count() “ die Anzahl der nicht fehlenden Werte. Um eine Frequenztabelle mit Werten zu bekommen, schau mal auf Series.value_counts() vorbei.

import pandas as pd
df = pd.DataFrame({
    "line": ["A", "A", "B", None, "B", "B"],
    "ridership": [100, None, 120, 130, None, 150],
})

print(df["line"].count())         # 5 (non-missing)
print(df["line"].value_counts())  # value frequencies

# For full row count, use len(df), not df.count()
print(len(df))                    # 6

Daten mit Counter überprüfen und bereinigen

Vor der Analyse schaue ich mir die Konsistenz der Kategorien, unerwartete Werte und Duplikate an. Mit „ Counter “ kann ich diese Überprüfungen schnell und wiederholbar durchführen.

from collections import Counter

# Example: validate allowed categories
allowed_types = {"Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant"}
type_counts = Counter(nyc_eatery_types)

unexpected = {t: c for t, c in type_counts.items() if t not in allowed_types}
if unexpected:
    print("Unexpected categories found:", unexpected)

# Example: flag duplicates (e.g., station IDs appearing more than once)
station_ids = ["ST-001", "ST-002", "ST-003", "ST-002", "ST-004", "ST-002"]
dup_counts = Counter(station_ids)
duplicates = [sid for sid, c in dup_counts.items() if c > 1]
print("Duplicate station IDs:", duplicates)

Praktische Tipps und häufige Probleme

Diese Details sparen Zeit und verhindern kleine Fehler.

• Counter ist wie ein Wörterbuch: Fehlende Schlüssel geben 0 zurück; mit „ del counter[key] “ kannst du Einträge löschen. Vermeide es, Nullen zu speichern, es sei denn, du brauchst sie vorübergehend.

• Verlass dich nicht auf die Reihenfolge der Iterationen. Benutze „ most_common() “, um eine sortierte Ausgabe zu bekommen.

• str.count() zählt nicht überlappende Übereinstimmungen. Für die Zählung überlappender Teilzeichenfolgen nimm „ re.finditer() “.

• Vermeide es, wiederholt „ list.count() “ für dieselbe große Sequenz aufzurufen. Bau stattdessen ein „ Counter “.

• Bei Pandas ist „ .count() “ für nicht fehlende Zählungen gedacht; für Wertfrequenzen nimm „ .value_counts() “.

Minimale Muster, auf die ich mich verlasse

Das sind die Ausschnitte, die ich am häufigsten in der Produktion und im Unterricht benutze.

• Ein-Durchlauf-Frequenzkarte: Counter(iterable)

• Top-N-Kategorien: Counter(data).most_common(n)

• Inkrementelle Updates: counter.update(batch) oder counter.subtract(batch)

• Einzelwertprüfung: sequence.count(x) (in Schleifen vermeiden)

• Tabellarische Häufigkeiten: df["col"].value_counts() (nicht df.count())

Fazit

collections.Counter ist das richtige Tool, um mehrere Werte schnell und übersichtlich zu zählen. Nutze die integrierte Funktion „ count() “ für einmalige Überprüfungen, „ C “ ( ounter ) für Häufigkeitskarten und Top-N-Analysen und „ Series.value_counts() “, wenn du mit Pandas arbeitest. Achte auf Randfälle beim Zählen von Zeichenfolgen, die Äquivalenz von Booleschen Werten und Ganzzahlen sowie den Unterschied zwischen nicht fehlenden Zählungen und Wertehäufigkeiten. Mit diesen Mustern kannst du schnell und richtig zählen.