Opération de soustraction de liste Python

Je veux faire quelque chose de similaire à ceci:

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

Mais cela n'est pas pris en charge par les listes python Quelle est la meilleure façon de le faire?

Utilisez une compréhension de liste:

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

Si vous souhaitez utiliser la -syntaxe infixe, vous pouvez simplement faire:

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

vous pouvez ensuite l'utiliser comme:

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

Mais si vous n'avez pas absolument besoin des propriétés de liste (par exemple, la commande), utilisez simplement des ensembles comme les autres réponses le recommandent.

Utiliser la différence définie

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

Ou vous pouvez simplement avoir des ensembles x et y afin de ne pas avoir à faire de conversions.

Il s'agit d'une opération de "soustraction d'ensemble". Utilisez la structure de données définie pour cela.

En Python 2.7:

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

Production:

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

si les articles en double et les commandes posent problème:

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

Pour de nombreux cas d'utilisation, la réponse que vous souhaitez est:

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

Il s'agit d'un hybride entre la réponse d' Aaronasterling et la réponse de QuantumSoup .

La version de aaronasterling fait des len(y)comparaisons d'éléments pour chaque élément dans x, donc cela prend du temps quadratique. La version de quantumSoup utilise des ensembles, elle effectue donc une seule recherche d'ensemble à temps constant pour chaque élément dans x- mais, comme elle convertit les deux x et yen ensembles, elle perd l'ordre de vos éléments.

En convertissant uniquement yen un ensemble et en itérant xdans l'ordre, vous obtenez le meilleur des deux mondes: le temps linéaire et la préservation de l'ordre. *

Cependant, cela a toujours un problème avec la version de quantumSoup: cela nécessite que vos éléments soient lavables. C'est à peu près intégré dans la nature des ensembles. ** Si vous essayez, par exemple, de soustraire une liste de dict d'une autre liste de dict, mais que la liste à soustraire est grande, que faites-vous?

Si vous pouvez décorer vos valeurs de manière à ce qu'elles soient lavables, cela résout le problème. Par exemple, avec un dictionnaire plat dont les valeurs sont elles-mêmes hachables:

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

Si vos types sont un peu plus compliqués (par exemple, vous avez souvent affaire à des valeurs compatibles JSON, qui sont hachables, ou à des listes ou des codes dont les valeurs sont récursivement du même type), vous pouvez toujours utiliser cette solution. Mais certains types ne peuvent tout simplement pas être convertis en quelque chose de lavable.

Si vos articles ne sont pas, et ne peuvent pas être, lavables, mais ils sont comparables, vous pouvez au moins obtenir un temps log-linéaire ( O(N*log M), ce qui est beaucoup mieux que le O(N*M)temps de la solution de liste, mais pas aussi bon que le O(N+M)temps de la solution réglée) en triant et en utilisant 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)]

Si vos articles ne sont ni lavables ni comparables, alors vous êtes coincé avec la solution quadratique.

_{* Notez que vous pouvez également le faire en utilisant une paire d' OrderedSetobjets, pour laquelle vous pouvez trouver des recettes et des modules tiers. Mais je pense que c'est plus simple.}

_{** La raison pour laquelle les recherches définies sont à temps constant est qu'il suffit de hacher la valeur et de voir s'il existe une entrée pour ce hachage. S'il ne peut pas hacher la valeur, cela ne fonctionnera pas.}

La recherche de valeurs dans des ensembles est plus rapide que leur recherche dans des listes:

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

Je pense que cela évoluera légèrement mieux que:

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

Les deux préservent l'ordre des listes.

Si les listes autorisent les éléments en double, vous pouvez utiliser Counter à partir de collections:

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

Si vous devez conserver l'ordre des éléments de x:

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

Je pense que la façon la plus simple d'y parvenir est d'utiliser 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]

Les autres solutions ont l'un des problèmes suivants:

1. Ils ne préservent pas l'ordre, ou
2. Ils ne suppriment pas un nombre précis d'éléments, par exemple pour x = [1, 2, 2, 2]et y = [2, 2]ils se convertissent yen a set, et suppriment tous les éléments correspondants (en laissant [1]uniquement) ou en supprimant un de chaque élément unique (en partant [1, 2, 2]), lorsque le comportement correct consiste à supprimer 2deux fois, partir [1, 2], ou
3. Ils O(m * n)fonctionnent, où une solution optimale peut O(m + n)fonctionner

Alain était sur la bonne voieCounter pour résoudre les problèmes n ° 2 et n ° 3, mais cette solution perdra son ordre. La solution qui préserve l'ordre (en supprimant les premières ncopies de chaque valeur pour les nrépétitions dans les listvaleurs à supprimer) est:

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.

Essayez-le en ligne!

Pour lui faire supprimer les dernières copies de chaque élément, changez simplement la forboucle en for val in reversed(x):et ajoutez out.reverse()immédiatement après avoir quitté la forboucle.

La construction de l' Counterest O(n)en termes de y« lien de, itérer xest O(n)en termes de x» longueur s, et les Countertests d'adhésion et de mutation sont O(1), tout list.appendest amorti O(1)(une donnée appendpeut être O(n), mais pour beaucoup de appends, les moyennes Big-O global O(1)depuis moins en moins d'entre eux nécessitent une réaffectation), de sorte que le travail global effectué l'est O(m + n).

Vous pouvez également tester pour déterminer s'il y avait des éléments yqui n'ont pas été supprimés xen testant:

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

Essaye ça.

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 réponse fournie par @aaronasterling semble bon, cependant, il est compatible avec l'interface par défaut de la liste: x = MyList(1, 2, 3, 4)vs x = MyList([1, 2, 3, 4]). Ainsi, le code ci-dessous peut être utilisé comme une liste plus conviviale pour 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])

Exemple:

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

Je pense que c'est plus rapide:

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}

Cet exemple soustrait deux listes:

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