Python'daki iki sıralanmamış listeyi (küme değil) verimli bir şekilde nasıl karşılaştırırım?

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

a & b eşit kabul edilmelidir, çünkü tam olarak aynı unsurlara sahiptirler, sadece farklı sırayla.

Mesele şu ki, gerçek listelerim tamsayılardan değil nesnelerden (sınıf örneklerim) oluşacaktır.

O (n) : Counter () yöntemi en iyisidir (nesneleriniz yıkanabilirse):

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

O (n günlüğü n) : Sort () yöntemi en iyisidir (nesneleriniz düzenlenebilirse):

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

O (n * n) : Nesneler ne yıkanabilir ne de düzenlenemezse eşitliği kullanabilirsiniz:

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

Her ikisini de sıralayabilirsiniz:

sorted(a) == sorted(b)

Bir sayma sıralaması da daha verimli olabilir (ancak nesnenin yıkanabilir olmasını gerektirir).

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

Maddelerin her zaman yıkanabileceğini biliyorsanız Counter(), O (n) 'yi
kullanabilirsiniz. Maddelerin her zaman sıralanabilir olduğunu biliyorsanız sorted(), O (n log n)' yi kullanabilirsiniz.

Genel durumda, sıralayabileceğinize veya öğelere sahip olamayacağınıza güvenemezsiniz, bu yüzden böyle bir geri dönüşe ihtiyacınız var, maalesef O (n ^ 2)

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

Bunu yapmanın en iyi yolu listeleri sıralamak ve karşılaştırmaktır. (Kullanılması Counter, yıkanamayan nesnelerle çalışmaz.) Bu, tamsayılar için basittir:

sorted(a) == sorted(b)

Keyfi nesnelerle biraz daha karmaşıklaşıyor. Nesne kimliğini, yani her iki listede de aynı nesnelerin olup olmadığını önemsiyorsanız , id()işlevi sıralama anahtarı olarak kullanabilirsiniz .

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

(Python 2.x'te aslında key= parametreye , çünkü herhangi bir nesneyi herhangi bir nesneyle karşılaştırabilirsiniz. Sıralama keyfi ancak sabittir, bu nedenle bu amaç için iyi çalışır; nesnelerin hangi sırada olduğu önemli değildir. Ancak, Python 3'te, farklı türlerdeki nesneleri karşılaştırmak pek çok durumda izin verilmez - örneğin, dizeleri tamsayılarla karşılaştıramazsınız - yani nesneleriniz varsa çeşitli türlerde, nesnenin kimliğini açıkça kullanmak için en iyisidir.)

Öte yandan listedeki nesneleri değere göre karşılaştırmak istiyorsanız , önce nesneler için "değer" in ne anlama geldiğini tanımlamanız gerekir. O zaman bunu bir anahtar olarak (ve Python 3 için tutarlı bir tür olarak) sağlamanın bir yoluna ihtiyacınız olacak. Birçok keyfi nesne için işe yarayabilecek potansiyel bir yol, bunlara göre sıralamaktır repr(). Tabii ki, bu repr()büyük listeler ve benzeri için çok fazla zaman ve hafıza oluşturma dizeleri harcayabilir .

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

Nesnelerin tümü kendi türünüzdeyse, __lt__()nesnenin kendisini başkalarıyla nasıl karşılaştıracağını bilmesi için bunları tanımlayabilirsiniz . Sonra onları sıralayabilir ve key=parametre hakkında endişelenmeyebilirsiniz . Tabii ki daha hızlı olacak olan tanımlayabilir __hash__()ve kullanabilirsiniz Counter.

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

assertCountEqual (birinci, ikinci, msg = Yok)

Bu sıranın, sıralarına bakılmaksızın ikinci olarak aynı öğeleri içerdiğini test edin. Yapmadıkları zaman, sekanslar arasındaki farkları listeleyen bir hata mesajı üretilecektir.

Birinci ve ikinci karşılaştırılırken yinelenen öğeler yok sayılmaz. Her bir öğenin her iki dizide de aynı sayıya sahip olup olmadığını doğrular. Eşdeğer: assertEqual (Sayaç (liste (ilk)), Sayaç (liste (ikinci))) ancak paylaşılamayan nesnelerin dizileriyle de çalışır.

Sürüm 3.2'deki yenilikler.

veya 2.7'de: https://docs.python.org/2.7/library/unittest.html#unittest.TestCase.assertItemsEqual

Liste, yıkanamayan öğeler (nesnelerin listesi gibi) içeriyorsa, Sayaç Sınıfı ve id () işlevini aşağıdaki gibi kullanabilirsiniz:

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

Umarım aşağıdaki kod parçası sizin durumunuzda işe yarayabilir: -

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

Bu listelerin hem tüm unsurları sağlayacaktır a& bbakılmaksızın aynı sırada olup olmadıklarını arasında aynıdır.

Daha iyi anlamak için bu sorudaki cevabıma bakın

Karşılaştırma bir test bağlamında yapılacaksa, assertCountEqual(a, b)( py>=3.2) ve assertItemsEqual(a, b)( 2.7<=py<3.2) kullanın.

Paylaşılamayan nesnelerin dizileri üzerinde de çalışır.

A, b listeleri olsun

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

Onları yıkanabilir hale getirmeye veya sıralamaya gerek yok.

unittestModülü kullanmak size temiz ve standart bir yaklaşım sağlar.

import unittest

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