I want to do something similar to this:

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

But this is not supported by python lists

What is the best way of doing it?

Use a list comprehension:

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

If you want to use the `-`

infix syntax, you can just do:

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

you can then use it like:

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

But if you don’t absolutely need list properties (for example, ordering), just use sets as the other answers recommend.

Use set difference

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

Or you might just have x and y be sets so you don’t have to do any conversions.

That is a “set subtraction” operation. Use the set data structure for that.

In Python 2.7:

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

Output:

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

if duplicate and ordering items are problem :

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

For many use cases, the answer you want is:

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

This is a hybrid between aaronasterling’s answer and quantumSoup’s answer.

aaronasterling’s version does `len(y)`

item comparisons for each element in `x`

, so it takes quadratic time. quantumSoup’s version uses sets, so it does a single constant-time set lookup for each element in `x`

—but, because it converts *both* `x`

and `y`

into sets, it loses the order of your elements.

By converting only `y`

into a set, and iterating `x`

in order, you get the best of both worlds—linear time, and order preservation.*

However, this still has a problem from quantumSoup’s version: It requires your elements to be hashable. That’s pretty much built into the nature of sets.** If you’re trying to, e.g., subtract a list of dicts from another list of dicts, but the list to subtract is large, what do you do?

If you can decorate your values in some way that they’re hashable, that solves the problem. For example, with a flat dictionary whose values are themselves hashable:

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

If your types are a bit more complicated (e.g., often you’re dealing with JSON-compatible values, which are hashable, or lists or dicts whose values are recursively the same type), you can still use this solution. But some types just can’t be converted into anything hashable.

If your items aren’t, and can’t be made, hashable, but they are comparable, you can at least get log-linear time (`O(N*log M)`

, which is a lot better than the `O(N*M)`

time of the list solution, but not as good as the `O(N+M)`

time of the set solution) by sorting and using `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)]
```

If your items are neither hashable nor comparable, then you’re stuck with the quadratic solution.

_{* Note that you could also do this by using a pair of OrderedSet objects, for which you can find recipes and third-party modules. But I think this is simpler.}

_{** The reason set lookups are constant time is that all it has to do is hash the value and see if there’s an entry for that hash. If it can’t hash the value, this won’t work.}

Try this.

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

Looking up values in sets are faster than looking them up in lists:

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

I believe this will scale slightly better than:

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

Both preserve the order of the lists.

The answer provided by @aaronasterling looks good, however, it is not compatible with the default interface of list: `x = MyList(1, 2, 3, 4)`

vs `x = MyList([1, 2, 3, 4])`

. Thus, the below code can be used as a more python-list friendly:

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

Example:

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

This example subtracts two lists:

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

Tags: laravelpython, list