Wie kann ich bei einem bestimmten Element dessen Vorkommen in einer Liste in Python zählen?

Wenn Sie nur die Anzahl eines Elements möchten, verwenden Sie die folgende countMethode:

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

Verwenden Sie diese Option nicht , wenn Sie mehrere Elemente zählen möchten. Das Anrufen countin einer Schleife erfordert für jeden countAnruf einen separaten Durchlauf über die Liste , was für die Leistung katastrophal sein kann. Wenn Sie alle Elemente oder nur mehrere Elemente zählen möchten, verwenden Sie Counter, wie in den anderen Antworten erläutert.

Verwenden CounterSie diese Option, wenn Sie Python 2.7 oder 3.x verwenden und die Anzahl der Vorkommen für jedes Element angeben möchten:

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

Zählen der Vorkommen eines Elements in einer Liste

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

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

Das Zählen der Vorkommen aller Elemente in einer Liste wird auch als "Zählen" einer Liste oder Erstellen eines Zählzählers bezeichnet.

Zählen aller Elemente mit count ()

Um das Vorkommen von Elementen in leinem zu zählen, können Sie einfach ein Listenverständnis und die count()Methode verwenden

[[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}

Alle Gegenstände mit Counter zählen ()

Alternativ gibt es die schnellere CounterKlasse aus der collectionsBibliothek

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 es Counterist, Listen zu zählen. Ich habe beide Methoden mit ein paar Werten von ausprobiert nund es scheint, dass dies Counterum einen konstanten Faktor von ungefähr 2 schneller ist.

Hier ist das Skript, das ich verwendet 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]

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)

list.count(x)Gibt zurück, wie oft xin einer Liste angezeigt wird

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

Wie kann ich bei einem bestimmten Element dessen Vorkommen 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.countMethode

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

Dies funktioniert gut 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. Sie können jedes iterable Element in einen Zähler ausgeben, nicht nur in eine Liste, und der Zähler behält eine Datenstruktur der Anzahl der Elemente bei.

Verwendungszweck:

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

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

Weitere Verwendung von collections.Counter

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

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

Mit dem Zähler können Sie auch Operationen mit mehreren Sätzen 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 gängige Bibliothek, aber nicht in der Standardbibliothek. Das Hinzufügen als Anforderung ist nicht trivial.

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

Wenn für Ihr Projekt noch keine Pandas erforderlich sind, wäre es dumm, es nur für diese Funktionalität erforderlich zu machen.

Ich habe alle vorgeschlagenen Lösungen (und einige neue) mit perfplot (einem kleinen Projekt von mir) verglichen .

Zählen einen Artikel

Bei ausreichend großen Arrays stellt sich heraus, dass

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

ist etwas schneller als die anderen Lösungen.

Zählen Sie alle Artikel

Wie bereits festgestellt ,

numpy.bincount(a)

ist was du willst.

Code zur Reproduktion der Diagramme:

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,
    )

Wenn Sie alle Werte gleichzeitig zählen möchten, können Sie dies sehr schnell mit numpy-Arrays und bincountwie folgt tun

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])

Wenn Sie verwenden können pandas, value_countsist es zur Rettung da.

>>> 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 auch nach Häufigkeit sortiert.

Wenn Sie möchten, dass das Ergebnis in einer Liste aufgeführt ist, gehen Sie wie folgt vor

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

Warum nicht Pandas benutzen?

import pandas as pd

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

# converting the list to a Series and counting the values
my_count = pd.Series(l).value_counts()
my_count

Ausgabe:

a    3
d    2
b    1
c    1
dtype: int64

Wenn Sie nach einer Zählung eines bestimmten Elements suchen, sagen Sie a , versuchen Sie:

my_count['a']

Ausgabe:

3

Ich hatte heute dieses Problem und habe meine eigene Lösung entwickelt, bevor ich daran dachte, SO zu überprüfen. Diese:

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

ist sehr, sehr langsam für große Listen. Meine Lösung

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

ist tatsächlich ein bisschen schneller als die Counter-Lösung, zumindest für Python 2.7.

# Python >= 2.6 (defaultdict) && < 2.7 (Counter, OrderedDict)
from collections import defaultdict
def count_unsorted_list_items(items):
    """
    :param items: iterable of hashable items to count
    :type items: iterable

    :returns: dict of counts like Py2.7 Counter
    :rtype: dict
    """
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


