it-swarm.com.de

Wie kann ich das Vorkommen eines Listenelements zählen?

Wie kann ich bei einer bestimmten Position in Python in einer Liste zählen?

1231
weakish

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

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

Nicht verwenden , wenn Sie mehrere Elemente zählen möchten. Das Aufrufen von count in einer Schleife erfordert einen separaten Durchlauf über die Liste für jeden count-Aufruf, was für die Leistung katastrophal sein kann. Wenn Sie alle Elemente oder auch nur mehrere Elemente zählen möchten, verwenden Sie Counter, wie in den anderen Antworten erläutert.

1571
Łukasz

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

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

Zählen der Vorkommen eines Elements in einer Liste

Zum Zählen der Vorkommen nur eines Listenelements können Sie count() verwenden.

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

Das Zählen der Vorkommen von all -Elementen in einer Liste wird auch als "Zählen" einer Liste oder Erstellen eines Zählerzählers bezeichnet.

Zählen aller Elemente mit count ()

Um die Vorkommen von Elementen in l 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}

Zählen aller Artikel mit Counter ()

Alternativ 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 Counter?

Ich habe überprüft, wie viel schneller Counter für das Auswerten von Listen ist. Ich habe beide Methoden mit einigen Werten von n ausprobiert und es scheint, dass Counter um 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]
215
user2314737

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

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

list.count(x) gibt die Anzahl zurück, zu der x in einer Liste angezeigt wird

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

42
Silfverstrom

Wie kann ich bei einer bestimmten Position in Python in einer Liste 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

Es gibt die list.count-Methode

>>> 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.Counter. Sie können jedes beliebige Element in einen Counter speichern, nicht nur in eine Liste, und der Counter 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 hashierbar sein. Sie sind im Grunde wie Sets, die redundante Elemente in sie hineinlassen.

Weiterverwendung von collections.Counter

Sie können iterierbare Werte von Ihrem Counter hinzufügen oder subtrahieren:

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

Sie können auch mit dem Zähler 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 verwenden? 

Pandas ist eine gemeinsame Bibliothek, aber nicht in der Standardbibliothek. Das Hinzufügen als Anforderung ist nicht trivial.

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

Wenn für Ihr Projekt nicht bereits Pandas erforderlich sind, wäre es töricht, es nur für diese Funktionalität als Anforderung festzulegen.

30
Aaron Hall

Wenn Sie alle Werte gleichzeitig zählen möchten , können Sie dies mit Numpy-Arrays und bincount wie folgt schnell 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])
29
flonk

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

Eins zählen

Bei ausreichend großen Arrays stellt sich das heraus

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

ist etwas schneller als die anderen Lösungen.

 enter image description here

Alle Elemente zählen

Wie zuvor festgestellt ,

numpy.bincount(a)

ist was du willst.

 enter image description here


Code zum Reproduzieren der Darstellungen:

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,
    )
27
Nico Schlömer

Wenn Sie pandas verwenden können, steht value_counts zur Rettung zur Verfügung. 

>>> 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 angezeigt wird, führen Sie die folgenden Schritte aus

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

Warum nicht Pandas verwenden?

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 einem bestimmten Element suchen, sagen Sie a .

my_count['a']

Ausgabe:

3
14
Shoresh
# 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)]
11
Wes Turner

Ich hatte dieses Problem heute und rollte meine eigene Lösung, bevor ich an SO dachte. Diese:

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

ist wirklich 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 eigentlich etwas schneller als die Counter-Lösung, zumindest für Python 2.7.

11
D Blanc

Anzahl aller Elemente mit itertools.groupby()

Eine weitere Möglichkeit, die Anzahl aller Elemente in der Liste zu ermitteln, könnte mit itertools.groupby() erfolgen.

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 a als erste Gruppe kombiniert wurden, während andere Gruppen von a weiter unten in der Liste vorhanden sind. Dies geschieht, weil die Eingabeliste L nicht sortiert wurde. Dies kann manchmal von Vorteil sein, wenn die Gruppen tatsächlich getrennt sein sollten.

Mit eindeutigen 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: Um eindeutige Zählungen zu erstellen, bieten viele der anderen Antworten im Vergleich zur groupby -Lösung einfacheren und besser lesbaren Code. Es wird hier jedoch gezeigt, um eine Parallele zu dem Beispiel für die doppelte Zählung zu zeichnen.

9

Um die Anzahl der verschiedenen Elemente mit einem gemeinsamen Typ zu zählen:

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

6
eyquem
from collections import Counter
country=['Uruguay', 'Mexico', 'Uruguay', 'France', 'Mexico']
count_country = Counter(country)
output_list= [] 

for i in count_country:
    output_list.append([i,count_country[i]])
print output_list

Ausgabeliste:

[['Mexico', 2], ['France', 1], ['Uruguay', 2]]
4
Aakash Goel

Sie können auch die countOf -Methode eines eingebauten Moduls operator verwenden.

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

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

Eine bessere Möglichkeit, dies mit Numpy zu tun, ist die Verwendung der Funktion unique , wobei das Attribut return_counts auf True gesetzt ist. Es wird ein Tupel mit einem Array der eindeutigen Werte und einem Array der Vorkommen jedes eindeutigen Werts zurückgegeben.

# 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 paaren

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}
3
AndyK

Ist möglicherweise nicht der effizienteste, erfordert einen zusätzlichen Durchlauf zum Entfernen von Duplikaten. 

Funktionale Umsetzung: 

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 als dict zurücksenden:

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

kehrt zurück : 

{'b': 3, 'c': 1, 'a': 2}
2
blue-sky

Im Folgenden sind die drei Lösungen:

Am schnellsten benutzt man eine for-Schleife und speichert sie in einem Dict.

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
2
Akash Swain
sum([1 for elem in <yourlist> if elem==<your_value>])

Dies gibt die Anzahl der Vorkommen von your_value zurück

1

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)
1
Harsh Gundecha

wenn Sie eine Anzahl von Vorkommen für das bestimmte 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])
0
DataBender
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)
0
ravi tanwar