Skip to main content

How to Find Most and Least Common Elements in Python Lists and Dictionaries

This guide explains how to find the most and least common elements in Python lists and the most frequent values in dictionaries. We'll primarily use the powerful collections.Counter class, which is designed for this purpose, and briefly cover alternative approaches using max()/min() with a custom key function.

Finding the Most Common Element in a List with Counter​

The collections.Counter class is a specialized dictionary subclass for counting hashable objects. It's the most efficient and Pythonic way to find the most common element(s) in a list.

from collections import Counter

a_list = ['one', 'one', 'one', 'two', 'two', 'three']
counter = Counter(a_list)
print(counter) # Output: Counter({'one': 3, 'two': 2, 'three': 1})

most_common = counter.most_common(1)  # Get the single most common
print(most_common)  # Output: [('one', 3)] # Returns a list of tuples

# To get JUST the element (not the count):
most_common_element = counter.most_common(1)[0][0]
print(most_common_element)  # Output: one
  • Counter(a_list): Creates a Counter object that counts the occurrences of each item in a_list.
  • counter.most_common(1): Returns a list of the n most common elements and their counts, from most to least common. Since we used 1, it returns a list containing a single tuple: [('one', 3)].
  • counter.most_common(1)[0][0]: This extracts the most common element itself. counter.most_common(1)[0] gets the first tuple ('one', 3), and [0] on that gets the element 'one'.

Finding the N Most Common Elements​

To get the n most common elements (and their counts), use most_common(n):

most_common_2 = counter.most_common(2)
print(most_common_2)  # Output: [('one', 3), ('two', 2)]

Finding the Least Common Element in a List with Counter​

To find the least common element(s), use slicing with a negative index on the result of most_common():

from collections import Counter

a_list = ['c', 'a', 'a', 'b', 'b', 'z', 'z', 'z']
# Get the least common element:

least_common = Counter(a_list).most_common()[-1] # Gets the last element from a list
print(least_common)  # Output: ('c', 1)
print(least_common[0]) # Get only the element Output: c

# Get the N least common elements
least_common_2_elements = Counter(a_list).most_common()[-2:]
print(least_common_2_elements) # Output: [('b', 2), ('c', 1)]
  • most_common()[-1]: Accesses the last element of the list returned by most_common(). Since most_common() returns elements ordered from most to least frequent, the last element is the least frequent.
  • most_common()[-2:]: Gets the last two elements (using slicing).

Finding the Most Frequent Value in a Dictionary with Counter​

To find the most frequent value (not key) in a dictionary:

from collections import Counter

my_dict = {
    'a': 1,
    'b': 1,
    'c': 1,
    'd': 2,
    'e': 2,
    'f': 3
}

counter = Counter(my_dict.values()) # Count the *values*
most_common_value = counter.most_common(1)[0]
print(most_common_value)    # Output: (1, 3)
print(most_common_value[0]) # Output: 1

most_common_values = counter.most_common(2) # Get two most frequent
print(most_common_values)   # Output: [(1, 3), (2, 2)]
  • We pass my_dict.values() to the counter, to count values, not keys.

Finding the Most Common Element in a List with max() (Alternative)​

While less efficient and readable than Counter, you can also use the max() function with the list.count method as the key:

a_list = ['one', 'one', 'one', 'two', 'two', 'three']

most_common = max(set(a_list), key=a_list.count) # Not as fast as Counter
print(most_common) # Output: one
  • The max() function finds the largest item.
  • The key=a_list.count argument specifies the function to determine the "largeness". In this case, it uses the built-in count method of the list, which will be run for every item in the set.
  • The set() converts the list to a set to avoid counting duplicate items.

Finding the Most Frequent Value in a Dictionary with max() (Alternative)​

Similar to lists, you can use max() with a custom key function for dictionaries:

my_dict = {
    'a': 1,
    'b': 1,
    'c': 1,
    'd': 2,
    'e': 2,
    'f': 3
}
values = list(my_dict.values())
most_common_value = max(set(values), key=values.count) # Inefficient approach.
print(most_common_value) # Output: 1
  • The list(my_dict.values()) extracts a list of the dictionary values.
  • Then, max() is used with the count() function as the key, and the set() of values to find the most common element.

Table of Contents