Python – How to Check if All Elements in a List Are the Same

listpythonpython-2.7

If i have this list;

mylist = ['n', 'n', '4', '3', 'w']

How do I get it to read the list, and tell me whether or not they are all the same?

I am aware that it is easy to tell they are not all the same in this example. I have much larger lists I would like it to read for me.

Would I go about this using:

min(...)

If so, how would I input each list item?

Best Answer

You can use set like this

len(set(mylist)) == 1

Explanation

sets store only unique items in them. So, we try and convert the list to a set. After the conversion, if the set has more than one element in it, it means that not all the elements of the list are the same.

Note: If the list has unhashable items (like lists, custom classes etc), the set method cannot be used. But we can use the first method suggested by @falsetru,

all(x == mylist[0] for x in mylist)

Advantages:

It even works with unhashable types
It doesn't create another temporary object in memory.
It short circuits after the first failure. If the first and the second elements don't match, it returns False immediately, whereas in the set approach all the elements have to be compared. So, if the list is huge, you should prefer the all approach.
It works even when the list is actually empty. If there are no elements in the iterable, all will return True. But the empty list will create an empty set for which the length will be 0.

Related Solutions

Python – Check if All Elements in a List Are Identical

Use itertools.groupby (see the itertools recipes):

from itertools import groupby

def all_equal(iterable):
    g = groupby(iterable)
    return next(g, True) and not next(g, False)

or without groupby:

def all_equal(iterator):
    iterator = iter(iterator)
    try:
        first = next(iterator)
    except StopIteration:
        return True
    return all(first == x for x in iterator)

There are a number of alternative one-liners you might consider:

Converting the input to a set and checking that it only has one or zero (in case the input is empty) items
```
def all_equal2(iterator):
    return len(set(iterator)) <= 1
```
Comparing against the input list without the first item
```
def all_equal3(lst):
    return lst[:-1] == lst[1:]
```

Counting how many times the first item appears in the list

def all_equal_ivo(lst):
    return not lst or lst.count(lst[0]) == len(lst)

Comparing against a list of the first element repeated

def all_equal_6502(lst):
    return not lst or [lst[0]]*len(lst) == lst

But they have some downsides, namely:

all_equal and all_equal2 can use any iterators, but the others must take a sequence input, typically concrete containers like a list or tuple.
all_equal and all_equal3 stop as soon as a difference is found (what is called "short circuit"), whereas all the alternatives require iterating over the entire list, even if you can tell that the answer is False just by looking at the first two elements.
In all_equal2 the content must be hashable. A list of lists will raise a TypeError for example.
all_equal2 (in the worst case) and all_equal_6502 create a copy of the list, meaning you need to use double the memory.

On Python 3.9, using perfplot, we get these timings (lower Runtime [s] is better):

Best Answer

Related Solutions

Python – Check if All Elements in a List Are Identical

Related Question