将您的输入转换为一个集:

len(set(the_list)) <= 1

使用set可以删除所有重复的元素。<= 1使它在输入为空时正确地返回True。

这要求输入中的所有元素都是可哈希的。例如，如果传入一个列表的列表，就会得到一个TypeError。

我怀疑这是“最python化的”，但类似于:

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

会成功的。

将您的输入转换为一个集:

len(set(the_list)) <= 1

使用set可以删除所有重复的元素。<= 1使它在输入为空时正确地返回True。

这要求输入中的所有元素都是可哈希的。例如，如果传入一个列表的列表，就会得到一个TypeError。

出现使用itertools。Groupby(参见itertools食谱):

from itertools import groupby

def all_equal(iterable):
    g = groupby(iterable)
    return next(g, True) and not next(g, False)

或不带groupby:

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

您可以考虑使用许多其他的一行程序:

Converting the input to a set and checking that it only has one or zero (in case the input is empty) items def all_equal2(iterator): return len(set(iterator)) <= 1 Comparing against the input list without the first item def all_equal3(lst): return lst[:-1] == lst[1:] Counting how many times the first item appears in the list def all_equal_ivo(lst): return not lst or lst.count(lst[0]) == len(lst) Comparing against a list of the first element repeated def all_equal_6502(lst): return not lst or [lst[0]]*len(lst) == lst

但它们也有一些缺点，即:

all_equal and all_equal2 can use any iterators, but the others must take a sequence input, typically concrete containers like a list or tuple. all_equal and all_equal3 stop as soon as a difference is found (what is called "short circuit"), whereas all the alternatives require iterating over the entire list, even if you can tell that the answer is False just by looking at the first two elements. In all_equal2 the content must be hashable. A list of lists will raise a TypeError for example. all_equal2 (in the worst case) and all_equal_6502 create a copy of the list, meaning you need to use double the memory.

在Python 3.9中，使用perfplot，我们得到这些计时(越低的Runtime [s]越好):

简单的解决方案是应用set on list

如果所有元素都相同，len将为1，否则大于1

lst = [1,1,1,1,1,1,1,1,1]
len_lst = len(list(set(lst)))

print(len_lst)

1


lst = [1,2,1,1,1,1,1,1,1]
len_lst = len(list(set(lst)))
print(len_lst)

2

[编辑:这个答案针对当前投票最多的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).

当然，可读性也有好处。