Python-Listensubtraktionsoperation

Ich möchte etwas Ähnliches tun:

>>> x = [1,2,3,4,5,6,7,8,9,0]  
>>> x  
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]  
>>> y = [1,3,5,7,9]  
>>> y  
[1, 3, 5, 7, 9]  
>>> y - x   # (should return [2,4,6,8,0])

Dies wird jedoch von Python-Listen nicht unterstützt. Wie geht das am besten?

Verwenden Sie ein Listenverständnis:

[item for item in x if item not in y]

Wenn Sie die -Infix-Syntax verwenden möchten , können Sie einfach Folgendes tun:

class MyList(list):
    def __init__(self, *args):
        super(MyList, self).__init__(args)

    def __sub__(self, other):
        return self.__class__(*[item for item in self if item not in other])

Sie können es dann wie folgt verwenden:

x = MyList(1, 2, 3, 4)
y = MyList(2, 5, 2)
z = x - y   

Wenn Sie jedoch keine Listeneigenschaften benötigen (z. B. Reihenfolge), verwenden Sie einfach Sets, wie in den anderen Antworten empfohlen.

Verwenden Sie die eingestellte Differenz

>>> z = list(set(x) - set(y))
>>> z
[0, 8, 2, 4, 6]

Oder Sie müssen nur x und y setzen, damit Sie keine Konvertierungen vornehmen müssen.

Das ist eine "Set-Subtraktions" -Operation. Verwenden Sie dazu die eingestellte Datenstruktur.

In Python 2.7:

x = {1,2,3,4,5,6,7,8,9,0}
y = {1,3,5,7,9}
print x - y

Ausgabe:

>>> print x - y
set([0, 8, 2, 4, 6])

Wenn doppelte und bestellte Artikel ein Problem sind:

[i for i in a if not i in b or b.remove(i)]

a = [1,2,3,3,3,3,4]
b = [1,3]
result: [2, 3, 3, 3, 4]

Für viele Anwendungsfälle lautet die gewünschte Antwort:

ys = set(y)
[item for item in x if item not in ys]

Dies ist ein Hybrid zwischen aaronasterling Antwort und quantumSoup Antwort .

Die Version von aaronasterling führt Elementvergleiche len(y)für jedes Element in durch x, daher dauert es quadratisch. In der Version von quantumSoup werden Mengen verwendet, sodass für jedes Element in eine einzelne Mengen-Suche mit konstanter Zeit durchgeführt xwird. Da jedoch beide x und yin Mengen konvertiert werden, verliert sie die Reihenfolge Ihrer Elemente.

Wenn Sie nur yin eine Menge konvertieren und in der richtigen xReihenfolge iterieren , erhalten Sie das Beste aus beiden Welten - lineare Zeit und Ordnungserhaltung. *

Dies hat jedoch immer noch ein Problem mit der Version von quantumSoup: Es erfordert, dass Ihre Elemente hashbar sind. Das ist so ziemlich in die Natur von Mengen eingebaut. ** Wenn Sie beispielsweise versuchen, eine Liste von Diktaten von einer anderen Liste von Diktaten zu subtrahieren, die zu subtrahierende Liste jedoch groß ist, was tun Sie dann?

Wenn Sie Ihre Werte so dekorieren können, dass sie hashbar sind, löst dies das Problem. Zum Beispiel mit einem flachen Wörterbuch, dessen Werte selbst hashbar sind:

ys = {tuple(item.items()) for item in y}
[item for item in x if tuple(item.items()) not in ys]

Wenn Ihre Typen etwas komplizierter sind (z. B. häufig mit JSON-kompatiblen Werten, die hashbar sind, oder Listen oder Diktaten, deren Werte rekursiv vom gleichen Typ sind), können Sie diese Lösung weiterhin verwenden. Einige Typen können jedoch nicht in etwas Hashbares konvertiert werden.

Wenn Ihre Elemente nicht hashbar sind und nicht erstellt werden können, aber vergleichbar sind, können Sie zumindest eine logarithmisch lineare Zeit erhalten ( O(N*log M)die viel besser ist als die O(N*M)Zeit der Listenlösung , aber nicht so gut wie) die O(N+M)Zeit der eingestellten Lösung) durch Sortieren und Verwenden von bisect:

ys = sorted(y)
def bisect_contains(seq, item):
    index = bisect.bisect(seq, item)
    return index < len(seq) and seq[index] == item
[item for item in x if bisect_contains(ys, item)]

Wenn Ihre Artikel weder hashbar noch vergleichbar sind, bleiben Sie bei der quadratischen Lösung.

_{* Beachten Sie, dass Sie dies auch tun können, indem Sie ein Objektpaar verwenden OrderedSet, für das Sie Rezepte und Module von Drittanbietern finden. Aber ich denke das ist einfacher.}

_{** Der Grund, warum Set-Lookups eine konstante Zeit sind, ist, dass sie nur den Wert hashen und prüfen müssen, ob es einen Eintrag für diesen Hash gibt. Wenn der Wert nicht gehasht werden kann, funktioniert dies nicht.}

Das Nachschlagen von Werten in Sätzen ist schneller als das Nachschlagen in Listen:

[item for item in x if item not in set(y)]

Ich glaube, das wird etwas besser skalieren als:

[item for item in x if item not in y]

Beide behalten die Reihenfolge der Listen bei.

Wenn die Listen doppelte Elemente zulassen, können Sie Zähler aus Sammlungen verwenden:

from collections import Counter
result = list((Counter(x)-Counter(y)).elements())

Wenn Sie die Reihenfolge der Elemente von x beibehalten müssen:

result = [ v for c in [Counter(y)] for v in x if not c[v] or c.subtract([v]) ]

Die anderen Lösungen haben eines der wenigen Probleme:

1. Sie bewahren keine Ordnung oder
2. Sie entfernen keine genaue Anzahl von Elementen, z. B. für x = [1, 2, 2, 2]und y = [2, 2]konvertieren yin a set, und entfernen entweder alle übereinstimmenden Elemente ( [1]nur verlassen) oder entfernen jedes einzelne eindeutige Element (verlassen [1, 2, 2]), wenn das richtige Verhalten darin besteht, 2zweimal zu entfernen . verlassen [1, 2], oder
3. Sie O(m * n)arbeiten dort, wo eine optimale Lösung O(m + n)funktionieren kann

Alain war auf dem richtigen WegCounter , um # 2 und # 3 zu lösen, aber diese Lösung wird die Bestellung verlieren. Die Lösung, die die Reihenfolge beibehält (Entfernen der ersten nKopien jedes Werts für nWiederholungen in den listzu entfernenden Werten), lautet:

from collections import Counter

x = [1,2,3,4,3,2,1]  
y = [1,2,2]  
remaining = Counter(y)

out = []
for val in x:
    if remaining[val]:
        remaining[val] -= 1
    else:
        out.append(val)
# out is now [3, 4, 3, 1], having removed the first 1 and both 2s.

Probieren Sie es online aus!

Um die letzten Kopien jedes Elements zu entfernen , ändern Sie einfach die forSchleife in for val in reversed(x):und fügen Sie sie out.reverse()unmittelbar nach dem Verlassen der forSchleife hinzu.

Die Konstruktion der Countersich O(n)in Bezug auf die y‚s Länge, Iterieren xist O(n)in Bezug auf die x‘ s Länge und CounterMitgliedschaft Tests und Mutation sind O(1), während list.appendabgeschrieben O(1)(a gegeben appendsein kann O(n), aber für viele appends, die Gesamt Big-O mittelt , O(1)da immer weniger von ihnen erfordern eine Neuzuweisung), so dass die Gesamtarbeit erledigt ist O(m + n).

Sie können auch testen, ob Elemente darin enthalten sind y, die nicht xdurch Testen entfernt wurden:

remaining = +remaining  # Removes all keys with zero counts from Counter
if remaining:
    # remaining contained elements with non-zero counts

Versuche dies.

def subtract_lists(a, b):
    """ Subtracts two lists. Throws ValueError if b contains items not in a """
    # Terminate if b is empty, otherwise remove b[0] from a and recurse
    return a if len(b) == 0 else [a[:i] + subtract_lists(a[i+1:], b[1:]) 
                                  for i in [a.index(b[0])]][0]

>>> x = [1,2,3,4,5,6,7,8,9,0]
>>> y = [1,3,5,7,9]
>>> subtract_lists(x,y)
[2, 4, 6, 8, 0]
>>> x = [1,2,3,4,5,6,7,8,9,0,9]
>>> subtract_lists(x,y)
[2, 4, 6, 8, 0, 9]     #9 is only deleted once
>>>

Ich denke, der einfachste Weg, dies zu erreichen, ist die Verwendung von set ().

>>> x = [1,2,3,4,5,6,7,8,9,0]  
>>> y = [1,3,5,7,9]  
>>> list(set(x)- set(y))
[0, 2, 4, 6, 8]

Die Antwort , die von gut aussieht @aaronasterling, ist es jedoch nicht mit der Standardoberfläche von Liste kompatibel: x = MyList(1, 2, 3, 4)vs x = MyList([1, 2, 3, 4]). Daher kann der folgende Code als Python-Listen-freundlicher verwendet werden:

class MyList(list):
    def __init__(self, *args):
        super(MyList, self).__init__(*args)

    def __sub__(self, other):
        return self.__class__([item for item in self if item not in other])

Beispiel:

x = MyList([1, 2, 3, 4])
y = MyList([2, 5, 2])
z = x - y

Ich denke das geht schneller:

In [1]: a = [1,2,3,4,5]

In [2]: b = [2,3,4,5]

In [3]: c = set(a) ^ set(b)

In [4]: c
Out[4]: {1}

In diesem Beispiel werden zwei Listen abgezogen:

# List of pairs of points
list = []
list.append([(602, 336), (624, 365)])
list.append([(635, 336), (654, 365)])
list.append([(642, 342), (648, 358)])
list.append([(644, 344), (646, 356)])
list.append([(653, 337), (671, 365)])
list.append([(728, 13), (739, 32)])
list.append([(756, 59), (767, 79)])

itens_to_remove = []
itens_to_remove.append([(642, 342), (648, 358)])
itens_to_remove.append([(644, 344), (646, 356)])

print("Initial List Size: ", len(list))

for a in itens_to_remove:
    for b in list:
        if a == b :
            list.remove(b)

print("Final List Size: ", len(list))