Eliminar todos los elementos que ocurren en una lista de otra

Digamos que tengo dos listas, l1y l2. Quiero realizar l1 - l2, que devuelve todos los elementos de l1no en l2.

Puedo pensar en un enfoque de bucle ingenuo para hacer esto, pero eso será realmente ineficiente. ¿Cuál es una forma pitónica y eficiente de hacer esto?

Como ejemplo, si tengo l1 = [1,2,6,8] and l2 = [2,3,5,8], l1 - l2debería volver[1,6]

Python tiene una función de lenguaje llamada List Comprehensions que se adapta perfectamente para hacer que este tipo de cosas sea extremadamente fácil. La siguiente declaración hace exactamente lo que desea y almacena el resultado en l3:

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

l3contendrá [1, 6].

Una forma es usar conjuntos:

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

Como alternativa, también puede usar filtercon la expresión lambda para obtener el resultado deseado. Por ejemplo:

>>> 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]

Comparación de rendimiento

Aquí estoy comparando el rendimiento de todas las respuestas mencionadas aquí. Como se esperaba, la set operación basada en Arkku es más rápida.

• Diferencia establecida de Arkku - Primero (0.124 usec por ciclo)

  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
  

• Lista Comprensión de Daniel Pryden con setbúsqueda - Segundo (0.302 usec por 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
  

• Lista de donas Comprensión en lista simple - Tercero (0.552 usec por 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
  

• Moinuddin Quadri's usandofilter - Cuarto (0.972 usec por ciclo)

  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 está usando la combinación de reduce+filter - Quinto (3.97 usec por ciclo)

  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
  

PD: set no mantiene el orden y elimina los elementos duplicados de la lista. Por lo tanto, no use la diferencia establecida si necesita alguno de estos.

Ampliando la respuesta de Donut y las otras respuestas aquí, puede obtener mejores resultados utilizando una comprensión de generador en lugar de una comprensión de lista, y utilizando una setestructura de datos (ya que el inoperador es O (n) en una lista pero O (1) en un set).

Así que aquí hay una función que funcionaría para usted:

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

El resultado será un iterable que va a buscar perezosamente la lista filtrada. Si necesita un objeto de lista real (por ejemplo, si necesita hacer un a len()en el resultado), puede crear fácilmente una lista como esta:

filtered_list = list(filter_list(full_list, excludes))

Use el tipo de conjunto Python. Eso sería lo más pitónico. :)

Además, como es nativo, también debería ser el método más optimizado.

Ver:

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

http://docs.python.org/library/sets.htm (para python anterior)

# 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

use Set Comprehensions {x para x en l2} o set (l2) para configurar, luego use List Comprehensions para obtener la lista

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

código de prueba de referencia:

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))

resultado de la prueba de referencia:

0.0015058517456054688
3.968189239501953
speedup 2635.179227x    

Solución alternativa

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