Skip to content

Easy Counter in Python

Python’s Counter: The Pythonic Way to Count Objects

Counting several repeated objects at once is a common problem in programming. Python offers a bunch of tools and techniques you can use to approach this problem. However, Python’s Counter from collections provides a clean, efficient, and Pythonic solution.

This dictionary subclass provides efficient counting capabilities out of the box. Understanding Counter and how to use it efficiently is a convenient skill to have as a Python developer.

In this tutorial, you’ll learn how to:

  • Count several repeated objects at once
  • Create counters with Python’s Counter
  • Retrieve the most common objects in a counter
  • Update object counts
  • Use Counter to facilitate further computations

You’ll also learn about the basics of using Counter as a multiset, which is an additional feature of this class in Python.

Counting Objects in Python

Sometimes you need to count the objects in a given data source to know how often they occur. In other words, you need to determine their frequency. For example, you might want to know how often a specific item appears in a list or sequence of values. When your list is short, counting the items can be straightforward and quick. However, when you have a long list, counting things can be more challenging.

To count objects, you typically use a counter, which is an integer variable with an initial value of zero. Then you increment the counter to reflect the number of times a given object appears in the input data source.

When you’re counting the occurrences of a single object, you can use a single counter. However, when you need to count several different objects, you have to create as many counters as unique objects you have.

To count several different objects at once, you can use a Python dictionary. The dictionary keys will store the objects you want to count. The dictionary values will hold the number of repetitions of a given object, or the object’s count.

For example, to count the objects in a sequence using a dictionary, you can loop over the sequence, check if the current object isn’t in the dictionary to initialize the counter (key-value pair), and then increment its count accordingly:

sequence = [1, 2, 3, 1, 4, 2, 1]
counter = {}
for element in sequence:
if element not in counter:
counter[element] = 0
counter[element] += 1
print(counter) # Output: {1: 3, 2: 2, 3: 1, 4: 1}

Python’s Counter class simplifies this process and provides a more convenient and efficient way to count objects.

Getting Started With Python’s Counter

Python’s Counter is a built-in class in the collections module. To start using it, you need to import the collections module:

from collections import Counter

Constructing Counters

There are several ways to construct a Counter object. You can pass an iterable as an argument, such as a list, tuple, or string. The Counter will then count the occurrences of each element in the iterable:

sequence = [1, 2, 3, 1, 4, 2, 1]
counter = Counter(sequence)
print(counter) # Output: Counter({1: 3, 2: 2, 3: 1, 4: 1})

You can also create an empty Counter and update it later:

counter = Counter()
counter.update([1, 2, 3, 1, 4, 2, 1])
print(counter) # Output: Counter({1: 3, 2: 2, 3: 1, 4: 1})

Additionally, you can pass keyword arguments to the Counter constructor. The keys will be the objects you want to count, and the values will be the counts:

counter = Counter(apples=4, bananas=2, oranges=1)
print(counter) # Output: Counter({'apples': 4, 'bananas': 2, 'oranges': 1})

Updating Object Counts

You can update the counts of a Counter by using the update() method. It accepts an iterable as an argument and increments the counts of the elements in the iterable:

counter = Counter()
counter.update([1, 2, 3])
counter.update([1, 2, 1, 4])
print(counter) # Output: Counter({1: 3, 2: 2, 3: 1, 4: 1})

Accessing the Counter’s Content

To access the content of a Counter, you can use the same syntax as accessing elements from a dictionary. You can retrieve the count of a specific object by using its key:

counter = Counter([1, 2, 3, 1, 4, 2, 1])
print(counter[1]) # Output: 3

If the key doesn’t exist in the Counter, it will return a count of 0:

print(counter[5]) # Output: 0

You can also access the keys and the counts separately using the keys() and values() methods:

counter = Counter([1, 2, 3, 1, 4, 2, 1])
print(counter.keys()) # Output: dict_keys([1, 2, 3, 4])
print(counter.values()) # Output: dict_values([3, 2, 1, 1])

Finding Most Common Objects

To find the most common objects in a Counter, you can use the most_common() method. It returns a list of tuples, where each tuple contains an object and its count, in descending order based on the count:

counter = Counter([1, 2, 3, 1, 4, 2, 1])
print(counter.most_common()) # Output: [(1, 3), (2, 2), (3, 1), (4, 1)]

You can also specify the number of most common objects you want to retrieve:

print(counter.most_common(2)) # Output: [(1, 3), (2, 2)]

Putting Counter Into Action

Now that you have a good understanding of how to use Counter, let’s explore some practical examples of how you can apply it to real-world problems.