# Python >= 2.2 (generators)
def count_sorted_list_items(items):
    """
    :param items: sorted iterable of items to count
    :type items: sorted iterable

    :returns: generator of (item, count) tuples
    :rtype: generator
    """
    if not items:
        return
    elif len(items) == 1:
        yield (items[0], 1)
        return
    prev_item = items[0]
    count = 1
    for item in items[1:]:
        if prev_item == item:
            count += 1
        else:
            yield (prev_item, count)
            count = 1
            prev_item = item
    yield (item, count)
    return


import unittest
class TestListCounters(unittest.TestCase):
    def test_count_unsorted_list_items(self):
        D = (
            ([], []),
            ([2], [(2,1)]),
            ([2,2], [(2,2)]),
            ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
            )
        for inp, exp_outp in D:
            counts = count_unsorted_list_items(inp) 
            print inp, exp_outp, counts
            self.assertEqual(counts, dict( exp_outp ))

        inp, exp_outp = UNSORTED_WIN = ([2,2,4,2], [(2,3), (4,1)])
        self.assertEqual(dict( exp_outp ), count_unsorted_list_items(inp) )


    def test_count_sorted_list_items(self):
        D = (
            ([], []),
            ([2], [(2,1)]),
            ([2,2], [(2,2)]),
            ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
            )
        for inp, exp_outp in D:
            counts = list( count_sorted_list_items(inp) )
            print inp, exp_outp, counts
            self.assertEqual(counts, exp_outp)

        inp, exp_outp = UNSORTED_FAIL = ([2,2,4,2], [(2,3), (4,1)])
        self.assertEqual(exp_outp, list( count_sorted_list_items(inp) ))
        # ... [(2,2), (4,1), (2,1)]

Nachfolgend sind die drei Lösungen aufgeführt:

Am schnellsten ist es, eine for-Schleife zu verwenden und in einem Dict zu speichern.

import time
from collections import Counter


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


z = [1,1,1,1,2,2,2,2,3,3,4,5,5,234,23,3,12,3,123,12,31,23,13,2,4,23,42,42,34,234,23,42,34,23,423,42,34,23,423,4,234,23,42,34,23,4,23,423,4,23,4]


#Solution 1 - Faster
st = time.monotonic()
for i in range(1000000):
    b = countElement(z)
et = time.monotonic()
print(b)
print('Simple for loop and storing it in dict - Duration: {}'.format(et - st))

#Solution 2 - Fast
st = time.monotonic()
for i in range(1000000):
    a = Counter(z)
et = time.monotonic()
print (a)
print('Using collections.Counter - Duration: {}'.format(et - st))

#Solution 3 - Slow
st = time.monotonic()
for i in range(1000000):
    g = dict([(i, z.count(i)) for i in set(z)])
et = time.monotonic()
print(g)
print('Using list comprehension - Duration: {}'.format(et - st))

Ergebnis

#Solution 1 - Faster

{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 234: 3, 23: 10, 12: 2, 123: 1, 31: 1, 13: 1, 42: 5, 34: 4, 423: 3}
Simple for loop and storing it in dict - Duration: 12.032000000000153

#Solution 2 - Fast

Counter({23: 10, 4: 6, 2: 5, 42: 5, 1: 4, 3: 4, 34: 4, 234: 3, 423: 3, 5: 2, 12: 2, 123: 1, 31: 1, 13: 1})
Using collections.Counter - Duration: 15.889999999999418

#Solution 3 - Slow

{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 34: 4, 423: 3, 234: 3, 42: 5, 12: 2, 13: 1, 23: 10, 123: 1, 31: 1}
Using list comprehension - Duration: 33.0

Anzahl aller Elemente mit itertools.groupby()

Eine andere Möglichkeit, die Anzahl aller Elemente in der Liste zu ermitteln, könnte mittels sein itertools.groupby().

Mit "Duplikat" zählt

from itertools import groupby

L = ['a', 'a', 'a', 't', 'q', 'a', 'd', 'a', 'd', 'c']  # Input list

counts = [(i, len(list(c))) for i,c in groupby(L)]      # Create value-count pairs as list of tuples 
print(counts)

Kehrt zurück

[('a', 3), ('t', 1), ('q', 1), ('a', 1), ('d', 1), ('a', 1), ('d', 1), ('c', 1)]

Beachten Sie, wie die ersten drei aals erste Gruppe kombiniert wurden , während andere Gruppen aweiter unten in der Liste vorhanden sind. Dies geschieht, weil die Eingabeliste Lnicht sortiert wurde. Dies kann manchmal von Vorteil sein, wenn die Gruppen tatsächlich getrennt sein sollten.

Mit einzigartigen Zählungen

