## The Question :

*427 people think this question is useful*

I need a function which takes in a `list`

and outputs `True`

if all elements in the input list evaluate as equal to each other using the standard equality operator and `False`

otherwise.

I feel it would be best to iterate through the list comparing adjacent elements and then `AND`

all the resulting Boolean values. But I’m not sure what’s the most Pythonic way to do that.

*The Question Comments :*

## The Answer 1

*462 people think this answer is useful*

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 == rest for rest 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):

## The Answer 2

*317 people think this answer is useful*

A solution faster than using set() that works on sequences (not iterables) is to simply count the first element. This assumes the list is non-empty (but that’s trivial to check, and decide yourself what the outcome should be on an empty list)

x.count(x[0]) == len(x)

some simple benchmarks:

>>> timeit.timeit('len(set(s1))<=1', 's1=[1]*5000', number=10000)
1.4383411407470703
>>> timeit.timeit('len(set(s1))<=1', 's1=[1]*4999+[2]', number=10000)
1.4765670299530029
>>> timeit.timeit('s1.count(s1[0])==len(s1)', 's1=[1]*5000', number=10000)
0.26274609565734863
>>> timeit.timeit('s1.count(s1[0])==len(s1)', 's1=[1]*4999+[2]', number=10000)
0.25654196739196777

## The Answer 3

*179 people think this answer is useful*

The simplest and most elegant way is as follows:

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

(Yes, this even works with the empty list! This is because this is one of the few cases where python has lazy semantics.)

Regarding performance, this will fail at the earliest possible time, so it is asymptotically optimal.

## The Answer 4

*48 people think this answer is useful*

A set comparison work:

len(set(the_list)) == 1

Using `set`

removes all duplicate elements.

## The Answer 5

*31 people think this answer is useful*

You can convert the list to a set. A set cannot have duplicates. So if all the elements in the original list are identical, the set will have just one element.

if len(set(input_list)) == 1:
# input_list has all identical elements.

## The Answer 6

*23 people think this answer is useful*

For what it’s worth, this came up on the python-ideas mailing list recently. It turns out that there is an itertools recipe for doing this already:^{1}

def all_equal(iterable):
"Returns True if all the elements are equal to each other"
g = groupby(iterable)
return next(g, True) and not next(g, False)

Supposedly it performs very nicely and has a few nice properties.

- Short-circuits: It will stop consuming items from the iterable as soon as it finds the first non-equal item.
- Doesn’t require items to be hashable.
- It is lazy and only requires O(1) additional memory to do the check.

^{1In other words, I can’t take the credit for coming up with the solution — nor can I take credit for even finding it.}

## The Answer 7

*11 people think this answer is useful*

This is another option, faster than `len(set(x))==1`

for long lists (uses short circuit)

def constantList(x):
return x and [x[0]]*len(x) == x

## The Answer 8

*10 people think this answer is useful*

This is a simple way of doing it:

result = mylist and all(mylist[0] == elem for elem in mylist)

This is slightly more complicated, it incurs function call overhead, but the semantics are more clearly spelled out:

def all_identical(seq):
if not seq:
# empty list is False.
return False
first = seq[0]
return all(first == elem for elem in seq)

## The Answer 9

*5 people think this answer is useful*

Check if all elements equal to the first.

`np.allclose(array, array[0])`

## The Answer 10

*3 people think this answer is useful*

Doubt this is the “most Pythonic”, but something like:

>>> falseList = [1,2,3,4]
>>> trueList = [1, 1, 1]
>>>
>>> def testList(list):
... for item in list[1:]:
... if item != list[0]:
... return False
... return True
...
>>> testList(falseList)
False
>>> testList(trueList)
True

would do the trick.

## The Answer 11

*3 people think this answer is useful*

I’d do:

not any((x[i] != x[i+1] for i in range(0, len(x)-1)))

as `any`

stops searching the iterable as soon as it finds a `True`

condition.

## The Answer 12

*3 people think this answer is useful*

Regarding using `reduce()`

with `lambda`

. Here is a working code that I personally think is way nicer than some of the other answers.

reduce(lambda x, y: (x[1]==y, y), [2, 2, 2], (True, 2))

