Python列表减法运算

Question

我想做类似的事情：

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

但这不被 python 列表支持 最好的方法是什么？

Answer 1

使用列表推导：

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

如果你想使用-中缀语法，你可以这样做：

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

你可以像这样使用它：

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

但是，如果您绝对不需要列表属性（例如，排序），只需按照其他答案的建议使用集合。

Answer 2

使用set difference

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

或者您可能只是设置了 x 和 y，因此您不必进行任何转换。

Answer 3

如果重复和订购商品有问题：

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

Answer 4

这是一个“集合减法”操作。为此使用设置的数据结构。

在 Python 2.7 中：

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

输出：

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

Answer 5

对于许多用例，您想要的答案是：

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

这是aaronasterling's answer 和quantumSoup's answer 的混合体。

aaronasterling 的版本对x 中的每个元素进行len(y) 项目比较，因此需要二次时间。 quantumSoup 的版本使用集合，因此它对x 中的每个元素进行一次恒定时间集合查找——但是，因为它将both x 和y 转换为集合，它失去了顺序你的元素。

通过仅将y 转换为一个集合，并按顺序迭代x，您可以获得两全其美——线性时间和顺序保留。*

---

但是，quantumSoup 的版本仍然存在问题：它要求您的元素是可散列的。这几乎是集合的本质。**如果您尝试从另一个 dicts 列表中减去一个 dicts 列表，但要减去的列表很大，您会怎么做？

如果您可以以某种方式装饰您的值，使其可散列，那么问题就解决了。例如，使用其值本身可散列的平面字典：

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

如果您的类型有点复杂（例如，您经常处理与 JSON 兼容的值，这些值是可散列的，或者值递归地为相同类型的列表或字典），您仍然可以使用此解决方案。但有些类型就是不能转换成任何可散列的东西。

---

如果您的项目不是，也无法制作，可散列，但它们是可比较的，您至少可以获得对数线性时间（O(N*log M)，这比 O(N*M) 的时间要好得多列表解决方案，但不如设置解决方案的O(N+M)时间）通过排序和使用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)]

---

如果您的项目既不可散列也不可比较，那么您将陷入二次解。

---

_{* 请注意，您也可以通过使用一对OrderedSet 对象来执行此操作，您可以找到它们的配方和第三方模块。但我认为这更简单。}

_{** 集合查找是恒定时间的原因是它所要做的就是散列值并查看该散列是否存在条目。如果它不能散列值，这将不起作用。}

Answer 6

如果列表允许重复元素，您可以使用集合中的计数器：

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

如果您需要保留 x 中的元素顺序：

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

Answer 7

我认为最简单的方法是使用 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]

Answer 8

在集合中查找值比在列表中查找更快：

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

我相信这会比：

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

两者都保留列表的顺序。

Answer 9

其他解决方案存在以下几个问题之一：

1. 他们不维护秩序，或者
2. 它们不会删除精确计数的元素，例如对于x = [1, 2, 2, 2] 和y = [2, 2]，它们将y 转换为set，并在行为正确时删除所有匹配元素（仅留下[1]）或删除每个唯一元素之一（留下[1, 2, 2]）将删除2 两次，留下[1, 2]，或者
3. 他们在 O(m * n) 工作，而最佳解决方案可以在 O(m + n) 工作

Alain was on the right track with Counter 解决 #2 和 #3，但该解决方案将失去排序。保留顺序的解决方案（删除每个值的第一个 n 副本以在要删除的值的 list 中重复 n）是：

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.

Try it online!

要使其删除每个元素的 最后 个副本，只需将 for 循环更改为 for val in reversed(x): 并在退出 for 循环后立即添加 out.reverse()。

根据y的长度构造Counter是O(n)，根据x的长度迭代x是O(n)，而Counter成员资格测试和变异是@ 987654349@，而list.append 摊销O(1)（给定的append 可以是O(n)，但对于许多appends，整体大O 平均值为O(1)，因为越来越少的它们需要重新分配)，所以完成的整体工作是O(m + n)。

您还可以通过测试来确定y 中是否有没有从x 中删除的元素：

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

Answer 10

试试这个。

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

Answer 11

@aaronasterling 提供的答案看起来不错，但是它与列表的默认接口不兼容：x = MyList(1, 2, 3, 4) vs x = MyList([1, 2, 3, 4])。因此，下面的代码可以用作对 python-list 更友好的代码：

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

例子：

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

Answer 12

我们也可以使用 set 方法来找出两个列表之间的差异

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

Answer 13

这个例子减去两个列表：

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

Answer 14

如果值是唯一的，你也可以试试这个：

list(set(x) - set(y))