CODEWITHSUNDEEP
pythonpython-3.xcounter
jimy
jimy

Reputation: 633

How to get the least common element in a list?

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.

Upvotes: 47

Views: 43954

Answers (13)

SultanOrazbayev
SultanOrazbayev

Reputation: 16561

It's unlikely that Counter.least_common will be implemented as a built-in method, see this GH issue.

In the meantime, it's possible to create a custom class that inherits from Counter and adds the relevant method:

from collections import Counter


class LeastCounter(Counter):
    def least_common(self, n: int | None = None) -> list[tuple]:
        """List the n least common elements and their counts from the least common
        to the most common. If n is None, then list all element counts.

        >>> Counter('abracadabra').least_common(3)
        [('d', 1), ('c', 1), ('r', 2)]
        """
        least = list(reversed(self.most_common()))
        if n is None:
            return least
        return least[:n]

This can be used to modify an existing Counter object:

existing_counter = Counter("abracadabra")
new_counter = LeastCounter(existing_counter)
print(new_counter.least_common(3))
# [('d', 1), ('c', 1), ('r', 2)]

Or to create a new object that will behave like a Counter but will also have the least_common method:

new_counter = LeastCounter("abracadabra")
print(new_counter.least_common(3))
# [('d', 1), ('c', 1), ('r', 2)]

Upvotes: 0

Dyutimoy Biswas
Dyutimoy Biswas

Reputation: 1

To find n least common elements, use the code:

collections.Counter(iterable)[-n:]

For the least common element, n = 1.

Upvotes: 0

ruohola
ruohola

Reputation: 24028

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]
5

Upvotes: 7

June
June

Reputation: 730

Sorry, late to this thread... Found the docs quite helpful: https://docs.python.org/3.7/library/collections.html

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]

Upvotes: 10

bmc
bmc

Reputation: 857

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

Counter(your_iterable).most_common()[-1]

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

Upvotes: 3

Matthias Herrmann
Matthias Herrmann

Reputation: 2790

Based on this answer for most common elements: https://stackoverflow.com/a/1518632

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)

Upvotes: 1

John Machin
John Machin

Reputation: 82924

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

Upvotes: 27

Saram Han
Saram Han

Reputation: 11

I would suggest as follows,

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

Upvotes: 1

Andrea Gigli
Andrea Gigli

Reputation: 41

I guess you need this:

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

Upvotes: 3

dawg
dawg

Reputation: 103754

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))
1
>>> max(data,key=lambda x: data.count(x))
4

Upvotes: 1

Glenn Maynard
Glenn Maynard

Reputation: 57474

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:]))

Upvotes: 5

Jim Brissom
Jim Brissom

Reputation: 32919

What about

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

Upvotes: 43

Anon.
Anon.

Reputation: 59973

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.

Upvotes: 46

Related Questions