So verwenden Sie den Python-Zähler aus dem Collections-Modul

Inhaltsverzeichnis

In dieser Anleitung werden wir die Verwendung des Counter-Objekts aus dem Python collections-Modul erkunden.

Bei der Arbeit mit umfangreichen Sequenzen in Python, wie Listen oder Zeichenketten, ist es oft notwendig, die Häufigkeit des Auftretens einzelner Elemente zu ermitteln.

Ein Python-Dictionary kann dies zwar leisten, jedoch vereinfacht die Counter-Klasse des collections-Moduls diese Aufgabe, indem sie ein Objekt erstellt, das die Elemente und ihre Anzahl innerhalb einer Sequenz als Dictionary speichert.

Im Laufe dieser Anleitung werden Sie lernen, wie man:

Das Counter-Objekt von Python verwendet.
Ein Python-Dictionary erstellt, um die Zählwerte von Elementen in einem Iterable zu speichern.
Das Dictionary mittels des Python-Zählers mit einer vereinfachten Syntax neu erstellt.
Operationen wie Aktualisieren, Subtrahieren und das Finden der Schnittmenge zwischen zwei Counter-Objekten durchführt.
Die am häufigsten vorkommenden Elemente mit der most_common()-Methode extrahiert.

Legen wir los!

Python Collections Modul und die Counter Klasse

Oftmals wird ein Python-Dictionary verwendet, um Elemente und ihre Häufigkeiten in einem Iterable zu speichern. Dabei werden die Elemente als Schlüssel und ihre Anzahl als Werte gespeichert.

Da die Counter-Klasse Teil des integrierten collections-Moduls von Python ist, kann sie wie folgt in Ihr Python-Skript importiert werden:

from collections import Counter

Nach dem Import kann ein Counter-Objekt wie folgt instanziert werden:

<counter_object> = Counter(iterable)

Dabei gilt:

iterable kann eine beliebige gültige Python-Iterable sein, z.B. eine Liste, eine Zeichenkette oder ein Tupel.
Die Elemente in der Iterable müssen hashbar sein.

Nun, da wir wissen, wie man Counter zur Erzeugung von Zähler-Objekten aus beliebigen Python-Iterables nutzt, beginnen wir mit dem Programmieren.

Die Beispiele in diesem Tutorial sind in diesem GitHub-Gist zu finden.

Wie man ein Zählerobjekt aus Python Iterables erzeugt

Wir erstellen eine Python-Zeichenkette, nennen sie „Wort“ und geben ihr den Wert „Renaissance“.

>>> wort = "renaissance"

Unser Ziel ist es, ein Dictionary zu erstellen, in dem jeder Buchstabe der Zeichenkette so oft abgebildet wird, wie er in der Zeichenkette vorkommt. Ein möglicher Ansatz wäre die Nutzung von for-Schleifen wie folgt:

>>> buchstaben_zaehler = {}
>>> for buchstabe in wort:
...     if buchstabe not in buchstaben_zaehler:
...         buchstaben_zaehler[buchstabe] = 0
...     buchstaben_zaehler[buchstabe] += 1
...
>>> buchstaben_zaehler
{'r': 1, 'e': 2, 'n': 2, 'a': 2, 'i': 1, 's': 2, 'c': 1}

Betrachten wir das obige Code-Snippet im Detail:

buchstaben_zaehler wird als leeres Python-Dictionary initialisiert.
Die Zeichenkette wort wird durchlaufen.
Es wird geprüft, ob der buchstabe bereits im Dictionary buchstaben_zaehler existiert.
Wenn der buchstabe nicht existiert, wird er mit einem Wert von 0 hinzugefügt, und dann um 1 erhöht.
Bei jedem Vorkommen eines Buchstabens in der Zeichenkette wird der entsprechende Wert um 1 erhöht.
Dieser Prozess wiederholt sich, bis die gesamte Zeichenkette verarbeitet wurde.

Wir haben das Dictionary buchstaben_zaehler selbst erstellt, indem wir eine for-Schleife verwendet haben, um die Zeichenkette wort zu durchlaufen.

Lassen Sie uns nun die Counter-Klasse aus dem collections-Modul nutzen. Um buchstaben_zaehler zu erhalten, müssen wir nur die Zeichenkette wort an Counter() übergeben, ohne Iterables zu durchlaufen.

>>> from collections import Counter
>>> buchstaben_zaehler = Counter(wort)
>>> buchstaben_zaehler
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1})

Das Counter-Objekt ist ebenfalls ein Python-Dictionary. Wir können die eingebaute Funktion isinstance() verwenden, um dies zu überprüfen:

>>> isinstance(buchstaben_zaehler,dict)
True

Wie wir sehen, gibt isinstance(buchstaben_zaehler, dict) True zurück, was bestätigt, dass das Counter-Objekt buchstaben_zaehler eine Instanz der Python-Klasse dict ist.

Ändern des Zählerobjekts

Bisher haben wir gelernt, wie man Counter-Objekte aus Python-Zeichenketten erzeugt.

Counter-Objekte können auch durch Aktualisierung mit Elementen aus einem anderen Iterable oder durch Subtrahieren eines anderen Iterables von ihnen verändert werden.

Aktualisieren eines Zählers mit Elementen aus einem anderen Iterable

Lassen Sie uns eine weitere Zeichenkette namens anderes_wort initialisieren:

>>> anderes_wort = "effervescence"

Nehmen wir an, wir möchten das Counter-Objekt buchstaben_zaehler mit den Elementen aus der Zeichenkette anderes_wort aktualisieren.

