刪除從另一個

Question

在蟒蛇（2.7）一個列表中，我們可以這樣做：

>>> a = [1, 2, 3] 
>>> b = [4 , 5] 
>>> a + b 
[1, 2, 3, 4, 5] 

然而，我們不能做一個 - B。

由於python幾乎所有東西都有些酷，在你看來什麼是最蟒蛇式的做 - b，

類似的問題的字典，既不能做a + b或a - b，其中a和b都是字典。謝謝。

Answer 1

你可以帶套做：

>>> s = set([1,2,3] + [4,5]) 
>>> s - set([4, 5]) 
{1, 2, 3} 

當然是一組主要的差別不能包含重複的元素。

Answer 2

我會做：

>>> a = [1, 2, 3] 
>>> b = [2, 3] 
>>> filter(lambda x: x not in b, a) 
[1] 

或使用列表理解

[x for x in a if x not in b] 

，它可以做了字典一樣。

Set定義了運營商-和方法difference和symmetric_difference。如果您打算廣泛使用該操作，請使用set而不是list或dict。

Answer 3

答案取決於所需的語義a - b。

如果你只是想的第一要素，然後切片是自然的方式來做到這一點：

In [11]: a = [1, 2, 3] 

In [12]: b = [4 , 5] 

In [13]: ab = a + b 

In [14]: ab[:len(a)] 
Out[14]: [1, 2, 3] 

如果，另一方面，你要刪除的第一個列表的元素沒有在第二發現列表：

In [15]: [v for v in ab if v not in b] 
Out[15]: [1, 2, 3] 

第二類型的操作的更自然表示使用集：

In [18]: set(ab) - set(b) 
Out[18]: set([1, 2, 3]) 

請注意，通常這不會保留元素的排序（因爲集合是無序的）。如果排序是非常重要的，並且b很可能是長，轉換b成一組可以提高性能：

In [19]: bset = set(b) 

In [20]: [v for v in ab if v not in bset] 
Out[20]: [1, 2, 3] 

對於字典，已經存在一個在就地「增加」操作。它叫做dict.update()。

Answer 4

y = set(b)
aminusb = filter(lambda p: p not in y,a)

Answer 5

我會嘗試[x for x in a if a not in b]。

Answer 6

試試這個：

def list_sub(lst1, lst2): 
    s = set(lst2) 
    return [x for x in lst1 if x not in s] 

list_sub([1, 2, 3, 1, 2, 1, 5], [1, 2]) 
> [3, 5] 

這是一個O(n+m)解決了因這樣的事實，它使用預先計算set，所以成員查找將是快速的。此外，它將保留原始元素的順序並刪除重複項。

Answer 7

訂單不會被保留，但它有你想要的結果：

>>> def list_diff(a, b): 
...  return list(set(a) - set(b)) 
... 
>>> print list_diff([1, 2, 3, 1, 2, 1], [1, 2]) 
[3] 

Answer 8

這裏是我的最佳選擇，一是涉及到使用的for循環的其他轉換設置。在小單子大小循環的情況下是可以接受的，可以看出對於10列表大小，

In [65]: d1 = range(10) 

In [66]: d2 = range(1) 

In [67]: %timeit [x for x in d1 if x not in d2] 
1000000 loops, best of 3: 827 ns per loop 

In [68]: %timeit list(set(d1)-set(d2)) 
1000000 loops, best of 3: 1.25 µs per loop 

但是如果列表尺寸足夠大，那麼你應該使用設置，

In [69]: d1 = range(10000) 

In [70]: d2 = range(1000) 

In [71]: %timeit [x for x in d1 if x not in d2] 
10 loops, best of 3: 105 ms per loop 

In [72]: %timeit list(set(d1)-set(d2)) 
1000 loops, best of 3: 566 µs per loop