Come confrontare in modo efficiente due elenchi non ordinati (non set) in Python?

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

a & b devono essere considerati uguali, perché hanno esattamente gli stessi elementi, solo in ordine diverso.

Il fatto è che i miei elenchi effettivi saranno costituiti da oggetti (le mie istanze di classe), non da numeri interi.

O (n) : il metodo Counter () è il migliore (se i tuoi oggetti sono cancellabili):

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

O (n log n) : il metodo sort () è il migliore (se i tuoi oggetti sono ordinabili):

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

O (n * n) : se gli oggetti non sono né hash, né ordinabili, puoi usare l'uguaglianza:

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

Puoi ordinare entrambi:

sorted(a) == sorted(b)

UN ordinamento di conteggio potrebbe anche essere più efficiente (ma richiede che l'oggetto sia hash).

>>> 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 sai che gli oggetti sono sempre hash, puoi usare un Counter()che è O (n)
Se sai che gli oggetti sono sempre ordinabili, puoi usare sorted()che è O (n log n)

Nel caso generale non puoi fare affidamento sulla possibilità di ordinare o avere gli elementi, quindi hai bisogno di un fallback come questo, che purtroppo è O (n ^ 2)

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

Il modo migliore per farlo è ordinare gli elenchi e confrontarli. (L'uso Counternon funzionerà con oggetti non hash.) Questo è semplice per gli interi:

sorted(a) == sorted(b)

Diventa un po 'più complicato con oggetti arbitrari. Se ti interessa l'identità dell'oggetto, ovvero se gli stessi oggetti sono presenti in entrambi gli elenchi, puoi utilizzare la id()funzione come chiave di ordinamento.

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

(In Python 2.x non è effettivamente necessario key= parametro, perché puoi confrontare qualsiasi oggetto con qualsiasi oggetto. L'ordinamento è arbitrario ma stabile, quindi funziona bene per questo scopo; non importa quale ordine siano gli oggetti in, solo che l'ordinamento è lo stesso per entrambi gli elenchi. In Python 3, tuttavia, il confronto di oggetti di tipi diversi è vietato in molte circostanze - ad esempio, non è possibile confrontare stringhe con numeri interi - quindi se si avranno oggetti di vari tipi, meglio usare esplicitamente l'ID dell'oggetto.)

Se si desidera confrontare gli oggetti nell'elenco per valore, d'altra parte, è necessario innanzitutto definire cosa significa "valore" per gli oggetti. Quindi avrai bisogno di un modo per fornirlo come chiave (e per Python 3, come tipo coerente). Un modo potenziale che funzionerebbe per molti oggetti arbitrari è quello di ordinare in base al loro repr(). Ovviamente, ciò potrebbe far perdere molto tempo in più e repr()stringhe di costruzione della memoria per elenchi di grandi dimensioni e così via.

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

Se gli oggetti sono tutti i tuoi tipi, puoi definirli __lt__()in modo che l'oggetto sappia come confrontarsi con gli altri. Quindi puoi semplicemente ordinarli e non preoccuparti del key=parametro. Ovviamente potresti anche definire __hash__()e usareCounter , che sarà più veloce.

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

assertCountEqual (primo, secondo, msg = nessuno)

Prova prima che la sequenza contenga gli stessi elementi del secondo, indipendentemente dal loro ordine. In caso contrario, verrà generato un messaggio di errore che elenca le differenze tra le sequenze.

Gli elementi duplicati non vengono ignorati quando si confrontano il primo e il secondo. Verifica se ogni elemento ha lo stesso conteggio in entrambe le sequenze. Equivalente a: assertEqual (Counter (list (first)), Counter (list (second))) ma funziona anche con sequenze di oggetti non lavabili.

Novità nella versione 3.2.

o in 2.7: https://docs.python.org/2.7/library/unittest.html#unittest.TestCase.assertItemsEqual

Se l'elenco contiene elementi che non sono cancellabili (come un elenco di oggetti), potresti essere in grado di utilizzare la classe Counter e la funzione id () come:

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

Spero che il codice seguente possa funzionare nel tuo caso: -

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

Ciò garantirà che tutti gli elementi in entrambi gli elenchi ae bsiano uguali, indipendentemente dal fatto che siano nello stesso ordine o meno.

Per una migliore comprensione, fare riferimento alla mia risposta in questa domanda

Se il confronto deve essere eseguito in un contesto di test, utilizzare assertCountEqual(a, b)( py>=3.2) e assertItemsEqual(a, b)( 2.7<=py<3.2).

Funziona anche su sequenze di oggetti non lavabili.

Consenti alle liste 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

Non c'è bisogno di renderli hashing o ordinarli.

L'uso del unittestmodulo offre un approccio pulito e standard.

import unittest

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