检查列表中的所有元素是否相同

Question

我需要一个函数，如果输入列表中的所有元素使用标准相等运算符计算为彼此相等，则接收 list 并输出 True，否则输出 False。

我觉得最好遍历列表比较相邻元素，然后 AND 所有结果布尔值。但我不确定最 Pythonic 的方式是什么。

Answer 1

使用itertools.groupby（见the itertools recipes）：

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)

---

您可能会考虑多种替代单线：

1. 将输入转换为集合并检查它是否只有一个或零（如果输入为空）项

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

2. 与没有第一项的输入列表进行比较

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

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

4. Comparing against a list of the first element repeated

   def all_equal_6502(lst):
       return not lst or [lst[0]]*len(lst) == lst
   

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

1. all_equal 和 all_equal2 可以使用任何迭代器，但其他迭代器必须采用序列输入，通常是列表或元组等具体容器。
2. all_equal 和 all_equal3 在发现差异后立即停止（所谓的“short circuit”），而所有替代方案都需要遍历整个列表，即使您知道答案是 False 只是通过查看前两个元素。
3. 在all_equal2 中，内容必须是hashable。例如，列表列表将引发 TypeError。
4. all_equal2（在最坏的情况下）和 all_equal_6502 创建列表的副本，这意味着您需要使用双倍的内存。

在 Python 3.9 上，使用 perfplot，我们得到这些时间（Runtime [s] 越低越好）：

Answer 2

比使用 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

Answer 3

[编辑：此答案稍后解决当前投票最多的itertools.groupby（这是一个很好的答案）答案。]

在不重写程序的情况下，最渐近执行和最易读的方式如下：

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

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

这将在尽可能早的时间失败，因此它是渐近最优的（预期时间大约是 O(#uniques) 而不是 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.groupby 答案，它的速度是allEqual 的两倍，因为它可能是优化的 C 代码。 （根据文档，它应该（类似于这个答案）没有任何内存开销，因为惰性生成器永远不会被评估为一个列表......这可能会让人担心，但伪代码显示分组的“列表”是实际上是惰性生成器。）

如果您更关心性能，请继续阅读...

---

关于性能的旁注，因为其他答案出于某种未知原因正在谈论它：

...如果您以前看过数据并且可能使用某种集合数据结构，并且您真的很关心性能，您可以通过增加您的 O(1) 免费获得 .isAllEqual()带有Counter 的结构，每次插入/删除/等都会更新。操作并检查它是否为{something:someCount} 即len(counter.keys())==1 的形式；或者，您可以将 Counter 放在单独的变量中。可以证明，这比其他任何东西都要好。也许你也可以使用 python 的 FFI 和 ctypes 和你选择的方法，也许还有启发式（比如它是一个带有 getitem 的序列strong>，然后依次检查第一个元素、最后一个元素，然后是元素）。

当然，为了可读性，有一些话要说。

Answer 4

将您的输入转换为set：

len(set(the_list)) <= 1

使用set 删除所有重复元素。 <= 1 是为了在输入为空时正确返回 True。

这要求输入中的所有元素都是hashable。例如，如果您传入列表列表，您将获得 TypeError。

Answer 5

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

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

Answer 6

对于它的价值，这是最近出现在python-ideas mailing list 上的。事实证明，已经有一个 itertools recipe 可以这样做：¹

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换句话说，我不能把提出解决方案的功劳归功于我——我也不能把自己的功劳归于找到它。}

Answer 7

这是一个简单的方法：

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)

Answer 8

这是另一种选择，比len(set(x))==1 长列表更快（使用短路）

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

Answer 9

检查所有元素是否等于第一个。

np.allclose(array, array[0])

Answer 10

怀疑这是“最 Pythonic”，但类似：

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

会成功的。

Answer 11

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

在没有“全部”的 Python 2.4 中工作。

Answer 12

我愿意：

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

因为any 在找到True 条件后立即停止搜索迭代。

Answer 13

关于使用reduce() 和lambda。这是一个我个人认为比其他一些答案更好的工作代码。

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

如果所有项目都相同，则返回一个元组，其中第一个值是布尔值。

Answer 14

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

Answer 15

如果您对更具可读性的东西感兴趣（但当然效率不高），您可以尝试：

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

Answer 16

或者使用numpy的diff方法：

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

然后调用：

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

输出：

True

Answer 17

你可以这样做：

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

python 让你导入像operator.and_ 这样的运算符是相当烦人的。从 python3 开始，您还需要导入 functools.reduce。

（您不应该使用此方法，因为如果它找到不相等的值，它不会中断，但会继续检查整个列表。它只是包含在此处作为完整性的答案。）

Answer 18

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

Answer 19

可以使用map和lambda

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

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

Answer 20

或者使用numpy的diff方法：

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

然后调用：

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

输出：

是的

Answer 21

还有一个纯 Python 递归选项：

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

但是由于某种原因，在某些情况下它比其他选项慢两个数量级。出于 C 语言的心态，我预计这会更快，但事实并非如此！

另一个缺点是 Python 中存在递归限制，在这种情况下需要调整。例如使用this。

Answer 22

简单的解决方案是在列表上应用集合

如果所有元素都相同，则 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

Answer 23

您可以使用.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

Answer 24

也许我低估了这个问题？检查列表中唯一值的长度。

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

Answer 25

我认为，这里的代码具有大量的 Python 性，并且在简单性和显而易见性之间取得了平衡，它应该也适用于相当旧的 Python 版本。

def all_eq(lst):
    for idx, itm in enumerate(lst):
        if not idx:   # == 0
            prev = itm
        if itm != prev:
            return False
        prev = itm
    return True