Remova todos os elementos que ocorrem em uma lista da outra

Digamos que eu tenho duas listas l1e l2. Eu quero executar l1 - l2, que retorna todos os elementos de l1não dentro l2.

Posso pensar em uma abordagem de loop ingênuo para fazer isso, mas isso será realmente ineficiente. O que é uma maneira pitônica e eficiente de fazer isso?

Como exemplo, se eu tiver l1 = [1,2,6,8] and l2 = [2,3,5,8], l1 - l2deve retornar[1,6]

O Python possui um recurso de linguagem chamado List Comprehensions, perfeitamente adequado para tornar esse tipo de coisa extremamente fácil. A declaração a seguir faz exatamente o que você deseja e armazena o resultado l3:

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

l3irá conter [1, 6].

Uma maneira é usar conjuntos:

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

Como alternativa, você também pode usar filtercom a expressão lambda para obter o resultado desejado. Por exemplo:

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

Comparação de desempenho

Aqui estou comparando o desempenho de todas as respostas mencionadas aqui. Como esperado, a set operação baseada em Arkku é mais rápida.

• Diferença de conjunto de Arkku - primeiro (0,124 usec por 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
  

• Compreensão da lista de Daniel Pryden com setpesquisa - segundo (0,302 usec por loop)

  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
  

• Compreensão da lista de rosquinhas na lista simples - Terceira (0,552 usec por loop)

  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
  

• O uso defilter Moinuddin Quadri - Quarto (0,972 usec por 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 usando a combinação de reduce+filter - Quinto (3,97 usec por 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 não mantém a ordem e remove os elementos duplicados da lista. Portanto, não use diferença definida se precisar de alguma dessas opções .

Expandindo a resposta de Donut e as outras respostas aqui, você pode obter resultados ainda melhores usando uma compreensão de gerador em vez de uma compreensão de lista e usando uma setestrutura de dados (já que o inoperador é O (n) em uma lista, mas O (1) em um conjunto).

Então, aqui está uma função que funcionaria para você:

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

O resultado será um iterável que buscará preguiçosamente a lista filtrada. Se você precisar de um objeto de lista real (por exemplo, se precisar fazer uma avaliação len()do resultado), poderá criar facilmente uma lista como esta:

filtered_list = list(filter_list(full_list, excludes))

Use o tipo de conjunto Python. Isso seria o mais pitonico. :)

Além disso, como é nativo, também deve ser o método mais otimizado.

Vejo:

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

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

# 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 em l2} ou set (l2) para definir, depois use List Comprehensions para obter list

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

código de teste de referência:

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 do teste de benchmark:

0.0015058517456054688
3.968189239501953
speedup 2635.179227x    

Solução alternativa:

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