#### [SOLVED] How can I count the occurrences of a list item?

By weakish

Given an item, how can I count its occurrences in a list in Python?

## Below are the three solutions:

Fastest is using a for loop and storing it in a 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))
``````

Result

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

## Count of all elements with `itertools.groupby()`

Antoher possiblity for getting the count of all elements in the list could be by means of `itertools.groupby()`.

With "duplicate" counts

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

Returns

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

Notice how it combined the first three `a`'s as the first group, while other groups of `a` are present further down the list. This happens because the input list `L` was not sorted. This can be a benefit sometimes if the groups should in fact be separate.

With unique counts

If unique group counts are desired, just sort the input list:

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

Returns

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

#### @AndyK 2018-10-21 21:59:07

It was suggested to use numpy's bincount, however it works only for 1d arrays with non-negative integers. Also, the resulting array might be confusing (it contains the occurrences of the integers from min to max of the original list, and sets to 0 the missing integers).

A better way to do it with numpy is to use the unique function with the attribute `return_counts` set to True. It returns a tuple with an array of the unique values and an array of the occurrences of each unique value.

``````# 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]
``````

and then we can pair them as

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

It also works with other data types and "2d lists", e.g.

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

# Given an item, how can I count its occurrences in a list in Python?

Here's an example list:

``````>>> l = list('aaaaabbbbcccdde')
>>> l
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'e']
``````

## `list.count`

There's the `list.count` method

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

This works fine for any list. Tuples have this method as well:

``````>>> t = tuple('aabbbffffff')
>>> t
('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f')
>>> t.count('f')
6
``````

## `collections.Counter`

And then there's collections.Counter. You can dump any iterable into a Counter, not just a list, and the Counter will retain a data structure of the counts of the elements.

Usage:

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

Counters are based on Python dictionaries, their keys are the elements, so the keys need to be hashable. They are basically like sets that allow redundant elements into them.

### Further usage of `collections.Counter`

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

And you can do multi-set operations with the counter as well:

``````>>> 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})
``````

## Why not pandas?

Why not use pandas?

Pandas is a common library, but it's not in the standard library. Adding it as a requirement is non-trivial.

There are builtin solutions for this use-case in the list object itself as well as in the standard library.

If your project does not already require pandas, it would be foolish to make it a requirement just for this functionality.

#### @jpp 2019-01-03 01:36:32

While "why not Pandas" is appropriate, it should probably be accompanied by "when to use NumPy", i.e. for large numeric arrays. The deciding factor isn't just project limitations, there are memory efficiencies with NumPy which become apparent with big data.

#### @ravi tanwar 2018-07-07 08:29:21

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

#### @Alex Riabov 2018-07-07 08:53:11

While this code may answer the question, providing additional context regarding why and/or how this code answers the question improves its long-term value.

#### @DataBender 2018-06-29 14:05:39

if you want a number of occurrences for the particular 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])
``````

#### @blue-sky 2018-03-01 10:38:08

May not be the most efficient, requires an extra pass to remove duplicates.

Functional implementation :

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

returns :

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

or return as `dict` :

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

returns :

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

#### @Thirupathi Thangavel 2018-01-17 07:56:22

If you can use `pandas`, then `value_counts` is there for rescue.

``````>>> 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
``````

It automatically sorts the result based on frequency as well.

If you want the result to be in a list of list, do as below

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

#### @Ćukasz 2010-04-08 13:31:52

If you only want one item's count, use the `count` method:

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

Don't use this if you want to count multiple items. Calling `count` in a loop requires a separate pass over the list for every `count` call, which can be catastrophic for performance. If you want to count all items, or even just multiple items, use `Counter`, as explained in the other answers.

#### @cpp-coder 2017-09-09 19:15:33

`mylist = [1,7,7,7,3,9,9,9,7,9,10,0] print sorted(set([i for i in mylist if mylist.count(i)>2]))`

