Мені потрібна наступна функція:

Вхід : alist

Вихід :

• True якщо всі елементи у вхідному списку оцінюють як рівні між собою за допомогою стандартного оператора рівності;
• False інакше.

Продуктивність : звичайно, я вважаю за краще не зазнавати зайвих накладних витрат.

Я вважаю, що найкраще:

• повторити список
• порівняйте сусідні елементи
• і ANDвсі отримані булеві значення

Але я не впевнений, який найбільш піфонічний спосіб це зробити.

Відсутність функції короткого замикання завдає шкоди лише довгому входу (понад ~ 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]

Різниця між трьома версіями полягає в тому, що:

1. В checkEqual2 змістом має бути хешируемим.
2. checkEqual1і checkEqual2може використовувати будь-які ітератори, алеcheckEqual3 повинні приймати послідовність введення, як правило, конкретні контейнери, такі як список або кортеж.
3. checkEqual1 припиняється, як тільки виявляється різниця.
4. Оскільки checkEqual1містить більше Python-коду, він менш ефективний, коли багато елементів на початку рівні.
5. Оскільки checkEqual2і checkEqual3завжди виконуються операції з копіювання O (N), вони зайнятимуть більше часу, якщо більша частина вашого вводу поверне помилкове значення.
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)

(Так, це навіть працює з порожнім списком! Це тому, що це один з небагатьох випадків, коли пітон має ліниву семантику.)

Щодо продуктивності, то це не вдасться якомога раніше, тому це асимптотично оптимально.

Набір порівняльних робіт:

len(set(the_list)) == 1

Використання setвидаляє всі повторювані елементи.

Ви можете перетворити список у набір. Набір не може мати дублікатів. Отже, якщо всі елементи в оригінальному списку однакові, набір матиме лише один елемент.

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

Що того варте, це нещодавно з’явилось у списку розсилки python-ідеї . Виявляється, для цього вже є рецепт 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])

Сумніваєтесь, що це "найбільш піфонічний", але щось на кшталт:

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

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