Wie zähle ich die Vorkommen eines Listenelements?

Question

Wie zähle ich die Vorkommen eines Elements in einer Liste in Python?

Answer 1

Wenn Sie nur die Zählung eines einzelnen Elements wünschen, verwenden Sie die count Methode:

>>> [1, 2, 3, 4, 1, 4, 1].count(1)
3

---

Wichtig: Dies ist sehr langsam, wenn Sie mitzählen mehrere verschiedene Artikel

Jede count Aufruf geht über die gesamte Liste der n Elemente. Aufruf von count in einer Schleife n mal bedeutet n * n Gesamtprüfungen, was sich katastrophal auf die Leistung auswirken kann.

Wenn Sie mehrere Elemente zählen wollen, verwenden Sie Counter die nur die n Schecks insgesamt.

Answer 2

Verwenden Sie Counter wenn Sie Python 2.7 oder 3.x verwenden und die Anzahl der Vorkommen für jedes Element benötigen:

>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> Counter(z)
Counter({'blue': 3, 'red': 2, 'yellow': 1})

Answer 3

Zählen des Vorkommens eines Elements in einer Liste

Um das Auftreten nur eines Listenelements zu zählen, können Sie Folgendes verwenden count()

>>> l = ["a","b","b"]
>>> l.count("a")
1
>>> l.count("b")
2

Zählen der Vorkommen von todos Die Erfassung von Einträgen in einer Liste wird auch als "Zählen" einer Liste oder als Erstellen eines Zählers bezeichnet.

Zählen aller Elemente mit count()

So zählen Sie das Vorkommen von Elementen in l kann man einfach ein Listenverständnis verwenden und die count() Methode

[[x,l.count(x)] for x in set(l)]

(oder in ähnlicher Weise mit einem Wörterbuch dict((x,l.count(x)) for x in set(l)) )

Beispiel:

>>> l = ["a","b","b"]
>>> [[x,l.count(x)] for x in set(l)]
[['a', 1], ['b', 2]]
>>> dict((x,l.count(x)) for x in set(l))
{'a': 1, 'b': 2}

Zählen aller Elemente mit Counter()

Alternativ dazu gibt es die schnellere Counter Klasse aus der collections Bibliothek

Counter(l)

Beispiel:

>>> l = ["a","b","b"]
>>> from collections import Counter
>>> Counter(l)
Counter({'b': 2, 'a': 1})

Wie viel schneller ist der Zähler?

Ich habe geprüft, wie viel schneller Counter ist für das Abhaken von Listen. Ich habe beide Methoden mit ein paar Werten von n und es scheint, dass Counter ist um einen konstanten Faktor von etwa 2 schneller.

Hier ist das von mir verwendete Skript:

from __future__ import print_function
import timeit

t1=timeit.Timer('Counter(l)', \
                'import random;import string;from collections import Counter;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
                )

t2=timeit.Timer('[[x,l.count(x)] for x in set(l)]',
                'import random;import string;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
                )

print("Counter(): ", t1.repeat(repeat=3,number=10000))
print("count():   ", t2.repeat(repeat=3,number=10000)

Und die Ausgabe:

Counter():  [0.46062711701961234, 0.4022796869976446, 0.3974247490405105]
count():    [7.779430688009597, 7.962715800967999, 8.420845870045014]

Answer 4

Eine andere Möglichkeit, die Anzahl der Vorkommen jedes Elements in einem Wörterbuch zu ermitteln:

dict((i, a.count(i)) for i in a)

Answer 5

Wie kann ich das Vorkommen eines Elements in einer Liste in Python zählen?

Hier ist eine Beispielliste:

>>> l = list('aaaaabbbbcccdde')
>>> l
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'e']

list.count

Da ist die list.count Methode

>>> l.count('b')
4

Dies funktioniert für jede Liste. Auch Tupel haben diese Methode:

>>> t = tuple('aabbbffffff')
>>> t
('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f')
>>> t.count('f')
6

collections.Counter

Und dann ist da noch collections.Counter. Sie können jede beliebige iterable in einen Zähler ausgeben, nicht nur eine Liste, und der Zähler wird eine Datenstruktur der Zählungen der Elemente beibehalten.

Verwendung:

>>> from collections import Counter
>>> c = Counter(l)
>>> c['b']
4

Zähler basieren auf Python-Dictionaries, ihre Schlüssel sind die Elemente, also müssen die Schlüssel hashfähig sein. Sie sind im Grunde wie Mengen, die redundante Elemente in ihnen zulassen.

Weitere Verwendung von collections.Counter

Sie können mit Iterables von Ihrem Zähler addieren oder subtrahieren:

>>> c.update(list('bbb'))
>>> c['b']
7
>>> c.subtract(list('bbb'))
>>> c['b']
4

Außerdem können Sie mit dem Zähler auch Multiset-Operationen durchführen:

>>> c2 = Counter(list('aabbxyz'))
>>> c - c2                   # set difference
Counter({'a': 3, 'c': 3, 'b': 2, 'd': 2, 'e': 1})
>>> c + c2                   # addition of all elements
Counter({'a': 7, 'b': 6, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c | c2                   # set union
Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c & c2                   # set intersection
Counter({'a': 2, 'b': 2})

Warum nicht Pandas?

Eine andere Antwort schlägt vor:

Warum nicht Pandas verwenden?

Pandas ist eine weit verbreitete Bibliothek, aber sie ist nicht in der Standardbibliothek enthalten. Es als Anforderung hinzuzufügen ist nicht trivial.

Für diesen Anwendungsfall gibt es sowohl im Listenobjekt selbst als auch in der Standardbibliothek eingebaute Lösungen.

Wenn Ihr Projekt nicht bereits Pandas benötigt, wäre es töricht, es nur für diese Funktionalität zur Voraussetzung zu machen.