#### @Nico Schlömer 2017-09-13 10:32:48

I've compared all suggested solutions (and a few new ones) with perfplot (a small project of mine).

### Counting one item

For large enough arrays, it turns out that

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

is slightly faster than the other solutions.

### Counting all items

``````numpy.bincount(a)
``````

is what you want.

Code to reproduce the plots:

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

#### @Mukarram Pasha 2018-03-03 09:20:46

numpy.bincount() will work only for lists with int items.

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

This will return the amount of occurences of your_value

#### @user2314737 2014-05-28 10:58:37

Counting the occurrences of one item in a list

For counting the occurrences of just one list item you can use `count()`

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

Counting the occurrences of all items in a list is also known as "tallying" a list, or creating a tally counter.

Counting all items with count()

To count the occurrences of items in `l` one can simply use a list comprehension and the `count()` method

``````[[x,l.count(x)] for x in set(l)]
``````

(or similarly with a dictionary `dict((x,l.count(x)) for x in set(l))`)

Example:

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

Counting all items with Counter()

Alternatively, there's the faster `Counter` class from the `collections` library

``````Counter(l)
``````

Example:

``````>>> l = ["a","b","b"]
>>> from collections import Counter
>>> Counter(l)
Counter({'b': 2, 'a': 1})
``````

How much faster is Counter?

I checked how much faster `Counter` is for tallying lists. I tried both methods out with a few values of `n` and it appears that `Counter` is faster by a constant factor of approximately 2.

Here is the script I used:

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

And the output:

``````Counter():  [0.46062711701961234, 0.4022796869976446, 0.3974247490405105]
count():    [7.779430688009597, 7.962715800967999, 8.420845870045014]
``````

#### @fhucho 2015-11-11 22:34:43

`Counter` is way faster for bigger lists. The list comprehension method is O(n^2), `Counter` should be O(n).

#### @Martijn Pieters 2017-05-23 10:13:51

Counter is not faster by a factor of 2, Counter is faster by a factor of n (O(n^2) vs O(n)).

#### @Jacob Schneider 2018-04-23 04:02:46

`count()` also works on strings, just saying

#### @Bram Vanroy 2018-06-19 21:27:58

I have found that when using this a lot (talking about millions of strings) that it is very slow because of its calls to `isinstance`. So if you are certain about the data that you're working with, it might be better to write a custom function without type and instance checking.

#### @Aakash Goel 2017-04-28 10:36:56

``````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
``````

Output list:

``````[['Mexico', 2], ['France', 1], ['Uruguay', 2]]
``````

#### @Chris_Rands 2017-05-23 09:42:52

Code only answers and not encouraged, and moreover the use of `Counter()` has been suggested many times in previous answers

#### @Shoresh 2016-10-17 17:15:38

Why not using Pandas?

``````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
``````

Output:

``````a    3
d    2
b    1
c    1
dtype: int64
``````

If you are looking for a count of a particular element, say a, try:

``````my_count['a']
``````

Output:

``````3
``````

#### @vishes_shell 2016-09-18 20:08:11

You can also use `countOf` method of a built-in module `operator`.

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

#### @Chris_Rands 2017-05-23 09:41:21

How is `countOf` is implemented? How does it compare to the more obvious `list.count` (which benefits from C implementation)? Are there any advantages?

#### @Silfverstrom 2010-04-08 13:34:15

`list.count(x)` returns the number of times `x` appears in a list

#### @tj80 2011-10-20 22:38:08

Another way to get the number of occurrences of each item, in a dictionary:

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

#### @Nicolas78 2012-10-10 00:30:31

this looks like one of the constructs I often come up with in the heat of the battle, but it will run through a len(a) times which means quadratic runtime complexity (as each run depends on len(a) again).

#### @hugo24 2013-08-23 09:20:20

would dict((i,a.count(i)) for i in set(a)) be more correct and faster?

