Python：确定列表中的所有项是否都是相同的项

在我的一些代码中，我将一系列对象放在一个列表中，并用它们的属性构建一个额外的列表，这是一个字符串。我需要确定第二个列表中的所有项是否具有完全相同的值，而事先不知道它是哪个值，然后返回bool，以便根据结果在代码中执行不同的操作

我不能事先知道属性的名称，这就是为什么我要尽可能地做一些通用的东西

为了让示例更清楚，一个名为“all_same”的理想函数的工作原理如下：

>>> property_list = ["one", "one", "one"]
>>> all_same(property_list)
True
>>> property_list = ["one", "one", "two"]
>>> all_same(property_list)
False

def all_same(items):
    return len(set(items)) < 2

---

我想列一个独特元素的列表，然后检查它的长度是否为1，但我不确定这是否是最优雅的解决方案。

你可以作弊并使用

设置

：

def all_same( items ):
    return len( set( items ) ) == 1 #== len( items )

或者您可以使用：

def all_same( items ):
    return all( map(lambda x: x == items[0], items ) )

def all_same(L):
  return all(x == L[0] for x in L)

或者，如果您处理的是一个iterable而不是列表：

def all_same( iterable ):
    it_copy = tee( iterable, 1 )
    return len( set( it_copy) ) == 1

示例：

>>> def all_same(items):
...     return all(x == items[0] for x in items)
...
>>> property_list = ["one", "one", "one"]
>>> all_same(property_list)
True
>>> property_list = ["one", "one", "two"]
>>> all_same(property_list)
False
>>> all_same([])
True

>>> def all_same(items):
...     return len(set(items)) < 2
... 
>>> 
>>> property_list = ["one", "one", "one"]
>>> all_same(property_list)
True
>>> property_list = ["one", "one", "two"]
>>> all_same(property_list)
False
>>> property_list = []
>>> all_same(property_list)
True

---

我最初将您解释为测试身份（“同一项”），但您实际上是在测试平等（“同一值”）。（如果您正在测试标识，请使用is而不是==）

以上内容适用于任何iterable，而不仅仅是列表，否则您可以使用：

def all_same( items ):
    return all( map(lambda x: x == items[0], items ) )

def all_same(L):
  return all(x == L[0] for x in L)

---

（但是，恕我直言，您最好使用通用版本，它在列表上工作得非常好。）

这对序列和可重用性都有效：

def all_same(items):
  it = iter(items)
  first = next(it, None)
  return all(x == first for x in it)

---

如果您知道值在列表中，这可能会更快

def all_same(values):
    return values.count(values[0]) == len(values)

---

最好的方法是使用Python集。您需要像这样定义

all\u same

：

>>> property_list = ["one", "one", "one"]
>>> all_same(property_list)
True
>>> property_list = ["one", "one", "two"]
>>> all_same(property_list)
False

def all_same(items):
    return len(set(items)) < 2

def全部相同（项目）：
返回长度（集合（项目））<2

测试：

>>> def all_same(items):
...     return all(x == items[0] for x in items)
...
>>> property_list = ["one", "one", "one"]
>>> all_same(property_list)
True
>>> property_list = ["one", "one", "two"]
>>> all_same(property_list)
False
>>> all_same([])
True

>>> def all_same(items):
...     return len(set(items)) < 2
... 
>>> 
>>> property_list = ["one", "one", "one"]
>>> all_same(property_list)
True
>>> property_list = ["one", "one", "two"]
>>> all_same(property_list)
False
>>> property_list = []
>>> all_same(property_list)
True

>>定义所有相同（项目）：
...     返回长度（集合（项目））<2
... 
>>> 
>>>属性列表=[“一”、“一”、“一”]
>>>全部相同（属性列表）
真的
>>>属性列表=[“一”、“一”、“二”]
>>>全部相同（属性列表）
假的
>>>属性列表=[]
>>>全部相同（属性列表）
真的

我仔细考虑后，为同一个问题创建了这段代码。但我不确定它是否适用于所有场景

def all_same(list):
    list[0]*len(list) == list

---

---

集合将只有一个项目，列表将有N。您可以在第二个代码中使用生成器表达式

all（x==items[0]表示项目中的x）

len（set（items））==1绝对是最惯用的。它也快得多：

a=[“a”]*100；a[53]=“b”

<代码>%timeit len（设置（a））==1-->每个循环2.83us<代码>%timeit all（x==a[0]表示a中的x）-->每个循环7.78us。@muraveill您使用的是哪台机器，您能重现这些结果吗？我可以在两台机器上尝试相反的相对顺序：

all（）

方法比

set（）

方法快大约3倍。非常好，我将使用这个方法，谢谢

len（set（items））==1

更快。@muraveill这在很大程度上取决于输入。这个答案有几个缺点：它只适用于可索引和相等（没有标识）。因此有了一个稍微改进的版本：导入操作符def same（iterable，compare=operator.eq，value_on_empty=True）：gen=iter（iterable）start=next（gen，value_on_empty）return all（gen中x的compare（start，x））这将适用于未大小的iterable，例如生成器，允许您指定“相同”的内容对空值的平均值和操作方法。@e-satis用该版本改进答案。+1我必须记住该配方。@Katrielex:然后你必须尝试/除了StopIteration；在这一点上，它的行为是等价的，长度也是一样的。我更喜欢

try:first=next（它），除了StopIteration:return True

——我认为流程更清晰——但确实有相同的区别。@Roger:对不起，注意到了，删除得太晚了。的确如此我喜欢这个解决方案。即使OP只要求列表，生成器现在在Python中非常普遍，最好不要假设输入是序列。请注意，您可以使用Python>=2.6:first=next（it，None）将其简化一点。啊，我想您应该检查

first is None

，而不是让它失效。它确实给出了正确的结果，但我更喜欢将其视为一个错误/“异常情况”，而不是依靠以后的代码来静默地做正确的事情。我知道我在这个观点中非常不和谐，但我不喜欢一行变成四行，因为我必须捕捉一个异常（我一般说来，你在回答中使用了for/break）。是的，我知道EAFP，但是，如果我可以避免的话……感谢+1，尽管：-）我刚刚意识到我在这里问了同样的问题：。我怎么把这两个问题联系起来？嘿，第一个问题我看到前面的问题是重复的。时间有时会起相反的作用。这个标题听起来像是询问者想要检查身份（

a是b

），而不是平等（

a==b

），恐怕这根本不起作用。例如，

test\u list=[1,1]

和

all\u same（test\u list）

返回

False

，因为

test\u list[0]=1

和

len（test\u list）=2

所以结果就是

1*2=2

。然后测试

2==test\u list

，这不是真的。这对我不起作用，因为我的列表中的元素是字典，不能散列