Counting Letters in a Text File

Counting the occurrences of letters in a text file is a common task in text analysis and natural language processing. With Counter, you can make this process much simpler and more efficient. Let’s see an example:

from collections import Counter
with open('text.txt', 'r') as file:
text =
letter_counter = Counter(text.lower())
print(letter_counter) # Output: Counter({'e': 45, 't': 34, 'a': 33, ...})

Plotting Categorical Data With ASCII Bar Charts

Counter can be useful for visualizing categorical data with ASCII bar charts. This is especially helpful when dealing with small datasets or when you need a quick visualization. Let’s say you have a list of programming languages and their counts:

from collections import Counter
languages = ['Python', 'JavaScript', 'Java', 'C++', 'C#', 'Ruby', 'Python', 'JavaScript', 'Java', 'Ruby']
language_counter = Counter(languages)
for language, count in language_counter.most_common():
print(f'{language}: {"#" * count}')


Python: ####
JavaScript: ##
Java: ##
Ruby: ##
C++: #
C#: #

Plotting Categorical Data With Matplotlib

If you have larger datasets or need more customizable visualizations, you can use Counter in conjunction with the matplotlib library. The Counter provides the data, and matplotlib provides the visualization capabilities:

import matplotlib.pyplot as plt
from collections import Counter
languages = ['Python', 'JavaScript', 'Java', 'C++', 'C#', 'Ruby', 'Python', 'JavaScript', 'Java', 'Ruby']
language_counter = Counter(languages)
languages, counts = zip(*language_counter.most_common()), counts)
plt.title('Most Popular Programming Languages')


Bar chart of programming languages

Finding the Mode of a Sample

The mode is the value that appears most frequently in a dataset. With Counter, finding the mode becomes a straightforward task:

from collections import Counter
dataset = [1, 5, 2, 3, 5, 3, 2, 1, 2, 3, 4, 2, 3]
dataset_counter = Counter(dataset)
mode = dataset_counter.most_common(1)[0][0]
print(mode) # Output: 3

Counting Files by Type

Counting files by type is useful when analyzing directories or managing file systems. With the glob module and Counter, you can count the occurrences of different file extensions:

from collections import Counter
import glob
files = glob.glob('path*')
extensions = [file.split('.')[-1] for file in files]
extension_counter = Counter(extensions)
print(extension_counter) # Output: Counter({'txt': 12, 'py': 6, 'csv': 4, ...})

Using Counter Instances as Multisets

A multiset, also known as a bag, is a collection of elements where each element can occur multiple times. Counter can be used as a multiset because it allows you to store multiple instances of the same object. By doing so, Counter provides useful methods for set operations.

Restoring Elements From a Counter

If you need to restore the original elements from a Counter, you can use the elements() method. It returns an iterator that generates all the elements in the Counter, taking into account their counts:

from collections import Counter
counter = Counter(a=3, b=2, c=1)
print(list(counter.elements())) # Output: ['a', 'a', 'a', 'b', 'b', 'c']

Subtracting the Elements’ Multiplicity

You can subtract the multiplicity of elements in one Counter from another Counter using the - operator:

from collections import Counter
counter1 = Counter(a=3, b=2, c=1)
counter2 = Counter(a=1, b=2, c=3)
difference = counter1 - counter2
print(difference) # Output: Counter({'a': 2})

Doing Arithmetic With Elements’ Multiplicity

You can perform arithmetic operations with the multiplicity of elements in a Counter. For example, you can add or subtract two Counter instances together:

from collections import Counter
counter1 = Counter(a=3, b=2, c=1)
counter2 = Counter(a=1, b=2, c=3)
sum_counter = counter1 + counter2
print(sum_counter) # Output: Counter({'a': 4, 'b': 4, 'c': 4})

You can also perform multiplication or division operations by using a scalar value:

from collections import Counter
counter = Counter(a=3, b=2, c=1)
double_counter = counter * 2
half_counter = counter 2
print(double_counter) # Output: Counter({'a': 6, 'b': 4, 'c': 2})
print(half_counter) # Output: Counter({'a': 1.5, 'b': 1.0, 'c': 0.5})


Python’s Counter provides a convenient, efficient, and Pythonic way to count objects in a variety of programming scenarios. Whether you’re counting letters in a text file, analyzing categorical data, finding the mode in a sample, or working with multisets, Counter can simplify your code and make it more readable.

As a Python developer, understanding the Counter class and knowing how to use it effectively can greatly enhance your productivity and problem-solving skills. So next time you encounter a counting problem, remember to reach for Python’s Counter for a clean and efficient solution!