Como comparar eficientemente duas listas não ordenadas (não conjuntos) em Python?

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

a & b deve ser considerado igual, porque eles têm exatamente os mesmos elementos, apenas em ordem diferente.

O problema é que minhas listas reais consistem em objetos (minhas instâncias de classe), não em números inteiros.

O (n) : O método Counter () é melhor (se seus objetos são hasháveis):

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

O (n log n) : O método classificado () é o próximo melhor (se seus objetos podem ser pedidos):

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

O (n * n) : se os objetos não forem hasháveis ​​nem ordenáveis, você poderá usar a igualdade:

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

Você pode classificar os dois:

sorted(a) == sorted(b)

Uma classificação de contagem também pode ser mais eficiente (mas exige que o objeto seja lavável).

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

Se você sabe que os itens são sempre laváveis, você pode usar um Counter()que é O (n)
Se você sabe que os itens são sempre ordenáveis, você pode usar o sorted()que é O (n log n)

No caso geral, você não pode confiar em poder classificar ou possui os elementos; portanto, você precisa de um fallback como esse, que infelizmente é O (n ^ 2)

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

A melhor maneira de fazer isso é ordenando as listas e comparando-as. (O uso Counternão funcionará com objetos que não são laváveis.) Isso é simples para números inteiros:

sorted(a) == sorted(b)

Fica um pouco mais complicado com objetos arbitrários. Se você se importa com a identidade do objeto, ou seja, se os mesmos objetos estão nas duas listas, você pode usar a id()função como chave de classificação.

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

(No Python 2.x, você realmente não precisa do key=parâmetro, porque é possível comparar qualquer objeto a qualquer objeto. A ordem é arbitrária, mas estável, portanto funciona bem para esse propósito; não importa em que ordem os objetos estejam. No entanto, no Python 3, comparar objetos de tipos diferentes não é permitido em muitas circunstâncias - por exemplo, você não pode comparar cadeias de caracteres com números inteiros - portanto, se você tiver objetos de vários tipos, melhor usar explicitamente o ID do objeto.)

Se você deseja comparar os objetos da lista por valor, por outro lado, primeiro precisa definir o que "valor" significa para os objetos. Então você precisará de alguma maneira de fornecer isso como uma chave (e para o Python 3, como um tipo consistente). Uma maneira potencial que funcionaria para muitos objetos arbitrários é classificar por eles repr(). Obviamente, isso poderia desperdiçar muito tempo extra e repr()seqüências de construção de memória para listas grandes e assim por diante.

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

Se os objetos são todos do seu próprio tipo, você pode defini __lt__()-los para que o objeto saiba como se comparar a outros. Então você pode apenas classificá-los e não se preocupar com o key=parâmetro. Claro que você também pode definir __hash__()e usar Counter, o que será mais rápido.

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

assertCountEqual (primeiro, segundo, msg = nenhum)

Teste essa sequência primeiro contém os mesmos elementos que o segundo, independentemente de sua ordem. Quando não o fizerem, uma mensagem de erro listando as diferenças entre as seqüências será gerada.

Elementos duplicados não são ignorados ao comparar o primeiro e o segundo. Ele verifica se cada elemento tem a mesma contagem nas duas seqüências. Equivalente a: assertEqual (Contador (lista (primeiro)), Contador (lista (segundo))), mas também trabalha com seqüências de objetos laváveis.

Novo na versão 3.2.

ou no 2.7: https://docs.python.org/2.7/library/unittest.html#unittest.TestCase.assertItemsEqual

Se a lista contiver itens que não são laváveis ​​(como uma lista de objetos), você poderá usar a Classe de Contador e a função id (), como:

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

Espero que o trecho de código abaixo possa funcionar no seu caso: -

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

Isso irá garantir que todos os elementos em ambas as listas ae bsão os mesmos, independentemente de se eles estão em mesma ordem ou não.

Para uma melhor compreensão, consulte a minha resposta nesta pergunta

Se a comparação for realizada em um contexto de teste, use assertCountEqual(a, b)( py>=3.2) e assertItemsEqual(a, b)( 2.7<=py<3.2).

Também funciona em seqüências de objetos unhashable.

Deixe as listas 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

Não há necessidade de torná-los laváveis ​​ou classificá-los.

O uso do unittestmódulo oferece uma abordagem limpa e padrão.

import unittest

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