Это еще один вариант, более быстрый, чем len(set(x))==1 для длинных списков (используется короткое замыкание)

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

Сложная сравнительная работа:

len(set(the_list)) == 1

Использование set удаляет все повторяющиеся элементы.

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

Следующее короткое замыкание:

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

Вы можете преобразовать список в набор. У набора не может быть дубликатов. Поэтому, если все элементы в исходном списке идентичны, набор будет иметь только один элемент.

if len(sets.Set(input_list)) == 1
// input_list has all identical elements.

Убедитесь, что все элементы равны первому.

np.allclose(array, array[0])

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

Работает в Python 2.4, который не имеет «все».

Решение быстрее, чем использование set (), которое работает с последовательностями (а не итерами), состоит в простом подсчете первого элемента. Это предполагает, что список не пуст (но это тривиально проверить и решить, какой результат должен быть в пустом списке)

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

несколько простых эталонных тестов:

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

Это простой способ сделать это:

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

Это немного сложнее, оно навлекает служебные вызовы функций, но семантика более четко прописана:

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

Если вам интересно что-то более читаемое (но, конечно, не так эффективно), вы можете попробовать:

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

Преобразуйте список в набор, а затем найдите количество элементов в наборе. Если результат равен 1, он имеет одинаковые элементы, а если нет, то элементы в списке не идентичны.

list1 = [1,1,1]
len(set(list1)) 
>1

list1 = [1,2,3]
len(set(list1)
>3

Измените список на набор. Тогда, если размер набора равен только 1, они должны быть одинаковыми.

if len(set(my_list)) == 1:

Сомневаюсь, что это «самый Pythonic», но что-то вроде:

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

выполнит трюк.

Относительно использования reduce() с lambda. Вот рабочий код, который, как мне кажется, лучше, чем некоторые другие ответы.

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

Возвращает кортеж, где первое значение является логическим, если все элементы одинаковы или нет.

Для чего это стоит, это появилось недавно в списке рассылки python-идей . Оказалось, что для этого уже существует рецепт itertools : 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)

Предположительно, он работает очень хорошо и имеет несколько приятных свойств.

1. Короткие замыкания: он перестанет потреблять элементы из итерации, как только найдет первый неравный элемент.
2. Не требует, чтобы элементы были хешируемыми.
3. ] Он ленив и требует только O (1) дополнительной памяти для проверки.

1Иными словами, я не могу взять кредит на то, чтобы придумать решение - и не может Я признаю, что даже нашел это.

Самый простой и элегантный способ заключается в следующем:

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

(Да, это даже работает с нулевым списком! Это потому, что это один из немногих случаев, когда python имеет ленивую семантику. )

Что касается производительности, это произойдет как можно скорее, поэтому оно асимптотически оптимально.

Вы можете сделать:

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

Довольно раздражает, что python заставляет вас импортировать такие операторы, как operator.and_. Начиная с python3, вам также нужно будет импортировать functools.reduce.

(Вы не должны использовать этот метод, потому что он не сломается, если он найдет не равные значения, но продолжит изучение всего списка. просто включается здесь в качестве ответа для полноты.)

>>> 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"

Я бы сделал:

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

as any перестает искать итерацию, как только обнаруживает условие True.

Вот два простых способа сделать это

, используя set ()

. При преобразовании списка в набор удаляются повторяющиеся элементы. Поэтому, если длина преобразованного набора равна 1, это означает, что все элементы одинаковы.

len(set(input_list))==1

Вот пример

>>> a = ['not', 'the', 'same']
>>> b = ['same', 'same', 'same']
>>> len(set(a))==1  # == 3
False
>>> len(set(b))==1  # == 1
True

, используя all ()

Это будет сравнивать (эквивалентность) первый элемент списка ввода со всеми остальными элементами в списке. Если все эквиваленты True будут возвращены, в противном случае возвращается False.

all(element==input_list[0] for element in input_list)

Вот пример

>>> a = [1, 2, 3, 4, 5]
>>> b = [1, 1, 1, 1, 1]
>>> all(number==a[0] for number in a)
False
>>> all(number==b[0] for number in b)
True

PS Если вы проверяете, соответствует ли весь список определенному значение, вы можете suibstitue значение in для input_list [0].

Можно использовать карту и лямбда

lst = [1,1,1,1,1,1,1,1,1]

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