Làm thế nào để so sánh hiệu quả hai danh sách không có thứ tự (không phải bộ) trong Python?

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

a & b nên được coi là bằng nhau, bởi vì chúng có chính xác các yếu tố giống nhau, chỉ theo thứ tự khác nhau.

Vấn đề là, danh sách thực tế của tôi sẽ bao gồm các đối tượng (thể hiện lớp của tôi), không phải số nguyên.

O (n) : Phương thức Counter () là tốt nhất (nếu các đối tượng của bạn có thể băm):

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

O (n log n) : Phương thức sort () là tiếp theo tốt nhất (nếu các đối tượng của bạn có thứ tự):

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

O (n * n) : Nếu các đối tượng không thể băm, cũng không thể sắp xếp theo thứ tự, bạn có thể sử dụng đẳng thức:

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

Bạn có thể sắp xếp cả hai:

sorted(a) == sorted(b)

Một kiểu đếm cũng có thể hiệu quả hơn (nhưng nó đòi hỏi đối tượng phải có khả năng băm).

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

Nếu bạn biết các mục luôn có thể băm, bạn có thể sử dụng một mục Counter()là O (n)
Nếu bạn biết các mục luôn có thể sắp xếp, bạn có thể sử dụng sorted()đó là O (n log n)

Trong trường hợp chung, bạn không thể dựa vào việc có thể sắp xếp hoặc có các yếu tố, vì vậy bạn cần một dự phòng như thế này, điều không may là O (n ^ 2)

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

Cách tốt nhất để làm điều này là bằng cách sắp xếp các danh sách và so sánh chúng. (Sử dụng Countersẽ không hoạt động với các đối tượng không thể băm được.) Điều này rất đơn giản đối với số nguyên:

sorted(a) == sorted(b)

Nó được một chút phức tạp hơn với các đối tượng tùy ý. Nếu bạn quan tâm đến danh tính đối tượng, tức là, liệu các đối tượng giống nhau có trong cả hai danh sách hay không, bạn có thể sử dụng id()hàm làm khóa sắp xếp.

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

(Trong Python 2.x bạn không thực sự cần key=tham số, bởi vì bạn có thể so sánh bất kỳ đối tượng nào với bất kỳ đối tượng nào. Thứ tự là tùy ý nhưng ổn định, vì vậy nó hoạt động tốt cho mục đích này; trong đó, chỉ có thứ tự là giống nhau cho cả hai danh sách. Tuy nhiên, trong Python 3, việc so sánh các đối tượng thuộc các loại khác nhau không được phép trong nhiều trường hợp - ví dụ: bạn không thể so sánh các chuỗi với số nguyên - vì vậy nếu bạn sẽ có các đối tượng thuộc nhiều loại khác nhau, tốt nhất là sử dụng rõ ràng ID của đối tượng.)

Nếu bạn muốn so sánh các đối tượng trong danh sách theo giá trị, mặt khác, trước tiên bạn cần xác định "giá trị" nghĩa là gì đối với các đối tượng. Sau đó, bạn sẽ cần một số cách để cung cấp khóa đó (và cho Python 3, dưới dạng một loại nhất quán). Một cách tiềm năng có thể làm việc cho nhiều đối tượng tùy ý là sắp xếp theo chúng repr(). Tất nhiên, điều này có thể lãng phí rất nhiều thời gian và repr()chuỗi xây dựng bộ nhớ cho các danh sách lớn, v.v.

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

Nếu các đối tượng là tất cả các loại của riêng bạn, bạn có thể xác định __lt__()trên chúng để đối tượng biết cách so sánh chính nó với các đối tượng khác. Sau đó, bạn có thể chỉ cần sắp xếp chúng và không lo lắng về key=tham số. Tất nhiên bạn cũng có thể xác định __hash__()và sử dụng Counter, sẽ nhanh hơn.

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

assertCountEqual (thứ nhất, thứ hai, thông điệp = Không)

Kiểm tra chuỗi đó trước tiên chứa các phần tử giống như thứ hai, bất kể thứ tự của chúng. Khi họ không làm như vậy, một thông báo lỗi liệt kê sự khác biệt giữa các chuỗi sẽ được tạo ra.

Các yếu tố trùng lặp không được bỏ qua khi so sánh thứ nhất và thứ hai. Nó xác minh xem mỗi phần tử có cùng số đếm trong cả hai chuỗi. Tương đương với: assertEqual (Counter (danh sách (đầu tiên)), Counter (danh sách (thứ hai))) nhưng cũng hoạt động với chuỗi các đối tượng không thể xóa được.

Mới trong phiên bản 3.2.

hoặc trong 2.7: https://docs.python.org/2.7/l Library / unittest.html # unittest.TestCase.assertItemsEqual

Nếu danh sách chứa các mục không thể băm (chẳng hạn như danh sách các đối tượng), bạn có thể sử dụng lớp Counter và hàm id (), chẳng hạn như:

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

Tôi hy vọng đoạn mã dưới đây có thể hoạt động trong trường hợp của bạn: -

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

Điều này sẽ đảm bảo rằng tất cả các yếu tố trong cả hai danh sách a& bđều giống nhau, bất kể chúng có cùng thứ tự hay không.

Để hiểu rõ hơn, hãy tham khảo câu trả lời của tôi trong câu hỏi này

Nếu việc so sánh được thực hiện trong ngữ cảnh thử nghiệm, hãy sử dụng assertCountEqual(a, b)( py>=3.2) và assertItemsEqual(a, b)( 2.7<=py<3.2).

Hoạt động trên chuỗi các đối tượng không thể phá vỡ quá.

Hãy để danh sách 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

Không cần phải làm cho chúng có thể băm hoặc sắp xếp chúng.

Sử dụng unittestmô-đun cung cấp cho bạn một cách tiếp cận sạch sẽ và tiêu chuẩn.

import unittest

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