Een item gegeven, hoe kan ik zijn gebeurtenissen in een lijst in Python tellen?
1, Autoriteit 100%
Als u alleen de teletalingen van één item wilt, gebruikt u de count
METHODE:
>>> [1, 2, 3, 4, 1, 4, 1].count(1)
3
BELANGRIJKE OPMERKING met betrekking tot tell-prestaties
Gebruik dit niet als u meerdere items wilt tellen
Bellen count
in een lus vereist een aparte pass over de lijst voor elke count
Call, die catastrofaal kan zijn voor prestaties.
Als u alle items of zelfs alleen meerdere items wilt tellen, gebruikt u Counter
, zoals uitgelegd in de andere antwoorden.
2, Autoriteit 95%
Gebruik Counter
als U gebruikt Python 2.7 of 3.x en u wilt het aantal voorvallen voor elk element:
>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> Counter(z)
Counter({'blue': 3, 'red': 2, 'yellow': 1})
3, Autoriteit 14%
Tellen van de gebeurtenissen van één item in een lijst
Voor het tellen van de gebeurtenissen van slechts één lijstitem kunt u count()
gebruiken
>>> l = ["a","b","b"]
>>> l.count("a")
1
>>> l.count("b")
2
Tellen van de gebeurtenissen van Alle -items in een lijst staat ook bekend als “Tallying” een lijst of het maken van een tally-teller.
Tellen van alle items met telling ()
Om de gebeurtenissen van items in L
te tellen, kunt u eenvoudig een lijstbegrip en de count()
METHODE
gebruiken
[[x,l.count(x)] for x in set(l)]
(of op dezelfde manier met een woordenboek dict((x,l.count(x)) for x in set(l))
)
Voorbeeld:
>>> 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}
Tellen van alle items met teller ()
U bent alternatief, er is de snellere Counter
KLASSE uit de collections
Bibliotheek
Counter(l)
Voorbeeld:
>>> l = ["a","b","b"]
>>> from collections import Counter
>>> Counter(l)
Counter({'b': 2, 'a': 1})
Hoeveel sneller is teller?
Ik heb gecontroleerd hoeveel snellere Counter
is voor tallying-lijsten. Ik heb beide methoden geprobeerd met een paar waarden van n
en het lijkt erop dat Counter
sneller is door een constante factor van ongeveer 2.
Hier is het script dat ik heb gebruikt:
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)
En de uitvoer:
Counter(): [0.46062711701961234, 0.4022796869976446, 0.3974247490405105]
count(): [7.779430688009597, 7.962715800967999, 8.420845870045014]
Antwoord 4, autoriteit 4%
Een andere manier om het aantal keren dat elk item voorkomt in een woordenboek te krijgen:
dict((i, a.count(i)) for i in a)
Antwoord 5, autoriteit 2%
list.count(x)
geeft het aantal keren terug dat x
in een lijst voorkomt
zie:
http://docs.python.org/tutorial/datastructures.html#more-on-lists
Antwoord 6, autoriteit 2%
Gegeven een item, hoe kan ik de voorkomens tellen in een lijst in Python?
Hier is een voorbeeldlijst:
>>> l = list('aaaaabbbbcccdde')
>>> l
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'e']
list.count
Er is de list.count
methode
>>> l.count('b')
4
Dit werkt prima voor elke lijst. Tupels hebben deze methode ook:
>>> t = tuple('aabbbffffff')
>>> t
('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f')
>>> t.count('f')
6
collections.Counter
En dan zijn er nog collecties. Teller. Je kunt elke iteratie in een teller dumpen, niet alleen een lijst, en de teller behoudt een gegevensstructuur van de tellingen van de elementen.
Gebruik:
>>> from collections import Counter
>>> c = Counter(l)
>>> c['b']
4
Tellers zijn gebaseerd op Python-woordenboeken, hun sleutels zijn de elementen, dus de sleutels moeten hashbaar zijn. Het zijn eigenlijk sets die overbodige elementen toelaten.
Verder gebruik van collections.Counter
Je kunt met iterables optellen of aftrekken van je teller:
>>> c.update(list('bbb'))
>>> c['b']
7
>>> c.subtract(list('bbb'))
>>> c['b']
4
En u kunt ook bewerkingen met meerdere sets uitvoeren met de teller:
>>> 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})
Waarom geen panda’s?
Een ander antwoord suggereert:
Waarom geen panda’s gebruiken?
Pandas is een algemene bibliotheek, maar het zit niet in de standaardbibliotheek. Het toevoegen als vereiste is niet triviaal.
Er zijn ingebouwde oplossingen voor dit gebruik-case in het lijst Object zelf, evenals in de standaardbibliotheek.
Als uw project niet al PANDA’s vereist, zou het dwaas zijn om het alleen voor deze functionaliteit een eis te maken.
Antwoord 7, autoriteit 2%
Als u alle waarden tegelijk wilt tellen, kunt u dit heel snel doen met behulp van numpy arrays en bincount
als volgt
import numpy as np
a = np.array([1, 2, 3, 4, 1, 4, 1])
np.bincount(a)
wat geeft
>>> array([0, 3, 1, 1, 2])
Antwoord 8
Als je pandas
kunt gebruiken, dan is value_counts
er voor redding.
>>> 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
Het sorteert het resultaat ook automatisch op frequentie.
Als je wilt dat het resultaat in een lijst met lijsten staat, doe dan zoals hieronder
>>> pd.Series(a).value_counts().reset_index().values.tolist()
[[1, 3], [4, 2], [3, 1], [2, 1]]
Antwoord 9
Waarom geen Panda’s gebruiken?
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
Uitvoer:
a 3
d 2
b 1
c 1
dtype: int64
Als u op zoek bent naar een telling van een bepaald element, zeg a, probeer dan:
my_count['a']
Uitvoer:
3
10
Ik had dit probleem vandaag en rolde mijn eigen oplossing voordat ik dacht om het te controleren. Dit:
dict((i,a.count(i)) for i in a)
is echt, echt traag voor grote lijsten. Mijn oplossing
def occurDict(items):
d = {}
for i in items:
if i in d:
d[i] = d[i]+1
else:
d[i] = 1
return d
is eigenlijk een beetje sneller dan de telleroplossing, tenminste voor Python 2.7.
11
# 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)]
Antwoord 12
Hieronder staan de drie oplossingen:
Snelste gebruikt een for-lus en slaat deze op in een 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))
Resultaat
#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
Antwoord 13
Tellen van alle elementen met itertools.groupby()
Een andere mogelijkheid om de telling van alle elementen in de lijst te krijgen, is door middel van itertools.groupby()
.
Met “dubbele” tellingen
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)
Retourneren
[('a', 3), ('t', 1), ('q', 1), ('a', 1), ('d', 1), ('a', 1), ('d', 1), ('c', 1)]
Zie hoe het de eerste drie a
‘s als de eerste groep combineerde, terwijl andere groepen van a
verderop in de lijst aanwezig zijn. Dit gebeurt omdat de invoerlijst L
niet is gesorteerd. Dit kan soms een voordeel zijn als de groepen eigenlijk gescheiden zouden moeten zijn.
Met unieke tellingen
Als unieke groepsaantallen gewenst zijn, sorteert u gewoon de invoerlijst:
counts = [(i, len(list(c))) for i,c in groupby(sorted(L))]
print(counts)
Retourneren
[('a', 5), ('c', 1), ('d', 2), ('q', 1), ('t', 1)]
Opmerking:voor het maken van unieke tellingen bieden veel van de andere antwoorden eenvoudigere en beter leesbare code in vergelijking met de groupby
-oplossing. Maar het wordt hier getoond om een parallel te trekken met het voorbeeld van dubbele telling.
Antwoord 14
Hoewel het een heel oude vraag is, heb ik er een gemaakt omdat ik geen oneliner heb gevonden.
# 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: 1, 2: 2, 3: 3, 4: 1}
15
Om het aantal diverse elementen te tellen met een gemeenschappelijk type:
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')
geeft
3
, niet 6
16
U kunt ook countOf
methode van een ingebouwde module operator
.
>>> import operator
>>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1)
3
Antwoord 17
Misschien niet de meest efficiënte, vereist een extra pas om duplicaten te verwijderen.
Functionele implementatie :
arr = np.array(['a','a','b','b','b','c'])
print(set(map(lambda x : (x , list(arr).count(x)) , arr)))
retouren:
{('c', 1), ('b', 3), ('a', 2)}
of retourneer als dict
:
print(dict(map(lambda x : (x , list(arr).count(x)) , arr)))
retouren:
{'b': 3, 'c': 1, 'a': 2}
Antwoord 18
Ik zou filter()
gebruiken, neem het voorbeeld van Lukasz:
>>> lst = [1, 2, 3, 4, 1, 4, 1]
>>> len(filter(lambda x: x==1, lst))
3
Antwoord 19
Gegeven een lijst X
import numpy as np
X = [1, -1, 1, -1, 1]
Het woordenboek dat i: frequency(i) toont voor elementen van deze lijst is:
{i:X.count(i) for i in np.unique(X)}
Uitvoer:
{ -1: 2, 1: 3}
Antwoord 20
gebruik %timeit om te zien welke bewerking efficiënter is. np.array-telbewerkingen zouden sneller moeten zijn.
from collections import Counter
mylist = [1,7,7,7,3,9,9,9,7,9,10,0]
types_counts=Counter(mylist)
print(types_counts)
Antwoord 21
sum([1 for elem in <yourlist> if elem==<your_value>])
Dit retourneert het aantal keren dat uw_waarde voorkomt
Antwoord 22
als u een aantal keren wilt voorkomen voor het specifieke element:
>>> 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])
Antwoord 23
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))
dit zal recursief tellen of zoeken naar het item in de lijst, zelfs als het in een lijst met lijsten staat
Antwoord 24
Als alternatief kunt u de teller ook zelf implementeren. Dit is hoe ik het doe:
item_list = ['me', 'me', 'you', 'you', 'you', 'they']
occ_dict = {}
for item in item_list:
if item not in occ_dict:
occ_dict[item] = 1
else:
occ_dict[item] +=1
print(occ_dict)
Uitvoer: {'me': 2, 'you': 3, 'they': 1}
Antwoord 25
test = [409.1, 479.0, 340.0, 282.4, 406.0, 300.0, 374.0, 253.3, 195.1, 269.0, 329.3, 250.7, 250.7, 345.3, 379.3, 275.0, 215.2, 300.0]
for i in test:
print('{} numbers {}'.format(i, test.count(i)))
Antwoord 26
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)