这是一种简单的方法:

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)

您可以将列表转换为集合。集合不能有重复项。所以如果原始列表中的所有元素都是相同的，那么集合就只有一个元素。

if len(set(input_list)) == 1:
    # input_list has all identical elements.

这是一个有趣的阅读和思考。谢谢大家! 我不认为任何依赖于纯计数的方法对所有情况都是可靠的。sum也可以工作，但只适用于数字或长度(再次导致计数场景)。

但我喜欢简单，所以我想出了这个:

all(i==lst[c-1] for c, i in enumerate(lst))

或者，我确实认为@kennytm的这个聪明的方法也适用于所有情况(有趣的是，它可能是最快的)。所以我承认它可能比我的好:

[lst[0]]*len(lst) == lst

我认为一个聪明的小奖励也会起作用，因为set消除了重复(聪明是有趣的，但通常不是维护代码的最佳实践)。我认为@kennytm的方法仍然会更快，但只适用于大型列表:

len(set(lst)) == 1

但是Python的简单和聪明是我最喜欢的语言之一。再想一下，如果你必须修改列表，就像我实际上做的那样，因为我正在比较地址(并将删除开头/结尾空格并转换为小写以消除可能的不一致，我的将更适合这项工作)。所以“更好”是主观的，因为我在使用这个词时使用了引号!但是你也可以事先清理列表。

祝你好运!

不管怎样，这是最近在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)

据说它的性能非常好，有一些不错的属性。

短路:一旦发现第一个不相等的项，它就会停止从可迭代对象中消费项目。 不要求项是可哈希的。 它是懒惰的，只需要O(1)个额外的内存来进行检查。

换句话说，我不能把提出这个解决方案的功劳占为己有，甚至我也不能把找到它的功劳占为己有。

或者使用numpy的diff方法:

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

并呼吁:

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

输出:

True

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

当然，可读性也有好处。