Hoe kan ik de gebeurtenissen van een lijstitem tellen?

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 countMETHODE:

>>> [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 countin een lus vereist een aparte pass over de lijst voor elke countCall, 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 Counterals 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 Lte 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 CounterKLASSE uit de collectionsBibliotheek

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 Counteris voor tallying-lijsten. Ik heb beide methoden geprobeerd met een paar waarden van nen het lijkt erop dat Countersneller 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 xin 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.countmethode

>>> 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 bincountals 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 pandaskunt gebruiken, dan is value_countser 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 averderop in de lijst aanwezig zijn. Dit gebeurt omdat de invoerlijst Lniet 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 countOfmethode 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)

Other episodes