Zählen der Anzahl der Vorkommen der einzelnen Elemente in einer Liste mit Pythons Counter

In Python kann die Anzahl aller Elemente in einer Liste oder einem Tupel mit der eingebauten Funktion len() ermittelt werden, und die Anzahl der einzelnen Elemente (die Anzahl der Vorkommen jedes Elements) kann mit der Methode count() ermittelt werden.

Darüber hinaus kann die Klasse Counter der Python-Standardbibliothek Collections verwendet werden, um die Elemente in der Reihenfolge der Anzahl ihres Auftretens zu erhalten.

In diesem Abschnitt werden wir Folgendes besprechen

• Zählen Sie die Gesamtzahl der Elemente:len()
• Zählen Sie die Anzahl der einzelnen Elemente (die Anzahl der Vorkommen der einzelnen Elemente):count()
• Verwendung.collections.Counter
• Die Elemente werden in der Reihenfolge der Häufigkeit ihres Auftretens abgerufen:most_common()
• Zählen Sie die Anzahl (Art) der sich nicht überschneidenden Elemente (eindeutige Elemente).
• Zählen Sie die Anzahl der Elemente, die die Bedingung erfüllen.

Außerdem wird als konkretes Beispiel das Folgende mit Beispielcode erläutert.

• Zählt die Anzahl der Vorkommen eines Wortes in einer Zeichenkette.
• Zählt die Anzahl der Vorkommen eines Zeichens in einer Zeichenkette.

Das Beispiel ist eine Liste, aber die gleiche Verarbeitung kann mit Tupeln durchgeführt werden.

Zählen der Gesamtzahl der Elemente: len()

Um die Gesamtzahl der Elemente in einer Liste oder einem Tupel zu zählen, verwenden Sie die eingebaute Funktion len().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(len(l))
# 7

Zählen der Anzahl der einzelnen Elemente (Anzahl der Vorkommen jedes Elements): count()-Methode

Um die Anzahl der einzelnen Elemente zu zählen (die Anzahl der Vorkommen der einzelnen Elemente), verwenden Sie die Methode count() für Listen, Tupel usw.

• Common Sequence Operations — Built-in Types — Python 3.10.0 Documentation

Wird ein Wert, der nicht als Element existiert, als Argument übergeben, wird 0 zurückgegeben.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(l.count('a'))
# 4

print(l.count('b'))
# 1

print(l.count('c'))
# 2

print(l.count('d'))
# 0

Wenn Sie die Anzahl der Vorkommen der einzelnen Elemente auf einmal abfragen möchten, ist der folgende collection.Counter nützlich.

Wie man collections.Counter verwendet

Die Python-Standardbibliothek collections enthält eine Klasse Counter.

• collections – Counter — Container datatypes — Python 3.10.0 Documentation

Counter() ist eine Unterklasse des Wörterbuchtyps dict, der Daten in Form von Elementen als Schlüssel und Vorkommen als Werte hat.

import collections

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})

print(type(c))
# <class 'collections.Counter'>

print(issubclass(type(c), dict))
# True

Wenn ein Element als Schlüssel angegeben wird, kann die Anzahl der Elemente ermittelt werden. Wird ein Wert angegeben, der nicht als Element existiert, wird 0 zurückgegeben.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Sie können auch Methoden vom Typ Wörterbuch wie keys(), values(), items() usw. verwenden.

print(c.keys())
# dict_keys(['a', 'b', 'c'])

print(c.values())
# dict_values([4, 1, 2])

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

Diese Methoden geben Objekte vom Typ dict_keys usw. zurück. Sie können so verwendet werden, wie sie sind, wenn Sie eine for-Anweisung ausführen wollen. Wenn Sie sie in eine Liste umwandeln wollen, verwenden Sie list().

Ermitteln der Elemente in der Reihenfolge ihres Auftretens: Methode most_common()

Counter hat die Methode most_common(), die eine Liste von Tupeln der Form (Element, Anzahl der Vorkommen) sortiert nach der Anzahl der Vorkommen zurückgibt.

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]

