To find the most common, I know I can use something like this:

most_common = collections.Counter(list).most_common(to_find)

However, I can’t seem to find anything comparable, for finding the least common element.

Could I please get recommendations on how to do.

most_common without any argument returns all the entries, ordered from most common to least.

So to find the least common, just start looking at it from the other end.

What about

least_common = collections.Counter(array).most_common()[-1]

Borrowing the source of collections.Counter.most_common and inverting as appropriate:

from operator import itemgetter
import heapq
import collections
def least_common_values(array, to_find=None):
    counter = collections.Counter(array)
    if to_find is None:
        return sorted(counter.items(), key=itemgetter(1), reverse=False)
    return heapq.nsmallest(to_find, counter.items(), key=itemgetter(1))

>>> data = [1,1,2,2,2,2,3,3,3,3,3,3,3,4,4,4,4,4,4,4]
>>> least_common_values(data, 2)
[(1, 2), (2, 4)]
>>> least_common_values([1,1,2,3,3])
[(2, 1), (1, 2), (3, 2)]

Sorry, late to this thread… Found the docs quite helpful:

Do a search for ‘least’, and you’ll come across this table which helps on getting more than the last (-1) element in the list:

c.most_common()[:-n-1:-1]       # n least common elements

Here’s an example:

n = 50

word_freq = Count(words)
least_common = word_freq.most_common()[:-n-1:-1]

def least_common_values(array, to_find):
    >>> least_common_values([1,1,2,2,2,2,3,3,3,3,3,3,3,4,4,4,4,4,4,4], 2)
    [(1, 2), (2, 4)]
    counts = collections.Counter(array)
    return list(reversed(counts.most_common()[-to_find:]))

To just get the least common element and nothing more:

>>> from collections import Counter
>>> ls = [1, 2, 3, 3, 2, 5, 1, 6, 6]
>>> Counter(ls).most_common()[-1][0]

I guess you need this:

least_common = collections.Counter(array).most_common()[:-to_find-1:-1]

The easiest way to implement the search of the minimum in an Iterable is as follows:


That returns a 2-dimensional tuple containing the element at first position and the count of occurrences at second position.

I would suggest as follows,

least_common = collections.Counter(array).most_common()[len(to_find)-10:len(to_find)]

You can use a key function:

>>> data=[1,1,2,2,2,2,3,3,3,3,3,3,4,4,4,4,4,4,4,4]
>>> min(data,key=lambda x: data.count(x))
>>> max(data,key=lambda x: data.count(x))

Based on this answer for most common elements:

Here is a one liner for obtaining the least common element in a list:

def least_common(lst):
    return min(set(lst), key=lst.count)