Frage Wie zähle ich das Vorkommen eines Listenelements?


Wie kann ich ein Element in einer Liste in Python zählen?


1084
2018-04-08 13:30


Ursprung


Antworten:


Wenn Sie nur einen Gegenstand zählen möchten, verwenden Sie die count Methode:

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

Nicht Verwenden Sie diese Option, wenn Sie mehrere Elemente zählen möchten. Berufung count in einer Schleife erfordert einen separaten Durchlauf über die Liste für jeden count Anruf, der für Leistung katastrophal sein kann. Wenn Sie alle Artikel oder auch nur mehrere Artikel zählen möchten, verwenden Sie Counter, wie in den anderen Antworten erklärt.


1425
2018-04-08 13:31



Wenn Sie Python 2.7 oder 3 verwenden und Anzahl der Vorkommen für jedes Element möchten:

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

1359
2018-04-29 07:44



Zählen der Vorkommen eines Elements in einer Liste

Zum Zählen der Vorkommen von nur einem Listenelement, das Sie verwenden können count()

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

Zählen der Vorkommen von alle Elemente in einer Liste werden auch als "Tallying" einer Liste oder Erstellen eines Tally-Zählers bezeichnet.

Zählen aller Gegenstände mit count ()

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

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

(oder ähnlich 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 Artikel mit Counter ()

Alternativ gibt es das schnellere Counter Klasse von 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 Counter?

Ich habe überprüft, wie viel schneller Counter dient zum Auszählen von Listen. Ich habe beide Methoden mit ein paar Werten ausprobiert n und es scheint so Counter ist um einen konstanten Faktor von etwa 2 schneller.

Hier ist das Skript, das ich benutzt habe:

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]

184
2018-05-28 10:58



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

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

56
2017-10-20 22:38



list.count(x) gibt die Anzahl der Wiederholungen zurück x erscheint in einer Liste

sehen: http://docs.python.org/tutorial/datastructures.html#more-on-lists


40
2018-04-08 13:34



Wenn du möchtest Zählen Sie alle Werte auf einmal Sie können es sehr schnell mit numpy Arrays und tun bincount wie folgt

import numpy as np
a = np.array([1, 2, 3, 4, 1, 4, 1])
np.bincount(a)

was gibt

>>> array([0, 3, 1, 1, 2])

27
2017-11-19 10:53



Wie kann ich ein Element 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 das list.count Methode

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

Dies funktioniert für jede Liste. Tupel haben auch 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 gibt es Sammlungen. Counter. Sie können jedes iterable in einen Counter und nicht nur in eine Liste ablegen, und der Counter behält eine Datenstruktur der Counts der Elemente bei.

Verwendung:

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

Die Zähler basieren auf Python-Wörterbüchern, ihre Schlüssel sind die Elemente, also müssen die Schlüssel hashbar sein. Sie sind im Grunde wie Sets, die redundante Elemente in ihnen zulassen.

Weitere Verwendung von collections.Counter

Sie können Iterables von Ihrem Zähler hinzufügen oder abziehen:

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

Und mit dem Zähler können Sie auch mehrere Operationen ausfü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 benutzen?

Pandas ist eine gemeinsame Bibliothek, aber es ist nicht in der Standardbibliothek. Das Hinzufügen als Abhängigkeit ist nicht trivial.

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

Wenn dein Projekt noch keine Pandas benötigt, wäre es dumm, es nur für diese Funktionalität zu benötigen.


23
2018-04-13 12:50



Ich habe alle vorgeschlagenen Lösungen (und ein paar neue) mit verglichen perfot (ein kleines Projekt von mir).

Zählen ein Artikel

Für groß genug Arrays, stellt sich heraus, dass

numpy.sum(numpy.array(a) == 1) 

ist etwas schneller als die anderen Lösungen.

enter image description here

Zählen alle Artikel

Wie zuvor festgestellt,

numpy.bincount(a)

ist was du willst.

enter image description here


Code zum Reproduzieren der Plots:

from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot


def counter(a):
    return Counter(a)


def count(a):
    return dict((i, a.count(i)) for i in set(a))


def bincount(a):
    return numpy.bincount(a)


def pandas_value_counts(a):
    return pandas.Series(a).value_counts()


def occur_dict(a):
    d = {}
    for i in a:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
    return d


def count_unsorted_list_items(items):
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


def operator_countof(a):
    return dict((i, operator.countOf(a, i)) for i in set(a))


perfplot.show(
    setup=lambda n: list(numpy.random.randint(0, 100, n)),
    n_range=[2**k for k in range(20)],
    kernels=[
        counter, count, bincount, pandas_value_counts, occur_dict,
        count_unsorted_list_items, operator_countof
        ],
    equality_check=None,
    logx=True,
    logy=True,
    )

2.

from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot


def counter(a):
    return Counter(a)


def count(a):
    return dict((i, a.count(i)) for i in set(a))


def bincount(a):
    return numpy.bincount(a)


def pandas_value_counts(a):
    return pandas.Series(a).value_counts()


def occur_dict(a):
    d = {}
    for i in a:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
    return d


def count_unsorted_list_items(items):
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


def operator_countof(a):
    return dict((i, operator.countOf(a, i)) for i in set(a))


perfplot.show(
    setup=lambda n: list(numpy.random.randint(0, 100, n)),
    n_range=[2**k for k in range(20)],
    kernels=[
        counter, count, bincount, pandas_value_counts, occur_dict,
        count_unsorted_list_items, operator_countof
        ],
    equality_check=None,
    logx=True,
    logy=True,
    )

20
2017-09-13 10:32



Wenn Sie es benutzen können pandas, dann value_counts ist da für die Rettung.

>>> import pandas as pd
>>> a = [1, 2, 3, 4, 1, 4, 1]
>>> pd.Series(a).value_counts()
1    3
4    2
3    1
2    1
dtype: int64

Das Ergebnis wird automatisch basierend auf der Häufigkeit sortiert.

Wenn das Ergebnis in einer Liste enthalten sein soll, gehen Sie wie folgt vor

>>> pd.Series(a).value_counts().reset_index().values.tolist()
[[1, 3], [4, 2], [3, 1], [2, 1]]

14
2018-01-17 07:56