Wie kann ich das Vorkommen eines Listenelements zählen?
Wie kann ich bei einer bestimmten Position in Python in einer Liste zählen?
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.
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})
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]
Eine andere Möglichkeit, die Anzahl der Vorkommen jedes Elements in einem Wörterbuch abzurufen:
dict((i, a.count(i)) for i in a)
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
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.
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])
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.
Alle Elemente zählen
numpy.bincount(a)
ist was du willst.
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,
)
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]]
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
# 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)]
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.
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.
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
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]]
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}
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}
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
sum([1 for elem in <yourlist> if elem==<your_value>])
Dies gibt die Anzahl der Vorkommen von your_value zurück
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)
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])
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)