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

适用于Python 2.4，它没有“all”。

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

或者使用numpy的diff方法:

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

并呼吁:

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

输出:

True

也许我低估了问题的严重性?检查列表中唯一值的长度。

lzt = [1,1,1,1,1,2]

if (len(set(lzt)) > 1):
    uniform = False
elif (len(set(lzt)) == 1):
    uniform = True
elif (not lzt):
    raise ValueError("List empty, get wrecked")

[编辑:这个答案针对当前投票最多的itertools。Groupby(这是一个很好的答案)稍后回答。

在不重写程序的情况下，最具渐近性能和可读性的方法如下:

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

(是的，这甚至适用于空列表!这是因为这是python具有惰性语义的少数情况之一。)

这将在尽可能早的时间失败，因此它是渐近最优的(期望时间大约是O(#惟一)而不是O(N)，但最坏情况时间仍然是O(N))。这是假设你之前没有看过这些数据……

(如果你关心性能，但不太关心性能，你可以先做通常的标准优化，比如将myList[0]常量从循环中提升出来，并为边缘情况添加笨拙的逻辑，尽管这是python编译器最终可能会学会如何做的事情，因此除非绝对必要，否则不应该这样做，因为它会破坏最小收益的可读性。)

如果你更关心性能，这是上面速度的两倍，但有点啰嗦:

def allEqual(iterable):
    iterator = iter(iterable)
    
    try:
        firstItem = next(iterator)
    except StopIteration:
        return True
        
    for x in iterator:
        if x!=firstItem:
            return False
    return True

如果你更关心性能(但还不足以重写你的程序)，请使用当前投票最多的itertools。它的速度是allEqual的两倍，因为它可能是优化的C代码。(根据文档，它应该(类似于这个答案)没有任何内存开销，因为惰性生成器永远不会被计算到列表中…这可能会让人担心，但伪代码表明，分组的“列表”实际上是惰性生成器。)

如果你更关心性能，请继续阅读…

关于性能的旁注，因为其他答案都在谈论它，因为一些未知的原因:

... if you have seen the data before and are likely using a collection data structure of some sort, and you really care about performance, you can get .isAllEqual() for free O(1) by augmenting your structure with a Counter that is updated with every insert/delete/etc. operation and just checking if it's of the form {something:someCount} i.e. len(counter.keys())==1; alternatively you can keep a Counter on the side in a separate variable. This is provably better than anything else up to constant factor. Perhaps you can also use python's FFI with ctypes with your chosen method, and perhaps with a heuristic (like if it's a sequence with getitem, then checking first element, last element, then elements in-order).

当然，可读性也有好处。

如果你对一些更有可读性的东西感兴趣(但当然不是那么高效)，你可以尝试:

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