Мне нужна следующая функция:

Вход : аlist

Выход :

• True если все элементы входного списка оцениваются как равные друг другу, используя стандартный оператор равенства;
• False в противном случае.

Производительность : конечно, я предпочитаю не подвергаться ненужным накладным расходам.

Я чувствую, что было бы лучше:

• перебрать список
• сравнить соседние элементы
• и ANDвсе полученные логические значения

Но я не уверен, какой самый Pythonic способ сделать это.

Отсутствие функции короткого замыкания сказывается только на длинном входе (более ~ 50 элементов), который имеет неравные элементы в начале. Если это происходит достаточно часто (как часто зависит от длины списков), короткое замыкание не требуется. Лучший алгоритм короткого замыкания, кажется, @KennyTM checkEqual1. Это платит, однако, значительную стоимость для этого:

• почти в 20 раз по производительности почти одинаковые списки
• производительность до 2,5 раз в коротких списках

Если длинные входы с ранними неравными элементами не происходят (или случаются достаточно редко), короткое замыкание не требуется. Тогда, безусловно, самым быстрым является решение @Ivo van der Wijk.

Общий метод:

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

Один лайнер:

def checkEqual2(iterator):
   return len(set(iterator)) <= 1

Также однострочник:

def checkEqual3(lst):
   return lst[1:] == lst[:-1]

Разница между 3 версиями заключается в том, что:

1. По checkEqual2содержанию должен быть хэш
2. checkEqual1и checkEqual2может использовать любые итераторы, но checkEqual3должен принимать последовательность ввода, обычно это конкретные контейнеры, такие как список или кортеж.
3. checkEqual1 останавливается, как только разница обнаружена.
4. Так как checkEqual1содержит больше кода Python, он менее эффективен, когда многие элементы равны в начале.
5. Так как checkEqual2и checkEqual3всегда выполняйте O (N) операции копирования, они займут больше времени, если большая часть вашего ввода вернет False.
6. Для checkEqual2и checkEqual3сложнее адаптировать сравнение a == bк a is b.

timeit результат, для Python 2.7 и (только s1, s4, s7, s9 должны возвращать True)

s1 = [1] * 5000
s2 = [1] * 4999 + [2]
s3 = [2] + [1]*4999
s4 = [set([9])] * 5000
s5 = [set([9])] * 4999 + [set([10])]
s6 = [set([10])] + [set([9])] * 4999
s7 = [1,1]
s8 = [1,2]
s9 = []

мы получили

      | checkEqual1 | checkEqual2 | checkEqual3  | checkEqualIvo | checkEqual6502 |
|-----|-------------|-------------|--------------|---------------|----------------|
| s1  | 1.19   msec | 348    usec | 183     usec | 51.6    usec  | 121     usec   |
| s2  | 1.17   msec | 376    usec | 185     usec | 50.9    usec  | 118     usec   |
| s3  | 4.17   usec | 348    usec | 120     usec | 264     usec  | 61.3    usec   |
|     |             |             |              |               |                |
| s4  | 1.73   msec |             | 182     usec | 50.5    usec  | 121     usec   |
| s5  | 1.71   msec |             | 181     usec | 50.6    usec  | 125     usec   |
| s6  | 4.29   usec |             | 122     usec | 423     usec  | 61.1    usec   |
|     |             |             |              |               |                |
| s7  | 3.1    usec | 1.4    usec | 1.24    usec | 0.932   usec  | 1.92    usec   |
| s8  | 4.07   usec | 1.54   usec | 1.28    usec | 0.997   usec  | 1.79    usec   |
| s9  | 5.91   usec | 1.25   usec | 0.749   usec | 0.407   usec  | 0.386   usec   |

Замечания:

# http://stackoverflow.com/q/3844948/
def checkEqualIvo(lst):
    return not lst or lst.count(lst[0]) == len(lst)

# http://stackoverflow.com/q/3844931/
def checkEqual6502(lst):
    return not lst or [lst[0]]*len(lst) == lst

Решение, которое быстрее, чем использование 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

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

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

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

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

Набор сравнительных работ:

len(set(the_list)) == 1

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

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

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

Для чего это стоит, это недавно появилось в списке рассылки python-ideas . Оказывается, что для этого уже есть рецепт itertools : ¹

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 Другими словами, я не могу взять кредит за то, что нашел решение - и я не могу взять кредит за то, что даже нашел его.}

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

используя 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

используя все ()

Это позволит сравнить (эквивалентность) первого элемента входного списка с каждым другим элементом в списке. Если все эквивалентны 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 Если вы проверяете, является ли весь список эквивалентным определенному значению, вы можете выбрать значение для input_list [0].

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

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

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

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)

Проверьте, все ли элементы равны первому.

np.allclose(array, array[0])

Сомневаюсь, что это «самый 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

сделал бы трюк.

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

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

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

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

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

Я сделаю:

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

as anyпрекращает поиск итерируемого, как только находит Trueусловие.

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

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

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

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

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

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

Или используйте diffметод NumPy:

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

И позвонить:

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

Вывод:

True

Или используйте метод сравнения numpy:

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

И позвонить:

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

Вывод:

Правда

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

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

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

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

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

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

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

Существует также рекурсивная опция чистого Python:

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

Однако по некоторым причинам это в некоторых случаях на два порядка медленнее, чем другие варианты. Исходя из менталитета языка Си, я ожидал, что это будет быстрее, но это не так!

Другим недостатком является то, что в Python есть предел рекурсии, который в этом случае необходимо скорректировать. Например, используя это .

Вы можете использовать, .nunique()чтобы найти количество уникальных предметов в списке.

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

Вы можете использовать set. Это сделает набор и удалит повторяющиеся элементы. Затем убедитесь, что в нем не более 1 элемента.

if len(set(your_list)) <= 1:
    print('all ements are equal')

Пример:

>>> len(set([5, 5])) <= 1
True