Wenn eindeutige Gruppenzahlen gewünscht werden, sortieren Sie einfach die Eingabeliste:

counts = [(i, len(list(c))) for i,c in groupby(sorted(L))]
print(counts)

Kehrt zurück

[('a', 5), ('c', 1), ('d', 2), ('q', 1), ('t', 1)]

Hinweis: Zum Erstellen eindeutiger Zählungen bieten viele der anderen Antworten im Vergleich zur groupbyLösung einen einfacheren und besser lesbaren Code . Hier wird jedoch gezeigt, dass eine Parallele zum Beispiel für die doppelte Anzahl gezogen wird.

Es wurde vorgeschlagen, den Bincount von numpy zu verwenden , dies funktioniert jedoch nur für 1d-Arrays mit nicht negativen Ganzzahlen . Das resultierende Array kann auch verwirrend sein (es enthält die Vorkommen der Ganzzahlen von min bis max der ursprünglichen Liste und setzt die fehlenden Ganzzahlen auf 0).

Eine bessere Möglichkeit, dies mit numpy zu tun, besteht darin, die eindeutige Funktion mit dem Attribut return_countsTrue zu verwenden. Es gibt ein Tupel mit einem Array der eindeutigen Werte und einem Array der Vorkommen jedes eindeutigen Werts zurück.

# a = [1, 1, 0, 2, 1, 0, 3, 3]
a_uniq, counts = np.unique(a, return_counts=True)  # array([0, 1, 2, 3]), array([2, 3, 1, 2]

und dann können wir sie als koppeln

dict(zip(a_uniq, counts))  # {0: 2, 1: 3, 2: 1, 3: 2}

Es funktioniert auch mit anderen Datentypen und "2d-Listen", z

>>> a = [['a', 'b', 'b', 'b'], ['a', 'c', 'c', 'a']]
>>> dict(zip(*np.unique(a, return_counts=True)))
{'a': 3, 'b': 3, 'c': 2}

So zählen Sie die Anzahl der verschiedenen Elemente mit einem gemeinsamen Typ:

li = ['A0','c5','A8','A2','A5','c2','A3','A9']

print sum(1 for el in li if el[0]=='A' and el[1] in '01234')

gibt

3 nicht 6

Es ist zwar eine sehr alte Frage, aber da ich keinen Einzeiler gefunden habe, habe ich einen gemacht.

# original numbers in list
l = [1, 2, 2, 3, 3, 3, 4]

# empty dictionary to hold pair of number and its count
d = {}

# loop through all elements and store count
[ d.update( {i:d.get(i, 0)+1} ) for i in l ]

print(d)

Sie können auch die countOfMethode eines integrierten Moduls verwenden operator.

>>> import operator
>>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1)
3

Möglicherweise nicht die effizienteste, erfordert einen zusätzlichen Durchgang, um Duplikate zu entfernen.

Funktionale Implementierung:

arr = np.array(['a','a','b','b','b','c'])
print(set(map(lambda x  : (x , list(arr).count(x)) , arr)))

kehrt zurück :

{('c', 1), ('b', 3), ('a', 2)}

oder zurückgeben als dict:

print(dict(map(lambda x  : (x , list(arr).count(x)) , arr)))

kehrt zurück :

{'b': 3, 'c': 1, 'a': 2}

sum([1 for elem in <yourlist> if elem==<your_value>])

Dies gibt die Anzahl der Vorkommen Ihres_Wertes zurück

Ich würde verwenden filter(), nehmen Sie Lukasz 'Beispiel:

>>> lst = [1, 2, 3, 4, 1, 4, 1]
>>> len(filter(lambda x: x==1, lst))
3

Wenn Sie eine Reihe von Vorkommen für das jeweilige Element wünschen:

>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> single_occurrences = Counter(z)
>>> print(single_occurrences.get("blue"))
3
>>> print(single_occurrences.values())
dict_values([3, 2, 1])

def countfrequncyinarray(arr1):
    r=len(arr1)
    return {i:arr1.count(i) for i in range(1,r+1)}
arr1=[4,4,4,4]
a=countfrequncyinarray(arr1)
print(a)

l2=[1,"feto",["feto",1,["feto"]],['feto',[1,2,3,['feto']]]]
count=0
 def Test(l):   
        global count 
        if len(l)==0:
             return count
        count=l.count("feto")
        for i in l:
             if type(i) is list:
                count+=Test(i)
        return count   
    print(Test(l2))

Dadurch wird rekursiv gezählt oder nach dem Element in der Liste gesucht, auch wenn es in der Liste der Listen enthalten ist