Supprimer tous les éléments qui apparaissent dans une liste d'une autre

Disons que j'ai deux listes, l1et l2. Je veux effectuer l1 - l2, qui renvoie tous les éléments de l1pas dans l2.

Je peux penser à une approche en boucle naïve pour faire cela, mais cela va être vraiment inefficace. Qu'est-ce qu'un moyen pythonique et efficace de le faire?

Par exemple, si je dois l1 = [1,2,6,8] and l2 = [2,3,5,8], l1 - l2devrait revenir[1,6]

Python a une fonctionnalité de langage appelée List Comprehensions qui est parfaitement adaptée pour rendre ce genre de chose extrêmement facile. L'instruction suivante fait exactement ce que vous voulez et stocke le résultat dans l3:

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

l3contiendra [1, 6].

Une façon consiste à utiliser des ensembles:

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

Comme alternative, vous pouvez également utiliser filteravec l'expression lambda pour obtenir le résultat souhaité. Par exemple:

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

Comparaison des performances

Ici, je compare les performances de toutes les réponses mentionnées ici. Comme prévu, l' set opération basée sur Arkku est la plus rapide.

• Arkku's Set Difference - First (0,124 usec par boucle)

  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

• Compréhension de liste de Daniel Pryden avec setrecherche - Deuxième (0,302 usec par boucle)

  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

• Compréhension de la liste de Donut sur liste simple - Troisième (0,552 usec par boucle)

  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

• Utilisation de Moinuddin Quadrifilter - Quatrième (0,972 usec par boucle)

  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 utilise une combinaison de reduce+filter - Cinquième (3,97 usec par boucle)

  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 ne conserve pas l'ordre et supprime les éléments en double de la liste. Par conséquent, n'utilisez pas la différence définie si vous en avez besoin.

En développant la réponse de Donut et les autres réponses ici, vous pouvez obtenir des résultats encore meilleurs en utilisant une compréhension de générateur au lieu d'une compréhension de liste et en utilisant une setstructure de données (puisque lein opérateur est O (n) sur une liste mais O (1) sur un ensemble).

Voici donc une fonction qui fonctionnerait pour vous:

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

Le résultat sera un itérable qui récupérera paresseusement la liste filtrée. Si vous avez besoin d'un véritable objet liste (par exemple, si vous devez faire un len()résultat), vous pouvez facilement créer une liste comme ceci:

filtered_list = list(filter_list(full_list, excludes))

Utilisez le type d'ensemble Python. Ce serait le plus pythonique. :)

De plus, comme il est natif, il devrait également être la méthode la plus optimisée.

Voir:

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

http://docs.python.org/library/sets.htm (pour les anciens 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

utilisez Set Comprehensions {x pour x dans l2} ou set (l2) pour obtenir l'ensemble, puis utilisez List Comprehensions pour obtenir la liste

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

code de test de référence:

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

résultat du test de référence:

0.0015058517456054688
3.968189239501953
speedup 2635.179227x    

Solution alternative:

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