If you have ever written a loop just to count how many times something appears in a list, Python Counter is about to change how you write that code forever. Python Counter is a specialized dictionary subclass from the built-in collections module that makes counting elements in any iterable incredibly simple and expressive. Instead of manually building a tally dictionary, you hand your data to Python Counter and it handles everything for you. This guide covers everything from creating your first counter to combining multiple counters and solving practical problems.
Python Counter is a class inside the collections module that counts hashable objects. Think of it as a dictionary where keys are elements and values are their counts. What makes it special is that it comes with built-in methods specifically designed for frequency analysis, and it never raises a KeyError when you access a missing key — it simply returns zero.
Before Python Counter existed, developers would write code like this to count things:
from collections import Counter
fruits = ["apple", "banana", "apple", "cherry", "banana", "apple"]
# The old manual way
counts = {}
for fruit in fruits:
if fruit in counts:
counts[fruit] += 1
else:
counts[fruit] = 0
print(counts)
That works, but it is verbose and error-prone. Python Counter replaces all of that with a single line. It is one of those tools that once you start using it, you wonder how you got along without it.
The Counter class is flexible — you can create one from a list, a string, a tuple, a dictionary, or even keyword arguments. Each approach suits a different situation.
From a list:
from collections import Counter
scores = [90, 85, 90, 72, 85, 90, 60, 72]
score_counter = Counter(scores)
print(score_counter)
Counter({90: 3, 85: 2, 72: 2, 60: 1})
The output shows each unique score alongside how many times it appeared. Python Counter automatically sorts by count in descending order when printed.
From a string:
from collections import Counter
sentence = "mississippi"
letter_counter = Counter(sentence)
print(letter_counter)
Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})
Counting characters is one of the most common uses of Python Counter, especially in coding interviews and text processing tasks.
From a dictionary:
from collections import Counter
inventory = {"apples": 5, "bananas": 3, "oranges": 8}
stock_counter = Counter(inventory)
print(stock_counter)
Counter({'oranges': 8, 'apples': 5, 'bananas': 3})
From keyword arguments:
from collections import Counter
votes = Counter(alice=142, bob=97, carol=211)
print(votes)
Counter({'carol': 211, 'alice': 142, 'bob': 97})
Since Python Counter is a subclass of dict, you access counts just like dictionary values. The big difference is what happens when you ask for a key that does not exist.
from collections import Counter
colors = ["red", "blue", "red", "green", "blue", "red"]
color_count = Counter(colors)
print(color_count["red"]) # key exists
print(color_count["purple"]) # key does not exist
3
0
A regular dictionary would throw a KeyError on that second line. Python Counter quietly returns zero, which makes it safe to use in conditions and arithmetic without defensive checks.
The most_common method is one of the most frequently used features of Python Counter. It returns a list of the top N elements and their counts, ordered from most common to least common. This is essential for frequency analysis tasks like finding top words in a document or most popular products in sales data.
from collections import Counter
words = ["the", "sky", "is", "blue", "the", "sky", "is", "the", "wide"]
word_freq = Counter(words)
# Top 2 most common words
print(word_freq.most_common(2))
# All words ranked by frequency
print(word_freq.most_common())
[('the', 3), ('sky', 2)]
[('the', 3), ('sky', 2), ('is', 2), ('blue', 1), ('wide', 1)]
Calling most_common without an argument returns all elements ranked from most to least frequent. Passing a number limits it to the top N results.
You do not have to build your entire counter at once. The update method lets you add more counts to an existing counter, which is useful when you are processing data in chunks or streaming it from a file.
from collections import Counter
daily_sales = Counter({"pizza": 12, "pasta": 7, "salad": 4})
# New batch of sales comes in
new_sales = ["pizza", "pizza", "salad", "pasta", "pizza"]
daily_sales.update(new_sales)
print(daily_sales)
Counter({'pizza': 15, 'pasta': 8, 'salad': 5})
The existing counts were incremented by the new ones. Notice how pizza went from 12 to 15 after adding the three new pizza sales. You can also pass another Counter, a dictionary, or keyword arguments to update.
This is where Python Counter really shines beyond a regular dictionary. You can use addition, subtraction, intersection, and union operators directly on counters, which makes combining frequency data from different sources very clean.
Adding two counters:
from collections import Counter
morning_traffic = Counter({"cars": 150, "bikes": 40, "trucks": 20})
evening_traffic = Counter({"cars": 200, "bikes": 65, "motorcycles": 30})
total_traffic = morning_traffic + evening_traffic
print(total_traffic)
Counter({'cars': 350, 'bikes': 105, 'motorcycles': 30, 'trucks': 20})
Addition merges both counters and sums up counts for shared keys.
Subtracting counters:
from collections import Counter
total_stock = Counter({"shirts": 100, "pants": 80, "hats": 50})
sold_items = Counter({"shirts": 30, "pants": 50, "hats": 10})
remaining = total_stock - sold_items
print(remaining)
Counter({'shirts': 70, 'pants': 30, 'hats': 40})
Subtraction removes counts, and any result that drops to zero or below is automatically excluded from the output.
Intersection (minimum counts) and Union (maximum counts):
from collections import Counter
store_a = Counter({"coffee": 5, "tea": 8, "juice": 3})
store_b = Counter({"coffee": 7, "tea": 4, "water": 10})
# Minimum of each shared key
overlap = store_a & store_b
print("Intersection:", overlap)
# Maximum of each key across both
combined = store_a | store_b
print("Union:", combined)
Intersection: Counter({'tea': 4, 'coffee': 5})
Union: Counter({'water': 10, 'tea': 8, 'coffee': 7, 'juice': 3})
Because Python Counter inherits from dict, you can iterate over it just like a regular dictionary. You can also convert it back to a plain list, a sorted list, or use elements() to get back a full iterable.
Using elements() to expand counts:
The elements method returns an iterator that repeats each element as many times as its count. This is useful when you need to reconstruct the original flat list from your counter.
from collections import Counter
letter_count = Counter({"a": 3, "b": 2, "c": 1})
expanded = list(letter_count.elements())
print(expanded)
['a', 'a', 'a', 'b', 'b', 'c']
Converting to a sorted list of tuples:
from collections import Counter
grades = Counter(["A", "B", "A", "C", "B", "A", "D", "B"])
sorted_grades = sorted(grades.items(), key=lambda x: x[0])
print(sorted_grades)
[('A', 3), ('B', 3), ('C', 1), ('D', 1)]
The subtract method works differently from the minus operator. It subtracts counts but allows results to go negative, which is useful when you need to track deficits or differences without filtering out zero or negative values.
from collections import Counter
budget = Counter({"design": 5000, "development": 12000, "marketing": 3000})
spent = Counter({"design": 6200, "development": 9000, "marketing": 3500})
budget.subtract(spent)
print(budget)
Counter({'development': 3000, 'design': -1200, 'marketing': -500})
Here you can immediately see that development is under budget by 3000, while design and marketing are over budget. The minus operator would have dropped the negative values entirely.
This example brings together everything covered in this guide. It reads a passage of text, uses Python Counter to count word frequencies, filters out common stop words, finds the top keywords, and combines results from two separate text sources.
from collections import Counter
import string
def clean_words(text):
translator = str.maketrans("", "", string.punctuation)
return text.lower().translate(translator).split()
stop_words = {"the", "a", "an", "and", "is", "in", "it", "of", "to", "was", "that", "for", "on", "are", "with"}
passage_one = """
Python is a powerful programming language that is widely used in web development,
data science, artificial intelligence, and automation. Python makes it easy to write
clean and readable code. The Python community is large and welcoming to beginners.
"""
passage_two = """
Data science relies heavily on Python for data analysis, visualization, and building
machine learning models. Python libraries like pandas and numpy make data manipulation
straightforward. Many companies use Python to automate repetitive tasks and build pipelines.
"""
words_one = [w for w in clean_words(passage_one) if w not in stop_words]
words_two = [w for w in clean_words(passage_two) if w not in stop_words]
counter_one = Counter(words_one)
counter_two = Counter(words_two)
combined = counter_one + counter_two
print("=== Top 10 Keywords Across Both Passages ===")
for word, count in combined.most_common(10):
print(f" {word}: {count}")
print("\n=== Words Only in Passage One ===")
only_one = counter_one - counter_two
for word, count in only_one.most_common(5):
print(f" {word}: {count}")
print("\n=== Words Only in Passage Two ===")
only_two = counter_two - counter_one
for word, count in only_two.most_common(5):
print(f" {word}: {count}")
print("\n=== Total Unique Words Tracked ===")
print(f" {len(combined)}")
=== Top 10 Keywords Across Both Passages ===
python: 6
data: 5
science: 2
use: 2
make: 2
programming: 1
language: 1
widely: 1
used: 1
web: 1
=== Words Only in Passage One ===
python: 3
powerful: 1
programming: 1
language: 1
widely: 1
=== Words Only in Passage Two ===
data: 4
analysis: 1
visualization: 1
building: 1
machine: 1
=== Total Unique Words Tracked ===
32