Question

a = [1, 2, 3, 1, 2, 3]
b = [3, 2, 1, 3, 2, 1]

a＆amp; b应该被认为是相等的，因为它们具有完全相同的元素，只是顺序不同。

问题是，我的实际列表将包含对象（我的类实例），而不是整数。

Answer 1

O（n）： Counter() 方法最好（如果您的对象可以播放）：

def compare(s, t):
    return Counter(s) == Counter(t)

O（n log n）： sorted() 方法是次佳的（如果您的对象可以订购）：

def compare(s, t):
    return sorted(s) == sorted(t)

O（n * n）：如果对象既不可清洗也不可订购，则可以使用相等：

def compare(s, t):
    t = list(t)   # make a mutable copy
    try:
        for elem in s:
            t.remove(elem)
    except ValueError:
        return False
    return not t

Answer 2

您可以对两者进行排序：

sorted(a) == sorted(b)

counting sort也可能更有效（但它需要对象可以清除）。

>>> from collections import Counter
>>> a = [1, 2, 3, 1, 2, 3]
>>> b = [3, 2, 1, 3, 2, 1]
>>> print (Counter(a) == Counter(b))
True

Answer 3

如果您知道这些项目始终可以播放，则可以使用Counter()即O（n）
如果您知道这些项目始终是可排序的，则可以使用sorted()，即O（n log n）

在一般情况下，您不能依赖于能够排序或具有元素，因此您需要这样的后备，不幸的是O（n ^ 2）

len(a)==len(b) and all(a.count(i)==b.count(i) for i in a)

Answer 4

执行此操作的最佳方法是对列表进行排序并进行比较。（使用Counter将无法使用不可清除的对象。）这对于整数来说很简单：

sorted(a) == sorted(b)

任意对象变得有点棘手。如果您关心对象标识，即相同的对象是否在两个列表中，您可以使用id()函数作为排序键。

sorted(a, key=id) == sorted(b, key==id)

（在Python 2.x中，您实际上并不需要key=参数，因为您可以将任何对象与任何对象进行比较。排序是任意的但是稳定，因此它可以正常工作;它不会无论对象在什么顺序，只有两个列表的顺序相同。但是在Python 3中，在许多情况下不允许比较不同类型的对象 - 例如，你不能将字符串与整数进行比较 - 所以如果你有各种类型的对象，最好明确使用对象的ID。）

另一方面，如果要通过值比较列表中的对象，首先需要定义“值”对于对象的含义。然后你需要一些方法来提供它作为一个键（对于Python 3，作为一致的类型）。对许多任意对象起作用的一种可能方法是按repr()排序。当然，这可能会浪费大量的额外时间和内存为大型列表构建repr()字符串等等。

sorted(a, key=repr) == sorted(b, key==repr)

如果对象都是您自己的类型，您可以在它们上定义__lt__()，以便对象知道如何将自己与其他对象进行比较。然后你可以对它们进行排序而不用担心key=参数。当然，您也可以定义__hash__()并使用Counter，这样会更快。

Answer 5

如果列表包含不可清除的项（例如对象列表），您可以使用Counter Class和id（）函数，例如：

from collections import Counter
...
if Counter(map(id,a)) == Counter(map(id,b)):
    print("Lists a and b contain the same objects")

Answer 6

如果要在测试环境中执行比较，请使用assertCountEqual(a, b)（py>=3.2）和assertItemsEqual(a, b)（2.7<=py<3.2）。

也适用于不可用对象的序列。

Answer 7

https://docs.python.org/3.5/library/unittest.html#unittest.TestCase.assertCountEqual

assertCountEqual（first，second，msg = None）

测试该序列首先包含与第二个相同的元素，而不管它们的顺序如何。如果没有，将生成列出序列之间差异的错误消息。

比较第一个和第二个时，不会忽略重复元素。它验证每个元素在两个序列中是否具有相同的计数。相当于：assertEqual（Counter（list（first）），Counter（list（second）））但也适用于不可用对象的序列。

3.2版中的新功能。

或在2.7中： https://docs.python.org/2.7/library/unittest.html#unittest.TestCase.assertItemsEqual

Answer 8

让a，b列出

def ass_equal(a,b):
try:
    map(lambda x: a.pop(a.index(x)), b) # try to remove all the elements of b from a, on fail, throw exception
    if len(a) == 0: # if a is empty, means that b has removed them all
        return True 
except:
    return False # b failed to remove some items from a

无需使它们可以清洗或分类。

Answer 9

我希望下面的代码可能适用于您的情况： -

if ((len(a) == len(b)) and
   (all(i in a for i in b))):
    print 'True'
else:
    print 'False'

这将确保列表a和列表中的所有元素。 b是相同的，无论它们是否处于相同的顺序。

为了更好地理解，请参阅this question

中的答案

Answer 10

使用unittest模块为您提供了一种干净而标准的方法。

import unittest

test_object = unittest.TestCase()
test_object.assertCountEqual(a, b)

Answer 11

您可以编写自己的函数来比较列表。

让我们得到两个列表。

select * from `contents__keywords`
where `keyword_id` in (127, 162, 249, 567)
group by `content_id`
having count(distinct `keyword_id`) >= 2
order by `content_id`
desc
limit 4

首先，我们定义一个空字典，统计列表项并写入字典。

list_1=['John', 'Doe'] 
list_2=['Doe','Joe']

之后，我们将使用以下函数比较两个列表。

def count_list(list_items):
    empty_dict={}
    for list_item in list_items:
        list_item=list_item.strip()
        if list_item not in empty_dict:
            empty_dict[list_item]=1
        else:
            empty_dict[list_item]+=1
    return empty_dict

如何在Python中有效地比较两个无序列表（不是集合）？

11 个答案: