现有的解决方案都提供了其中的一个或另一个:

比O(n*m)性能快。 保持输入列表的顺序。

但到目前为止，还没有一种解决方案兼而有之。如果你两者都想要，试试这个:

s = set(temp2)
temp3 = [x for x in temp1 if x not in s]

性能测试

import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print timeit.timeit('list(set(temp1) - set(temp2))', init, number = 100000)
print timeit.timeit('s = set(temp2);[x for x in temp1 if x not in s]', init, number = 100000)
print timeit.timeit('[item for item in temp1 if item not in temp2]', init, number = 100000)

结果:

4.34620224079 # ars' answer
4.2770634955  # This answer
30.7715615392 # matt b's answer

我提出的方法以及保持顺序也比集合减法(稍微)快，因为它不需要构造一个不必要的集合。如果第一个列表比第二个列表长得多，并且散列代价昂贵，那么性能差异将更加明显。下面是第二个测试:

init = '''
temp1 = [str(i) for i in range(100000)]
temp2 = [str(i * 2) for i in range(50)]
'''

结果:

11.3836875916 # ars' answer
3.63890368748 # this answer (3 times faster!)
37.7445402279 # matt b's answer

由于目前的解决方案都不产生一个元组，我将抛出:

temp3 = tuple(set(temp1) - set(temp2))

另外:

#edited using @Mark Byers idea. If you accept this one as answer, just accept his instead.
temp3 = tuple(x for x in temp1 if x not in set(temp2))

像其他在这个方向上得到答案的非元组一样，它保持了顺序

获取在temp1中而不在temp2中的元素 (假设每个列表中的元素是唯一的):

In [5]: list(set(temp1) - set(temp2))
Out[5]: ['Four', 'Three']

注意它是不对称的 :

In [5]: set([1, 2]) - set([2, 3])
Out[5]: set([1]) 

这里您可能期望/希望它等于set([1,3])。如果你想要set([1,3])作为你的答案，你可以使用set([1,2])。symmetric_difference(设置([2、3]))。

我想要一个能够使用两个列表并能做diff in bash所做的事情的东西。因为当你搜索“python diff two lists”时，这个问题首先会弹出，而且不是很具体，所以我会把我想到的贴出来。

使用difflib中的SequenceMather，你可以像diff一样比较两个列表。其他答案都不会告诉你差异发生的位置，但这个答案可以。有些答案只给出了一个方向上的差异。有些元素会重新排序。有些公司不处理副本。但是这个解决方案让你在两个列表之间有了真正的区别:

a = 'A quick fox jumps the lazy dog'.split()
b = 'A quick brown mouse jumps over the dog'.split()

from difflib import SequenceMatcher

for tag, i, j, k, l in SequenceMatcher(None, a, b).get_opcodes():
  if tag == 'equal': print('both have', a[i:j])
  if tag in ('delete', 'replace'): print('  1st has', a[i:j])
  if tag in ('insert', 'replace'): print('  2nd has', b[k:l])

这个输出:

both have ['A', 'quick']
  1st has ['fox']
  2nd has ['brown', 'mouse']
both have ['jumps']
  2nd has ['over']
both have ['the']
  1st has ['lazy']
both have ['dog']

当然，如果您的应用程序做出了与其他答案相同的假设，那么您将从中受益最大。但如果你正在寻找一个真正的差异功能，那么这是唯一的方法。

例如，其他答案都无法处理:

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

但这一个有:

  2nd has [5, 4, 3, 2]
both have [1]
  1st has [2, 3, 4, 5]

这里有一个最简单情况的反答案。

这比上面那个做双向差分的要短，因为它只做了问题要求的事情:生成第一个列表中的东西的列表，而不是第二个列表中的东西。

from collections import Counter

lst1 = ['One', 'Two', 'Three', 'Four']
lst2 = ['One', 'Two']

c1 = Counter(lst1)
c2 = Counter(lst2)
diff = list((c1 - c2).elements())

或者，根据你的可读性偏好，它可以是一个不错的单行代码:

diff = list((Counter(lst1) - Counter(lst2)).elements())

输出:

['Three', 'Four']

请注意，如果您只是对其进行迭代，则可以删除list(…)调用。

因为这个解决方案使用计数器，所以相对于许多基于集合的答案，它可以正确地处理数量。例如，在这个输入中:

lst1 = ['One', 'Two', 'Two', 'Two', 'Three', 'Three', 'Four']
lst2 = ['One', 'Two']

输出结果为:

['Two', 'Two', 'Three', 'Three', 'Four']

如果要删除列表a中存在于列表b中的所有值。

def list_diff(a, b):
    r = []

    for i in a:
        if i not in b:
            r.append(i)
    return r

list_diff([1、2、2],[1])

结果(2,2):

or

def list_diff(a, b):
    return [x for x in a if x not in b]