#### @Clément 2013-10-07 09:46:31

@hugo24: A bit, but it won't be asymptotically faster in the worst case; it will take `n * (number of different items)` operations, not counting the time it takes to build the set. Using `collections.Counter` is really much better.

#### @Wes Turner 2011-08-14 08:47:39

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

#### @plaes 2011-08-14 08:58:15

This is a bit "enterprisey"...

#### @eyquem 2011-08-14 15:40:12

@Wes Turner Happily, you use Python. Imagine the same in Java or C....

#### @Wes Turner 2011-08-21 12:32:36

@plaes : How so? If by 'enterprisey', you mean "documented" in preparation for Py3k annotations, I agree.

This is a great example, as I am developing mainly in 2.7, but have to have migration paths to 2.4.

#### @flonk 2013-11-19 10:53:07

If you want to count all values at once you can do it very fast using numpy arrays and `bincount` as follows

``````import numpy as np
a = np.array([1, 2, 3, 4, 1, 4, 1])
np.bincount(a)
``````

which gives

``````>>> array([0, 3, 1, 1, 2])
``````

#### @D Blanc 2011-11-07 19:18:54

I had this problem today and rolled my own solution before I thought to check SO. This:

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

is really, really slow for large lists. My solution

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

is actually a bit faster than the Counter solution, at least for Python 2.7.

#### @chaosflaws 2015-06-08 21:29:35

Counter sorts the entries while yours does not, hence the speed difference (True at the time of writing, not sure if it was when you wrote the answer. Still, it might be relevant for someone scrolling down.)

#### @Martijn Pieters 2017-04-22 18:05:30

Counter in Python 2 was a little on the slow side, yes. It uses C-optimised code to do the counting in Python 3 however, and now beats your loop with ease.

#### @eyquem 2011-08-14 15:51:59

To count the number of diverse elements having a common 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')
``````

gives

`3` , not 6

#### @user52028778 2011-04-29 07:44:22

If you are using Python 2.7 or 3 and you want number of occurrences for each element:

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

#### @Bram Vanroy 2018-06-19 21:26:32

I have found that when using this a lot (talking about millions of strings) that it is very slow because of its calls to `isinstance`. So if you are certain about the data that you're working with, it might be better to write a custom function without type and instance checking.

#### @user2357112 2018-11-14 04:08:00

@BramVanroy: What `isinstance` calls? Even with millions of strings, calling `Counter` only involves one `isinstance` call, to check whether its argument is a mapping. You most likely misjudged what's eating all your time.

#### @Bram Vanroy 2018-11-14 08:45:57

You misinterpreted what I meant: Counter checks the types of your data before it creates the Counter. This takes relatively much time and if you know the type of your data in advance. If you look at Counter's update method, you'll see it has to go through three if-statements before doing something. If you call update frequently, this adds up quickly. When you have control over your data and you know that the input will be indeed an iterable, then you can skip the first two checks. As I said, I only noticed this when working with millions of updates so it's an edge case.

#### @user2357112 2018-11-14 18:20:32

@BramVanroy: If you're performing millions of updates rather than just counting millions of strings, that's a different story. The optimization effort in `Counter` has gone into counting large iterables, rather than counting many iterables. Counting a million-string iterable will go faster with `Counter` than with a manual implementation. If you want to call `update` with many iterables, you may be able to speed things up by joining them into one iterable with `itertools.chain`.

### [SOLVED] How do I list all files of a directory?

• 2010-07-08 19:31:22
• duhhunjonn
• 3046080 View
• 3339 Score
• Tags:   python directory

### [SOLVED] Finding the index of an item given a list containing it in Python

• 2008-10-07 01:39:38
• Eugene M
• 3150767 View
• 2595 Score
• Tags:   python list

### [SOLVED] How do I check if a list is empty?

• 2008-09-10 06:20:11
• Ray Vega
• 2111183 View
• 3152 Score
• Tags:   python list