Rimuovere tutti gli elementi presenti in un elenco da un altro

Diciamo che ho due liste l1e l2. Voglio esibirmi l1 - l2, che restituisce tutti gli elementi di l1non in l2.

Mi viene in mente un approccio a ciclo ingenuo per farlo, ma sarà davvero inefficiente. Qual è un modo pitonico ed efficace per farlo?

Ad esempio, se ho l1 = [1,2,6,8] and l2 = [2,3,5,8], l1 - l2dovrebbe tornare[1,6]

Python ha una funzione linguistica chiamata Comprensione delle liste che si adatta perfettamente a rendere questo genere di cose estremamente semplice. La seguente dichiarazione fa esattamente quello che vuoi e memorizza il risultato in l3:

l3 = [x for x in l1 if x not in l2]

l3conterrà [1, 6].

Un modo è usare i set:

>>> set([1,2,6,8]) - set([2,3,5,8])
set([1, 6])

In alternativa, puoi anche usare filterl'espressione lambda per ottenere il risultato desiderato. Per esempio:

>>> l1 = [1,2,6,8]
>>> l2 = set([2,3,5,8])

#     v  `filter` returns the a iterator object. Here I'm type-casting 
#     v  it to `list` in order to display the resultant value
>>> list(filter(lambda x: x not in l2, l1))
[1, 6]

Confronto delle prestazioni

Qui sto confrontando le prestazioni di tutte le risposte menzionate qui. Come previsto, l' set operazione basata su Arkku è la più veloce.

• Arkku's Set Difference - First (0.124 usec per loop)

  mquadri$ python -m timeit -s "l1 = set([1,2,6,8]); l2 = set([2,3,5,8]);" "l1 - l2"
  10000000 loops, best of 3: 0.124 usec per loop

• Comprensione dell'elenco di Daniel Pryden con setricerca - Secondo (0,302 usec per ciclo)

  mquadri$ python -m timeit -s "l1 = [1,2,6,8]; l2 = set([2,3,5,8]);" "[x for x in l1 if x not in l2]"
  1000000 loops, best of 3: 0.302 usec per loop

• Comprensione dell'elenco di ciambelle su un elenco semplice - Terzo (0,552 usec per ciclo)

  mquadri$ python -m timeit -s "l1 = [1,2,6,8]; l2 = [2,3,5,8];" "[x for x in l1 if x not in l2]"
  1000000 loops, best of 3: 0.552 usec per loop

• L'utilizzo di Moinuddin Quadrifilter - Quarto (0,972 usec per loop)

  mquadri$ python -m timeit -s "l1 = [1,2,6,8]; l2 = set([2,3,5,8]);" "filter(lambda x: x not in l2, l1)"
  1000000 loops, best of 3: 0.972 usec per loop

• Akshay Hazari utilizza la combinazione di reduce+filter - Fifth (3.97 usec per loop)

  mquadri$ python -m timeit "l1 = [1,2,6,8]; l2 = [2,3,5,8];" "reduce(lambda x,y : filter(lambda z: z!=y,x) ,l1,l2)"
  100000 loops, best of 3: 3.97 usec per loop

PS: set non mantiene l'ordine e rimuove gli elementi duplicati dall'elenco. Quindi, non usare la differenza impostata se ne hai bisogno.

Espandendo la risposta di Donut e le altre risposte qui, puoi ottenere risultati ancora migliori utilizzando una comprensione del generatore anziché una comprensione dell'elenco e utilizzando una setstruttura di dati (poiché l' inoperatore è O (n) in un elenco ma O (1) su un set).

Quindi, ecco una funzione che funzionerebbe per te:

def filter_list(full_list, excludes):
    s = set(excludes)
    return (x for x in full_list if x not in s)

Il risultato sarà un iterabile che recupererà pigramente l'elenco filtrato. Se hai bisogno di un vero oggetto elenco (ad esempio se devi fare un len()risultato), puoi facilmente creare un elenco in questo modo:

filtered_list = list(filter_list(full_list, excludes))

Usa il tipo di set Python. Sarebbe il più Pythonic. :)

Inoltre, poiché è nativo, dovrebbe essere anche il metodo più ottimizzato.

Vedere:

http://docs.python.org/library/stdtypes.html#set

http://docs.python.org/library/sets.htm (per i vecchi python)

# Using Python 2.7 set literal format.
# Otherwise, use: l1 = set([1,2,6,8])
#
l1 = {1,2,6,8}
l2 = {2,3,5,8}
l3 = l1 - l2

usa Imposta comprensioni {x per x in l2} o imposta (l2) per ottenere l'impostazione, quindi usa Elenco comprensioni per ottenere l'elenco

l2set = set(l2)
l3 = [x for x in l1 if x not in l2set]

codice test benchmark:

import time

l1 = list(range(1000*10 * 3))
l2 = list(range(1000*10 * 2))

l2set = {x for x in l2}

tic = time.time()
l3 = [x for x in l1 if x not in l2set]
toc = time.time()
diffset = toc-tic
print(diffset)

tic = time.time()
l3 = [x for x in l1 if x not in l2]
toc = time.time()
difflist = toc-tic
print(difflist)

print("speedup %fx"%(difflist/diffset))

risultato del test benchmark:

0.0015058517456054688
3.968189239501953
speedup 2635.179227x    

Soluzione alternativa:

reduce(lambda x,y : filter(lambda z: z!=y,x) ,[2,3,5,8],[1,2,6,8])