Wir können die Methode update() auf das Counter-Objekt buchstaben_zaehler anwenden.

>>> buchstaben_zaehler.update(anderes_wort)
>>> buchstaben_zaehler
Counter({'e': 7, 'n': 3, 's': 3, 'c': 3, 'r': 2, 'a': 2, 'f': 2, 'i': 1, 'v': 1})

Die Ausgabe zeigt, dass das Counter-Objekt aktualisiert wurde und nun auch die Buchstaben und die Anzahl ihrer Vorkommen aus anderes_wort enthält.

Subtrahieren von Elementen aus einem anderen Iterable

Nun wollen wir den Wert von anderes_wort vom Objekt buchstaben_zaehler subtrahieren. Hierfür verwenden wir die Methode subtract(). <counter-object>.subtract(<some-iterable>) subtrahiert die Werte, die den Elementen in <some-iterable> entsprechen, von <counter-object>.

Subtrahieren wir anderes_wort von buchstaben_zaehler.

>>> buchstaben_zaehler.subtract(anderes_wort)
>>> buchstaben_zaehler
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1, 'f': 0, 'v': 0})

Wir sehen, dass die Werte, die den Buchstaben in anderes_wort entsprechen, subtrahiert wurden, aber die hinzugefügten Schlüssel „f“ und „v“ nicht entfernt wurden. Sie sind jetzt dem Wert 0 zugeordnet.

Hinweis: Hier haben wir anderes_wort, eine Python-Zeichenkette, an den Methodenaufruf subtract() übergeben. Wir können auch ein Python-Counter-Objekt oder ein anderes Iterable übergeben.

Schnittmenge zwischen zwei Counter-Objekten in Python

Gelegentlich kann es notwendig sein, die Schnittmenge zwischen zwei Python Counter-Objekten zu finden, um zu ermitteln, welche Schlüssel in beiden Objekten vorhanden sind.

Erstellen wir ein Counter-Objekt, nennen wir es buchstaben_zaehler_2, aus der Zeichenkette anderes_wort „effervescence“.

>>> anderes_wort = "effervescence"
>>> buchstaben_zaehler_2 = Counter(anderes_wort)
>>> buchstaben_zaehler_2
Counter({'e': 5, 'f': 2, 'c': 2, 'r': 1, 'v': 1, 's': 1, 'n': 1})

Wir können den Operator & verwenden, um die Schnittmenge zwischen buchstaben_zaehler und buchstaben_zaehler_2 zu ermitteln.

>>> buchstaben_zaehler & buchstaben_zaehler_2
Counter({'e': 2, 'r': 1, 'n': 1, 's': 1, 'c': 1})

Beachten Sie, wie wir die Schlüssel und die Anzahl der gemeinsamen Vorkommen der beiden Wörter erhalten. Sowohl ‚Renaissance‘ als auch ‚Effervescence‘ enthalten zwei Vorkommen von ‚e‘ und jeweils ein Vorkommen von ‚r‘, ’n‘, ’s‘ und ‚c‘ gemeinsam.

Die häufigsten Elemente mit most_common finden

Eine weitere häufige Operation für Python-Counter-Objekte ist die Suche nach den am häufigsten vorkommenden Elementen.

Um die Top-k der häufigsten Elemente im Zähler abzurufen, kann die Methode most_common() verwendet werden. Im folgenden Beispiel rufen wir most_common() auf buchstaben_zaehler auf, um die drei am häufigsten vorkommenden Buchstaben zu finden.

>>> buchstaben_zaehler.most_common(3)
(('e', 2), ('n', 2), ('a', 2))

Wir sehen, dass die Buchstaben „e“, „n“ und „a“ jeweils zweimal im Wort „Renaissance“ vorkommen.

Dies ist besonders nützlich, wenn der Zähler viele Einträge hat und man an den gängigsten Schlüsseln interessiert ist.

Fazit

Hier ist eine kurze Zusammenfassung der wichtigsten Erkenntnisse:

Die Counter-Klasse aus dem integrierten collections-Modul kann verwendet werden, um ein Dictionary mit den Zählwerten aller Elemente in einer Iterable zu erhalten. Es ist wichtig, sicherzustellen, dass alle Elemente in der Iterable hashbar sind.
Der Inhalt eines Python-Counter-Objekts kann mit dem Inhalt eines anderen Counter-Objekts oder eines anderen iterierbaren Objekts aktualisiert werden, indem die update()-Methode mit der folgenden Syntax verwendet wird: counter1.update(counter2). Anstelle von counter2 kann jedes Iterable verwendet werden.
Wenn der Inhalt eines der Iterables aus dem aktualisierten Zähler entfernt werden soll, kann die Methode subtract() verwendet werden: counter1.subtract(counter2).
Um die gemeinsamen Elemente zwischen zwei Counter-Objekten zu finden, kann der &-Operator verwendet werden. Für zwei Zähler zähler1 und zähler2 gibt zähler1 & zähler2 die Schnittmenge der beiden Zählerobjekte zurück.
Um die k häufigsten Elemente in einem Zähler zu erhalten, kann die Methode most_common() verwendet werden. counter.most_common(k) liefert die k häufigsten Elemente und die jeweiligen Anzahlen.

Als Nächstes werden wir das defaultdict erkunden, eine weitere Klasse im collections-Modul. defaultdict kann anstelle eines regulären Python-Dictionaries verwendet werden, um fehlende Schlüssel zu behandeln.