Operazione di sottrazione dell'elenco Python

Voglio fare qualcosa di simile a questo:

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

Ma questo non è supportato dalle liste di Python Qual è il modo migliore per farlo?

Usa una comprensione dell'elenco:

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

Se vuoi usare la -sintassi infix, puoi semplicemente fare:

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

puoi quindi usarlo come:

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

Ma se non hai assolutamente bisogno delle proprietà dell'elenco (ad esempio, l'ordinamento), usa solo i set come le altre risposte raccomandano.

Usa la differenza impostata

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

Oppure potresti avere solo xey in modo da non dover fare alcuna conversione.

Questa è un'operazione "imposta sottrazione". Utilizzare la struttura di dati impostata per questo.

In Python 2.7:

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

Produzione:

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

se gli articoli duplicati e ordinati sono un problema:

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

Per molti casi d'uso, la risposta che desideri è:

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

Questo è un ibrido tra la risposta di aaronasterling e la risposta di quantumSoup .

La versione di aaronasterling len(y)confronta gli elementi per ogni elemento in x, quindi richiede un tempo quadratico. La versione di quantumSoup utilizza set, quindi esegue una singola ricerca di set a tempo costante per ogni elemento in x—ma, poiché converte entrambi x e yin set, perde l'ordine dei tuoi elementi.

Convertendo solo yin un set e ripetendo xin ordine, ottieni il meglio da entrambi i mondi: tempo lineare e conservazione dell'ordine. *

Tuttavia, questo ha ancora un problema dalla versione di quantumSoup: richiede che i tuoi elementi siano hash. È praticamente integrato nella natura dei set. ** Se stai provando, ad esempio, a sottrarre un elenco di dadi da un altro elenco di dadi, ma l'elenco da sottrarre è grande, cosa fai?

Se riesci a decorare i tuoi valori in qualche modo che sono hash, questo risolve il problema. Ad esempio, con un dizionario semplice i cui valori sono essi stessi cancellabili:

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

Se i tuoi tipi sono un po 'più complicati (ad esempio, spesso hai a che fare con valori compatibili con JSON, che sono hash, o elenchi o dicts i cui valori sono ricorsivamente dello stesso tipo), puoi comunque usare questa soluzione. Ma alcuni tipi non possono essere convertiti in nulla di hash.

Se i tuoi articoli non sono, e non possono essere realizzati, hash, ma sono comparabili, puoi almeno ottenere un tempo log-linear ( O(N*log M)che è molto meglio del O(N*M)tempo della soluzione dell'elenco, ma non buono come il O(N+M)tempo della soluzione impostata) ordinando e utilizzando 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)]

Se i tuoi articoli non sono né lavabili né confrontabili, allora sei bloccato con la soluzione quadratica.

_{* Nota che puoi anche farlo usando una coppia di OrderedSetoggetti, per i quali puoi trovare ricette e moduli di terze parti. Ma penso che sia più semplice.}

_{** Il motivo per cui le ricerche impostate sono a tempo costante è che tutto ciò che deve fare è hash il valore e vedere se c'è una voce per quell'hash. Se non è possibile eseguire l'hashing del valore, questo non funzionerà.}

Cercare i valori negli insiemi è più veloce che cercarli negli elenchi:

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

Credo che questo ridimensionerà leggermente meglio di:

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

Entrambi preservano l'ordine delle liste.

Se gli elenchi consentono elementi duplicati, puoi utilizzare Contatore dalle raccolte:

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

Se è necessario preservare l'ordine degli elementi da x:

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

Penso che il modo più semplice per raggiungere questo obiettivo sia usando 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]

Le altre soluzioni presentano uno dei pochi problemi:

1. Non preservano l'ordine, o
2. Non rimuovono un conteggio preciso di elementi, ad esempio per x = [1, 2, 2, 2]e y = [2, 2]si convertono yin a set, o rimuovono tutti gli elementi corrispondenti ( [1]solo lasciando ) o rimuovono uno di ciascun elemento unico (lasciando [1, 2, 2]), quando il comportamento corretto sarebbe rimuovere 2due volte, in partenza[1, 2] , o
3. Funzionano O(m * n), dove una soluzione ottimale può fare il O(m + n)lavoro

Alain era sulla buona stradaCounter per risolvere il n. 2 e il n. 3, ma quella soluzione perderà gli ordini. La soluzione che conserva l'ordine (rimuovendo le prime ncopie di ciascun valore per le nripetizioni listdei valori da rimuovere) è:

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.

Provalo online!

Per farlo rimuovere le ultime copie di ogni elemento, basta cambiare il forciclo in for val in reversed(x):e aggiungere out.reverse()immediatamente dopo essere usciti dal forciclo.

Costruendo il valore Counterè O(n)in termini di ylunghezza, l'iterazione xè O(n)in termini di xlunghezza e i Countertest di appartenenza e la mutazione sono O(1), mentre list.appendsono ammortizzati O(1)(un dato appendpuò essere O(n), ma per molti appendsecondi, le medie generali di O maggiore O(1)da sempre meno di questi richiede una riallocazione), quindi il lavoro complessivo svolto è O(m + n).

Puoi anche provare per determinare se c'erano elementi da ycui non sono stati rimossi dal xtest:

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

Prova questo.

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

La risposta fornita da @aaronasterling sembra buono, tuttavia, non è compatibile con l'interfaccia predefinita di lista: x = MyList(1, 2, 3, 4)vs x = MyList([1, 2, 3, 4]). Pertanto, il codice seguente può essere utilizzato come un più amichevole elenco Python:

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

Esempio:

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

Penso che questo sia più veloce:

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}

Questo esempio sottrae due elenchi:

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