Das Element mit der höchsten Anzahl von Vorkommnissen kann durch Angabe eines Indexes ermittelt werden, z. B. [0] für die höchste Anzahl von Vorkommnissen und [-1] für die niedrigste Anzahl von Vorkommnissen. Wenn Sie nur die Elemente oder nur die Anzahl der Vorkommen erhalten möchten, können Sie den Index weiter angeben.

print(c.most_common()[0])
# ('a', 4)

print(c.most_common()[-1])
# ('b', 1)

print(c.most_common()[0][0])
# a

print(c.most_common()[0][1])
# 4

Wenn Sie sie in der Reihenfolge der abnehmenden Anzahl der Vorkommen sortieren wollen, verwenden Sie den Slice mit dem Inkrement -1.

print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]

Wenn das Argument n für die Methode most_common() angegeben wird, werden nur die n Elemente mit der höchsten Anzahl von Vorkommen zurückgegeben. Wenn es weggelassen wird, werden alle Elemente zurückgegeben.

print(c.most_common(2))
# [('a', 4), ('c', 2)]

Wenn Sie anstelle eines Tupels (Element, Anzahl der Vorkommnisse) eine separate Liste von Elementen und Vorkommnissen, geordnet nach der Anzahl der Vorkommnisse, wünschen, können Sie diese wie folgt zerlegen

values, counts = zip(*c.most_common())

print(values)
# ('a', 'c', 'b')

print(counts)
# (4, 2, 1)

Die eingebaute Funktion zip() wird verwendet, um eine zweidimensionale Liste (in diesem Fall eine Liste von Tupeln) zu transponieren und sie dann zu entpacken und zu extrahieren.

Zählen Sie die Anzahl (Art) der sich nicht überschneidenden Elemente (eindeutige Elemente).

Um zu zählen, wie viele sich nicht überschneidende Elemente (eindeutige Elemente) es in einer Liste oder einem Tupel gibt (wie viele Typen es gibt), verwenden Sie Counter oder set() wie oben beschrieben.

Die Anzahl der Elemente im Counter-Objekt ist gleich der Anzahl der sich nicht überschneidenden Elemente in der ursprünglichen Liste, die mit len() ermittelt werden kann.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(len(c))
# 3

Sie können auch set(), den Konstruktor für den Settyp set, verwenden, was einfacher ist, wenn Sie kein Counter-Objekt benötigen.

Der Typ set ist ein Datentyp, der keine doppelten Elemente hat. Die Übergabe einer Liste an set() ignoriert doppelte Werte und gibt ein Objekt vom Typ set mit nur eindeutigen Werten als Elementen zurück. Die Anzahl der Elemente dieses Typs wird mit len() ermittelt.

print(set(l))
# {'a', 'c', 'b'}

print(len(set(l)))
# 3

Zählen Sie die Anzahl der Elemente, die die Bedingung erfüllen.

Um die Anzahl der Elemente in einer Liste oder einem Tupel zu zählen, die eine bestimmte Bedingung erfüllen, verwenden Sie die Notation für das Listenverständnis oder Generatorausdrücke.

Zählen Sie zum Beispiel die Anzahl der Elemente mit negativen Werten für die folgende Liste von Zahlen

l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

Die Anwendung eines bedingten Ausdrucks auf jedes Element in Listenform ergibt eine Liste, deren Elemente boolsche Werte sind (true, false). Der boolesche Typ bool ist eine Unterklasse des ganzzahligen Typs int, bei dem wahr als 1 und falsch als 0 behandelt wird. Daher kann die Anzahl der wahren Werte (die Anzahl der Elemente, die die Bedingung erfüllen) durch Berechnung der Summe mit sum() ermittelt werden.

print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]

print(sum([i < 0 for i in l]))
# 5

Ersetzt man [] in der Notation des Listenverständnisses durch (), erhält man einen Generatorausdruck. Die Notation des Listenverständnisses erzeugt eine Liste aller verarbeiteten Elemente, während der Generatorausdruck die Elemente sequentiell verarbeitet und daher speichereffizienter ist.

Wenn der Generatorausdruck das einzige Argument ist, kann () weggelassen werden, so dass er wie im letzten Fall geschrieben werden kann.