Returns a tuple where the first value is the boolean if all items are same or not.

## The Answer 13

*2 people think this answer is useful*

>>> a = [1, 2, 3, 4, 5, 6]
>>> z = [(a[x], a[x+1]) for x in range(0, len(a)-1)]
>>> z
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
# Replacing it with the test
>>> z = [(a[x] == a[x+1]) for x in range(0, len(a)-1)]
>>> z
[False, False, False, False, False]
>>> if False in z : Print "All elements are not equal"

## The Answer 14

*2 people think this answer is useful*

def allTheSame(i):
j = itertools.groupby(i)
for k in j: break
for k in j: return False
return True

Works in Python 2.4, which doesn’t have “all”.

## The Answer 15

*2 people think this answer is useful*

If you’re interested in something a little more readable (but of course not as efficient,) you could try:

def compare_lists(list1, list2):
if len(list1) != len(list2): # Weed out unequal length lists.
return False
for item in list1:
if item not in list2:
return False
return True
a_list_1 = ['apple', 'orange', 'grape', 'pear']
a_list_2 = ['pear', 'orange', 'grape', 'apple']
b_list_1 = ['apple', 'orange', 'grape', 'pear']
b_list_2 = ['apple', 'orange', 'banana', 'pear']
c_list_1 = ['apple', 'orange', 'grape']
c_list_2 = ['grape', 'orange']
print compare_lists(a_list_1, a_list_2) # Returns True
print compare_lists(b_list_1, b_list_2) # Returns False
print compare_lists(c_list_1, c_list_2) # Returns False

## The Answer 16

*2 people think this answer is useful*

Can use map and lambda

lst = [1,1,1,1,1,1,1,1,1]
print all(map(lambda x: x == lst[0], lst[1:]))

## The Answer 17

*2 people think this answer is useful*

Or use `diff`

method of numpy:

import numpy as np
def allthesame(l):
return np.all(np.diff(l)==0)

And to call:

print(allthesame([1,1,1]))

Output:

True

## The Answer 18

*1 people think this answer is useful*

You can do:

reduce(and_, (x==yourList[0] for x in yourList), True)

It is fairly annoying that python makes you import the operators like `operator.and_`

. As of python3, you will need to also import `functools.reduce`

.

(You should not use this method because it will not break if it finds non-equal values, but will continue examining the entire list. It is just included here as an answer for completeness.)

## The Answer 19

*1 people think this answer is useful*

lambda lst: reduce(lambda a,b:(b,b==a[0] and a[1]), lst, (lst[0], True))[1]

The next one will short short circuit:

all(itertools.imap(lambda i:yourlist[i]==yourlist[i+1], xrange(len(yourlist)-1)))

## The Answer 20

*1 people think this answer is useful*

Or use diff method of numpy:

import numpy as np
def allthesame(l):
return np.unique(l).shape[0]<=1

And to call:

print(allthesame([1,1,1]))

Output:

True

## The Answer 21

*1 people think this answer is useful*

There is also a pure Python recursive option:

def checkEqual(lst):
if len(lst)==2 :
return lst[0]==lst[1]
else:
return lst[0]==lst[1] and checkEqual(lst[1:])

However for some reason it is in some cases two orders of magnitude slower than other options. Coming from C language mentality, I expected this to be faster, but it is not!

The other disadvantage is that there is recursion limit in Python which needs to be adjusted in this case. For example using this.

## The Answer 22

*1 people think this answer is useful*

## The simple solution is to apply set on list

### if all elements are identical len will be 1 else greater than 1

lst = [1,1,1,1,1,1,1,1,1]
len_lst = len(list(set(lst)))
print(len_lst)
1
lst = [1,2,1,1,1,1,1,1,1]
len_lst = len(list(set(lst)))
print(len_lst)
2

## The Answer 23

*0 people think this answer is useful*

You can use `.nunique()`

to find number of unique items in a list.

def identical_elements(list):
series = pd.Series(list)
if series.nunique() == 1: identical = True
else: identical = False
return identical
identical_elements(['a', 'a'])
Out[427]: True
identical_elements(['a', 'b'])
Out[428]: False