Aşağıdaki fonksiyona ihtiyacım var:

Giriş : alist

Çıktı :

• True giriş listesindeki tüm elemanlar standart eşitlik operatörünü kullanarak birbirine eşit olarak değerlendirilirse;
• False aksi takdirde.

Performans : elbette, gereksiz ek yüke maruz kalmamayı tercih ederim.

Ben en iyisi olacağını hissediyorum:

• liste boyunca yineleme
• bitişik elemanları karşılaştır
• ve ANDsonuçta elde edilen tüm Boolean değerleri

Ama bunu yapmanın en Pitonik yolunun ne olduğundan emin değilim.

Kısa devre özelliğinin olmaması, yalnızca eşit olmayan öğelere sahip uzun bir girişe (~ 50'den fazla eleman) zarar verir. Bu yeterince sık meydana gelirse (listelerin ne kadar uzunluğuna bağlı olabilir), kısa devre gereklidir. En iyi kısa devre algoritması @KennyTM gibi görünüyor checkEqual1. Bununla birlikte, bunun için önemli bir maliyet ödüyor:

• 20x'e kadar performansta neredeyse aynı listeler
• Kısa listelerde 2,5 kata kadar performans

Erken eşit olmayan öğelere sahip uzun girişler olmazsa (veya nadiren yeterli değilse), kısa devre gerekmez. Sonra, en hızlısı @Ivo van der Wijk çözümüdür.

Genel yöntem:

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

Tek astarı:

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

Ayrıca bir astar:

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

3 versiyon arasındaki fark şudur:

1. Gelen checkEqual2içerik hashable olmalıdır.
2. checkEqual1ve checkEqual2herhangi bir yineleyici kullanabilir, ancak checkEqual3bir dizi girişi, tipik olarak bir liste veya demet gibi beton kaplar almalıdır.
3. checkEqual1 fark bulunur bulunmaz durur.
4. Yana checkEqual1daha Python kodunu içeren maddelerin birçoğu başlangıçta eşit olduğunda, daha az verimlidir.
5. Yana checkEqual2ve checkEqual3her zaman O (K) kopyalama işlemleri gerçekleştirmek girişiniz en Yanlış dönecektir, onlar daha uzun sürer.
6. İçin checkEqual2ve checkEqual3ondan karşılaştırma adapte zordur a == biçin a is b.

timeit sonuç, Python 2.7 ve (yalnızca s1, s4, s7, s9 True döndürmelidir)

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 = []

aldık

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

Not:

# 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

Diziler (yinelemesiz) üzerinde çalışan set () yöntemini kullanmaktan daha hızlı bir çözüm, yalnızca ilk öğeyi saymaktır. Bu, listenin boş olmadığını varsayar (ancak boş bir listede sonucun ne olması gerektiğine kendiniz karar vermeniz önemsizdir)

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

bazı basit kriterler:

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

En basit ve zarif yol aşağıdaki gibidir:

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

(Evet, bu boş liste ile bile çalışır! Bunun nedeni, python'un tembel anlambilimine sahip olduğu birkaç durumdan biridir.)

Performans ile ilgili olarak, bu mümkün olan en erken zamanda başarısız olacaktır, bu nedenle asimptotik olarak optimaldir.

Bir dizi karşılaştırma çalışması:

len(set(the_list)) == 1

Kullanarak settüm yinelenen öğeler kaldırılır.

Listeyi bir kümeye dönüştürebilirsiniz. Bir kümenin kopyaları olamaz. Dolayısıyla, orijinal listedeki tüm öğeler aynı ise, kümede yalnızca bir öğe bulunur.

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

Değeri için, bu son zamanlarda python-fikirler posta listesinde geldi . Bunu zaten yapmak için bir itertools tarifi olduğu ortaya çıkıyor : ¹

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)

Sözde çok güzel bir performans sergiliyor ve birkaç güzel özelliği var.

1. Kısa devreler: İlk eşit olmayan öğeyi bulur bulmaz yinelenen öğeleri tüketmeyi durduracaktır.
2. Öğelerin yıkanabilir olmasını gerektirmez.
3. Tembeldir ve kontrolü yapmak için sadece O (1) ek bellek gerektirir.

^{1 Başka bir deyişle, ben çözüm ile geliyor için kredi alamaz - ne de olsa kredi notun bulma onu.}

İşte bunu yapmanın iki basit yolu

set () kullanarak

Listeyi bir kümeye dönüştürürken, yinelenen öğeler kaldırılır. Dönüştürülen kümenin uzunluğu 1 ise, bu tüm öğelerin aynı olduğunu gösterir.

len(set(input_list))==1

İşte bir örnek

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

tümünü kullanarak ()

Bu, giriş listesinin ilk öğesini listedeki diğer tüm öğelerle karşılaştırır (eşdeğerlik). Hepsi eşdeğerse True döndürülür, aksi takdirde False döndürülür.

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

İşte bir örnek

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

Not: Tüm listenin belirli bir değere eşit olup olmadığını kontrol ediyorsanız, input_list [0] için değeri saklayabilirsiniz.

Bu, len(set(x))==1uzun listelerden daha hızlı bir başka seçenektir (kısa devre kullanır)

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

Bunu yapmanın basit bir yolu:

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

Bu biraz daha karmaşıktır, işlev çağrısı tepegözüne neden olur, ancak anlambilim daha açık bir şekilde belirtilir:

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

Tüm öğelerin birinciye eşit olup olmadığını kontrol edin.

np.allclose(array, array[0])

Şüphe bu "en Pythonic", ama gibi bir şey:

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

hile yapardı.

Biraz daha okunabilir bir şeyle ilgileniyorsanız (ancak elbette o kadar verimli değil) deneyebilirsiniz:

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

Listeyi kümeye dönüştürün ve ardından kümedeki öğelerin sayısını bulun. Sonuç 1 ise, aynı öğelere sahiptir ve eğer değilse, listedeki öğeler aynı değildir.

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

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

İle kullanımı reduce()ile ilgili lambda. Kişisel olarak diğer cevaplardan daha güzel olduğunu düşündüğüm bir çalışma kodu.

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

Tüm öğeler aynı veya değilse, ilk değerin boole olduğu bir demet döndürür.

Ben yapardım:

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

olarak anydurur en kısa sürede iterable arama bir bulduğu olarak Truekoşulu.

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

"Tümü" olmayan Python 2.4 ile çalışır.

Harita ve lambda kullanabilir

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

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

Veya diffnumpy yöntemini kullanın :

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

Ve aramak için:

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

Çıktı:

True

Veya farklı numpy yöntemini kullanın:

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

Ve aramak için:

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

Çıktı:

Doğru

Yapabilirsin:

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

Python'un operatörleri içe aktarmanızı oldukça sinir bozucu operator.and_. Python3'ten itibaren ayrıca içe aktarmanız gerekecektir functools.reduce.

(Bu yöntemi kullanmamalısınız, çünkü eşit olmayan değerler bulursa kırılmaz, ancak tüm listeyi incelemeye devam eder. Burada tamlık için bir yanıt olarak eklenmiştir.)

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

Bir sonraki kısa devreye kısa devre yapacak:

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

Listeyi bir kümeyle değiştirin. O zaman setin boyutu sadece 1 ise, aynı olmalılar.

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

Saf Python özyinelemeli bir seçenek de vardır:

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

Ancak, bazı nedenlerden ötürü, diğer seçeneklerden daha yavaş iki büyüklük sırasıdır. C dili zihniyetinden geldiğimde, bunun daha hızlı olmasını bekliyordum, ama değil!

Diğer dezavantaj, Python'da bu durumda ayarlanması gereken özyineleme sınırının olmasıdır. Örneğin bunu kullanarak .

.nunique()Listedeki benzersiz öğelerin sayısını bulmak için kullanabilirsiniz .

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

kullanabilirsiniz set. Bir set yapacak ve tekrarlayan elemanları kaldıracaktır. Sonra 1'den fazla eleman olmadığını kontrol edin.

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

Misal:

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