Verifica se gli elenchi condividono elementi in Python

Voglio verificare se uno degli elementi in un elenco è presente in un altro elenco. Posso farlo semplicemente con il codice qui sotto, ma sospetto che potrebbe esserci una funzione di libreria per farlo. In caso contrario, esiste un metodo più pitonico per ottenere lo stesso risultato.

In [78]: a = [1, 2, 3, 4, 5]

In [79]: b = [8, 7, 6]

In [80]: c = [8, 7, 6, 5]

In [81]: def lists_overlap(a, b):
   ....:     for i in a:
   ....:         if i in b:
   ....:             return True
   ....:     return False
   ....: 

In [82]: lists_overlap(a, b)
Out[82]: False

In [83]: lists_overlap(a, c)
Out[83]: True

In [84]: def lists_overlap2(a, b):
   ....:     return len(set(a).intersection(set(b))) > 0
   ....: 

Risposta breve : usare not set(a).isdisjoint(b), è generalmente il più veloce.

Esistono quattro modi comuni per verificare se due elenchi ae bcondividere elementi. La prima opzione è convertire entrambi in set e controllare la loro intersezione, come tale:

bool(set(a) & set(b))

Poiché i set vengono archiviati utilizzando una tabella hash in Python, la ricerca èO(1) (vedere qui per ulteriori informazioni sulla complessità degli operatori in Python). Teoricamente, questo è O(n+m)in media per ne moggetti negli elenchi ae b. Ma 1) deve prima creare serie fuori dagli elenchi, il che può richiedere una quantità non trascurabile di tempo, e 2) supporre che le collisioni di hashing siano sparse tra i tuoi dati.

Il secondo modo per farlo è usare un'espressione del generatore che esegue l'iterazione sugli elenchi, come ad esempio:

any(i in a for i in b)

Ciò consente la ricerca sul posto, quindi non viene allocata nuova memoria per le variabili intermedie. Si salva anche alla prima scoperta. Ma l' inoperatore è sempre O(n)in lista (vedi qui ).

Un'altra opzione proposta è un ibrido per scorrere l'elenco, convertire l'altro in un set e testare l'appartenenza a questo set, in questo modo:

a = set(a); any(i in a for i in b)

Un quarto approccio consiste nell'utilizzare il isdisjoint()metodo degli insiemi (congelati) (vedere qui ), ad esempio:

not set(a).isdisjoint(b)

Se gli elementi ricercati sono vicini all'inizio di un array (ad es. È ordinato), viene favorita l'espressione del generatore, poiché il metodo di intersezione insiemi deve allocare nuova memoria per le variabili intermedie:

from timeit import timeit
>>> timeit('bool(set(a) & set(b))', setup="a=list(range(1000));b=list(range(1000))", number=100000)
26.077727576019242
>>> timeit('any(i in a for i in b)', setup="a=list(range(1000));b=list(range(1000))", number=100000)
0.16220548999262974

Ecco un grafico del tempo di esecuzione per questo esempio in funzione della dimensione dell'elenco:

Si noti che entrambi gli assi sono logaritmici. Questo rappresenta il caso migliore per l'espressione del generatore. Come si può vedere, ilisdisjoint() metodo è migliore per dimensioni di elenco molto piccole, mentre l'espressione del generatore è migliore per dimensioni di elenco più grandi.

D'altra parte, poiché la ricerca inizia con l'inizio dell'espressione ibrida e del generatore, se l'elemento condiviso è sistematicamente alla fine dell'array (o entrambi gli elenchi non condividono alcun valore), gli approcci di intersezione disgiunti e impostati sono quindi molto più veloce dell'espressione del generatore e dell'approccio ibrido.

>>> timeit('any(i in a for i in b)', setup="a=list(range(1000));b=[x+998 for x in range(999,0,-1)]", number=1000))
13.739536046981812
>>> timeit('bool(set(a) & set(b))', setup="a=list(range(1000));b=[x+998 for x in range(999,0,-1)]", number=1000))
0.08102107048034668

È interessante notare che l'espressione del generatore è molto più lenta per elenchi di dimensioni maggiori. Questo è solo per 1000 ripetizioni, anziché 100000 per la figura precedente. Questa impostazione si avvicina bene anche quando non sono condivisi elementi ed è il caso migliore per gli approcci di intersezione disgiunti e impostati.

Ecco due analisi usando numeri casuali (invece di attrezzare l'installazione per favorire una tecnica o un'altra):

Elevata possibilità di condivisione: gli elementi vengono presi casualmente [1, 2*len(a)] . Bassa possibilità di condivisione: gli elementi vengono presi casualmente[1, 1000*len(a)] .

Fino ad ora, questa analisi supponeva che entrambe le liste avessero le stesse dimensioni. Nel caso di due elenchi di dimensioni diverse, ad esempio aè molto più piccolo, isdisjoint()è sempre più veloce:

Assicurarsi che l' aelenco sia più piccolo, altrimenti le prestazioni diminuiscono. In questo esperimento, la adimensione dell'elenco è stata impostata su costante5 .

In sintesi:

• Se gli elenchi sono molto piccoli (<10 elementi), not set(a).isdisjoint(b) è sempre il più veloce.
• Se gli elementi negli elenchi sono ordinati o hanno una struttura regolare di cui puoi trarre vantaggio, l'espressione del generatore any(i in a for i in b) è la più veloce su elenchi di grandi dimensioni;
• Prova l'intersezione impostata con not set(a).isdisjoint(b), che è sempre più veloce dibool(set(a) & set(b)) .
• L'ibrido "scorre attraverso l'elenco, prova sul set" a = set(a); any(i in a for i in b) è generalmente più lento di altri metodi.
• L'espressione del generatore e l'ibrido sono molto più lenti rispetto agli altri due approcci quando si tratta di elenchi senza condividere elementi.

Nella maggior parte dei casi, l'utilizzo del isdisjoint()metodo è l'approccio migliore in quanto l'esecuzione del generatore richiederà molto più tempo per l'esecuzione, poiché è molto inefficiente quando non sono condivisi elementi.

def lists_overlap3(a, b):
    return bool(set(a) & set(b))

Nota: quanto sopra presuppone che si desideri un valore booleano come risposta. Se tutto ciò che serve è un'espressione da usare in ifun'istruzione, basta usareif set(a) & set(b):

def lists_overlap(a, b):
  sb = set(b)
  return any(el in sb for el in a)

Questo è asintoticamente ottimale (caso peggiore O (n + m)) e potrebbe essere migliore dell'approccio intersezione a causa di any del cortocircuito.

Per esempio:

lists_overlap([3,4,5], [1,2,3])

restituirà True non appena arriverà 3 in sb

EDIT: Un'altra variante (grazie a Dave Kirby):

def lists_overlap(a, b):
  sb = set(b)
  return any(itertools.imap(sb.__contains__, a))

Questo si basa imapsull'iteratore, che è implementato in C, piuttosto che sulla comprensione di un generatore. Utilizza anche sb.__contains__come funzione di mappatura. Non so quanta differenza prestazionale ciò comporti. Continuerà a cortocircuitare.

È inoltre possibile utilizzare anycon la comprensione dell'elenco:

any([item in a for item in b])

In Python 2.6 o versioni successive puoi fare:

return not frozenset(a).isdisjoint(frozenset(b))

È possibile utilizzare qualsiasi espressione del generatore di funzioni / wa incorporata:

def list_overlap(a,b): 
     return any(i for i in a if i in b)

Come hanno sottolineato John e Lie, questo dà risultati errati quando per ogni i condiviso dalle due liste bool (i) == False. Dovrebbe essere:

return any(i in b for i in a)

Questa domanda è piuttosto vecchia, ma ho notato che mentre le persone discutevano set contro liste, nessuno pensava di usarle insieme. Seguendo l'esempio di Soravux,

Peggior caso per le liste:

>>> timeit('bool(set(a) & set(b))',  setup="a=list(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
100.91506409645081
>>> timeit('any(i in a for i in b)', setup="a=list(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
19.746716022491455
>>> timeit('any(i in a for i in b)', setup="a= set(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
0.092626094818115234

E il caso migliore per gli elenchi:

>>> timeit('bool(set(a) & set(b))',  setup="a=list(range(10000)); b=list(range(10000))", number=100000)
154.69790101051331
>>> timeit('any(i in a for i in b)', setup="a=list(range(10000)); b=list(range(10000))", number=100000)
0.082653045654296875
>>> timeit('any(i in a for i in b)', setup="a= set(range(10000)); b=list(range(10000))", number=100000)
0.08434605598449707

Quindi, anche più veloce dell'iterazione attraverso due elenchi, è l'iterazione di un elenco per vedere se si trova in un set, il che ha senso dal momento che il controllo se un numero è in un set richiede tempo costante mentre il controllo iterando attraverso un elenco richiede tempo proporzionale alla lunghezza di la lista.

Pertanto, la mia conclusione è che scorre attraverso un elenco e controlla se si trova in un set .

se non ti interessa quale potrebbe essere l'elemento sovrapposto, puoi semplicemente controllare l' lenelenco combinato rispetto agli elenchi combinati come set. Se ci sono elementi sovrapposti, l'insieme sarà più corto:

len(set(a+b+c))==len(a+b+c) ritorna True, se non c'è sovrapposizione.

Ne lancerò un altro con uno stile di programmazione funzionale:

any(map(lambda x: x in a, b))

Spiegazione:

map(lambda x: x in a, b)

restituisce un elenco di valori booleani in cui bsi trovano gli elementi di a. Tale elenco viene quindi passato a any, che restituisce semplicemente Truese ci sono elementi True.