print(sum((i < 0 for i in l)))
# 5

print(sum(i < 0 for i in l))
# 5

Wenn Sie die Anzahl der falschen Werte zählen wollen (die Anzahl der Elemente, die die Bedingung nicht erfüllen), verwenden Sie not. Beachten Sie, dass > einen höheren Vorrang hat als not (es wird zuerst berechnet), daher sind die Klammern () in (i < 0) im folgenden Beispiel nicht notwendig.

print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]

print(sum(not (i < 0) for i in l))
# 6

Natürlich können die Bedingungen selbst geändert werden.

print(sum(i >= 0 for i in l))
# 6

Einige weitere Beispiele sind unten aufgeführt.

Beispiel für die Ermittlung der Anzahl der ungeraden Elemente einer Liste von Zahlen.

print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]

print(sum(i % 2 == 1 for i in l))
# 6

Beispiel für eine Bedingung für eine Liste von Zeichenketten.

l = ['apple', 'orange', 'banana']

print([s.endswith('e') for s in l])
# [True, True, False]

print(sum(s.endswith('e') for s in l))
# 2

Zähler wird verwendet, um auf der Grundlage der Anzahl der Vorkommen zu zählen. items() ruft ein Tupel von (Element, Anzahl der Vorkommen) ab, und die Anzahl der Vorkommen gibt die Bedingung an.

Es folgt ein Beispiel für die Extraktion von Elementen mit zwei oder mehr Vorkommen und das Zählen der Gesamtzahl der Vorkommen. In diesem Beispiel gibt es vier a's und zwei c's, also insgesamt sechs.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']

print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]

print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6

Es folgt ein Beispiel für die Extraktion der Typen von Elementen mit zwei oder mehr Vorkommen und das Zählen der Anzahl der Vorkommen. In diesem Beispiel gibt es zwei Typen, a und c.

print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']

print([i[1] >= 2 for i in c.items()])
# [True, False, True]

print(sum(i[1] >= 2 for i in c.items()))
# 2

Zählt die Anzahl der Vorkommen eines Wortes in einer Zeichenkette.

Ein konkretes Beispiel: Zählen wir die Anzahl der Vorkommen eines Wortes in einer Zeichenkette.

Ersetzen Sie zunächst mit der Methode replace() überflüssige Kommas und Punkte durch eine leere Zeichenkette und löschen Sie sie anschließend. Anschließend erstellen Sie mit der Methode split() eine durch Leerzeichen getrennte Liste.

s = 'government of the people, by the people, for the people.'

s_remove = s.replace(',', '').replace('.', '')

print(s_remove)
# government of the people by the people for the people

word_list = s_remove.split()

print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']

Wenn Sie eine Liste erstellen können, können Sie die Anzahl der Vorkommen jedes Wortes, die Art der vorkommenden Wörter und die Funktion most_common() von collections.Counter verwenden, um das am häufigsten vorkommende Wort zu ermitteln.

print(word_list.count('people'))
# 3

print(len(set(word_list)))
# 6

c = collections.Counter(word_list)

print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})

print(c.most_common()[0][0])
# the

Der oben beschriebene Prozess ist sehr einfach, daher ist es besser, Bibliotheken wie NLTK für komplexere natürliche Sprachverarbeitung zu verwenden.

• Natural Language Toolkit — NLTK 3.6.5 documentation

Im Falle von japanischem Text kann split() auch nicht verwendet werden, um den Text aufzuteilen, da es keine klare Worttrennung gibt. Sie können zum Beispiel die Janome-Bibliothek verwenden, um dies zu erreichen.

Zählt die Anzahl der Vorkommen eines Zeichens in einer Zeichenkette.

Da Strings auch ein Sequenztyp sind, können sie mit der Methode count() verwendet oder als Argument an den Konstruktor von collections.Counter() übergeben werden.

s = 'supercalifragilisticexpialidocious'

print(s.count('p'))
# 2

c = collections.Counter(s)

print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})

Beispiel für die Suche nach den 5 am häufigsten vorkommenden Zeichen.

print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]

values, counts = zip(*c.most_common(5))

print(values)
# ('i', 's', 'c', 'a', 'l')