Entfernen Sie alle Elemente, die in einer Liste vorkommen, aus einer anderen

Nehmen wir an, ich habe zwei Listen l1und l2. Ich möchte durchführen l1 - l2, was alle Elemente von l1nicht in zurückgibt l2.

Ich kann mir einen naiven Loop-Ansatz vorstellen, aber das wird wirklich ineffizient sein. Was ist eine pythonische und effiziente Methode, um dies zu tun?

Als Beispiel, wenn ich habe l1 = [1,2,6,8] and l2 = [2,3,5,8], l1 - l2sollte zurückkehren[1,6]

Python verfügt über eine Sprachfunktion namens List Comprehensions , die sich perfekt dafür eignet, solche Dinge extrem einfach zu machen. Die folgende Anweisung macht genau das, was Sie wollen, und speichert das Ergebnis in l3:

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

l3wird enthalten [1, 6].

Eine Möglichkeit besteht darin, Sets zu verwenden:

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

Als Alternative können Sie auch verwenden , filtermit dem Lambda - Ausdruck um das gewünschte Ergebnis zu erhalten. Zum Beispiel:

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

Leistungsvergleich

Hier vergleiche ich die Leistung aller hier genannten Antworten. Wie erwartet ist der set Betrieb von Arkku am schnellsten.

• Arkkus eingestellter Unterschied - Zuerst (0,124 usec pro Schleife)

  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
  

• Daniel Prydens Listenverständnis mit setNachschlagen - Zweiter (0,302 usec pro Schleife)

  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
  

• Donuts Listenverständnis auf einfacher Liste - Dritter (0,552 usec pro Schleife)

  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 verwendetfilter - Viertens (0,972 usec pro Schleife)

  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 verwendet eine Kombination von reduce+filter - Fünftel (3,97 usec pro Schleife)

  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 behält die Reihenfolge nicht bei und entfernt die doppelten Elemente aus der Liste. Verwenden Sie daher keine eingestellte Differenz, wenn Sie eine dieser benötigen.

Wenn Sie die Antwort von Donut und die anderen Antworten hier erweitern, können Sie noch bessere Ergebnisse erzielen, indem Sie ein Generatorverständnis anstelle eines Listenverständnisses und eine setDatenstruktur verwenden (da der inOperator O (n) in einer Liste ist, aber O (1). am Set).

Hier ist eine Funktion, die für Sie funktionieren würde:

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

Das Ergebnis ist eine Iterierbarkeit, die die gefilterte Liste träge abruft. Wenn Sie ein echtes Listenobjekt benötigen (z. B. wenn Sie len()das Ergebnis bearbeiten müssen ), können Sie ganz einfach eine Liste wie folgt erstellen:

filtered_list = list(filter_list(full_list, excludes))

Verwenden Sie den Python-Set-Typ. Das wäre das Pythonischste. :) :)

Da es nativ ist, sollte es auch die am besten optimierte Methode sein.

Sehen:

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

http://docs.python.org/library/sets.htm (für ältere 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

Verwenden Sie Set Comprehensions {x für x in l2} oder set (l2), um set zu erhalten, und verwenden Sie List Comprehensions , um die Liste abzurufen

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

Benchmark-Testcode:

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

Benchmark-Testergebnis:

0.0015058517456054688
3.968189239501953
speedup 2635.179227x    

Alternative Lösung:

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