获得两个列表之间的区别
我在Python中有两个列表，如下所示：
temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']
我需要创建第三个列表，其中包含第一个列表中不存在于第二个列表中的项目。从我必须得到的例子：
temp3 = ['Three', 'Four']
有没有没有循环和检查的快速方法？
31 个答案:
答案 0 :(得分：1009)
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(set([2, 3]))。
答案 1 :(得分：426)
现有解决方案均提供以下一种或另一种：
- 比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
答案 2 :(得分：61)
temp3 = [item for item in temp1 if item not in temp2]
答案 3 :(得分：17)
如果你想以递归方式获得差异，我已经为python编写了一个包： https://github.com/seperman/deepdiff
安装
从PyPi安装：
pip install deepdiff
使用示例
导入
>>> from deepdiff import DeepDiff
>>> from pprint import pprint
>>> from __future__ import print_function # In case running on Python 2
相同的对象返回空
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = t1
>>> print(DeepDiff(t1, t2))
{}
项目类型已更改
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:"2", 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{ 'type_changes': { 'root[2]': { 'newtype': <class 'str'>,
'newvalue': '2',
'oldtype': <class 'int'>,
'oldvalue': 2}}}
项目的价值已更改
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:4, 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
添加和/或删除了项目
>>> t1 = {1:1, 2:2, 3:3, 4:4}
>>> t2 = {1:1, 2:4, 3:3, 5:5, 6:6}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff)
{'dic_item_added': ['root[5]', 'root[6]'],
'dic_item_removed': ['root[4]'],
'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
字符串差异
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world"}}
>>> t2 = {1:1, 2:4, 3:3, 4:{"a":"hello", "b":"world!"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { 'root[2]': {'newvalue': 4, 'oldvalue': 2},
"root[4]['b']": { 'newvalue': 'world!',
'oldvalue': 'world'}}}
字符串差异2
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world!\nGoodbye!\n1\n2\nEnd"}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n1\n2\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { "root[4]['b']": { 'diff': '--- \n'
'+++ \n'
'@@ -1,5 +1,4 @@\n'
'-world!\n'
'-Goodbye!\n'
'+world\n'
' 1\n'
' 2\n'
' End',
'newvalue': 'world\n1\n2\nEnd',
'oldvalue': 'world!\n'
'Goodbye!\n'
'1\n'
'2\n'
'End'}}}
>>>
>>> print (ddiff['values_changed']["root[4]['b']"]["diff"])
---
+++
@@ -1,5 +1,4 @@
-world!
-Goodbye!
+world
1
2
End
输入类型
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n\n\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'type_changes': { "root[4]['b']": { 'newtype': <class 'str'>,
'newvalue': 'world\n\n\nEnd',
'oldtype': <class 'list'>,
'oldvalue': [1, 2, 3]}}}
列表差异
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3, 4]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{'iterable_item_removed': {"root[4]['b'][2]": 3, "root[4]['b'][3]": 4}}
列表差异2：
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'iterable_item_added': {"root[4]['b'][3]": 3},
'values_changed': { "root[4]['b'][1]": {'newvalue': 3, 'oldvalue': 2},
"root[4]['b'][2]": {'newvalue': 2, 'oldvalue': 3}}}
列出忽略顺序或重复的差异:(使用与上面相同的词典）
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2, ignore_order=True)
>>> print (ddiff)
{}
包含字典的列表：
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:1, 2:2}]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:3}]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'dic_item_removed': ["root[4]['b'][2][2]"],
'values_changed': {"root[4]['b'][2][1]": {'newvalue': 3, 'oldvalue': 1}}}
设定：
>>> t1 = {1, 2, 8}
>>> t2 = {1, 2, 3, 5}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (DeepDiff(t1, t2))
{'set_item_added': ['root[3]', 'root[5]'], 'set_item_removed': ['root[8]']}
命名元组：
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> t1 = Point(x=11, y=22)
>>> t2 = Point(x=11, y=23)
>>> pprint (DeepDiff(t1, t2))
{'values_changed': {'root.y': {'newvalue': 23, 'oldvalue': 22}}}
自定义对象：
>>> class ClassA(object):
... a = 1
... def __init__(self, b):
... self.b = b
...
>>> t1 = ClassA(1)
>>> t2 = ClassA(2)
>>>
>>> pprint(DeepDiff(t1, t2))
{'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
添加了对象属性：
>>> t2.c = "new attribute"
>>> pprint(DeepDiff(t1, t2))
{'attribute_added': ['root.c'],
'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
答案 4 :(得分：15)
如果您真的在研究性能，那么请使用numpy！
这是完整的笔记本，作为github上的要点，列表，numpy和pandas之间的比较。
https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451
答案 5 :(得分：12)
我会投入，因为现有的解决方案都没有产生元组：
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))
就像其他非元组在这个方向上产生答案一样，它保留了顺序
答案 6 :(得分：12)
最简单的方法，
使用 set（）。difference（set（））
list_a = [1,2,3]
list_b = [2,3]
print set(list_a).difference(set(list_b))
答案是set([1])
可以打印为列表，
print list(set(list_a).difference(set(list_b)))
答案 7 :(得分：12)
可以使用python XOR运算符完成。
- 这将删除每个列表中的重复项
- 这将显示temp1与temp1和temp2与temp1的区别。
set(temp1) ^ set(temp2)
答案 8 :(得分：9)
这可能比马克的列表理解更快：
list(itertools.filterfalse(set(temp2).__contains__, temp1))
答案 9 :(得分：9)
试试这个：
temp3 = set(temp1) - set(temp2)
答案 10 :(得分：9)
我想要的东西需要两个列表，并且可以执行diff中的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']
当然，如果您的应用程序做出与其他答案相同的假设，您将从中受益最多。但如果您正在寻找真正的diff功能，那么这是唯一的方法。
例如，其他答案都无法处理：
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]
答案 11 :(得分：6)
这是最简单案例的Counter答案。
这比上面的双向差异更短，因为它只能完成问题所要求的：生成第一个列表中的内容列表而不是第二个列表中的内容。
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']
答案 12 :(得分：5)
如果对difflist的元素进行排序和设置，则可以使用朴素方法。
list1=[1,2,3,4,5]
list2=[1,2,3]
print list1[len(list2):]
或使用本机设置方法：
subset=set(list1).difference(list2)
print subset
import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print "Naive solution: ", timeit.timeit('temp1[len(temp2):]', init, number = 100000)
print "Native set solution: ", timeit.timeit('set(temp1).difference(temp2)', init, number = 100000)
天真的解决方案：0.0787101593292
原生集合解决方案：0.998837615564
答案 13 :(得分：5)
我在游戏中为时已晚，但您可以对上面提到的一些代码的性能进行比较，其中两个最快的竞争者是，
list(set(x).symmetric_difference(set(y)))
list(set(x) ^ set(y))
我为编码的基本级别道歉。
import time
import random
from itertools import filterfalse
# 1 - performance (time taken)
# 2 - correctness (answer - 1,4,5,6)
# set performance
performance = 1
numberoftests = 7
def answer(x,y,z):
if z == 0:
start = time.clock()
lists = (str(list(set(x)-set(y))+list(set(y)-set(y))))
times = ("1 = " + str(time.clock() - start))
return (lists,times)
elif z == 1:
start = time.clock()
lists = (str(list(set(x).symmetric_difference(set(y)))))
times = ("2 = " + str(time.clock() - start))
return (lists,times)
elif z == 2:
start = time.clock()
lists = (str(list(set(x) ^ set(y))))
times = ("3 = " + str(time.clock() - start))
return (lists,times)
elif z == 3:
start = time.clock()
lists = (filterfalse(set(y).__contains__, x))
times = ("4 = " + str(time.clock() - start))
return (lists,times)
elif z == 4:
start = time.clock()
lists = (tuple(set(x) - set(y)))
times = ("5 = " + str(time.clock() - start))
return (lists,times)
elif z == 5:
start = time.clock()
lists = ([tt for tt in x if tt not in y])
times = ("6 = " + str(time.clock() - start))
return (lists,times)
else:
start = time.clock()
Xarray = [iDa for iDa in x if iDa not in y]
Yarray = [iDb for iDb in y if iDb not in x]
lists = (str(Xarray + Yarray))
times = ("7 = " + str(time.clock() - start))
return (lists,times)
n = numberoftests
if performance == 2:
a = [1,2,3,4,5]
b = [3,2,6]
for c in range(0,n):
d = answer(a,b,c)
print(d[0])
elif performance == 1:
for tests in range(0,10):
print("Test Number" + str(tests + 1))
a = random.sample(range(1, 900000), 9999)
b = random.sample(range(1, 900000), 9999)
for c in range(0,n):
#if c not in (1,4,5,6):
d = answer(a,b,c)
print(d[1])
答案 14 :(得分：4)
如果遇到TypeError: unhashable type: 'list'，则需要将列表或集合转换为元组，例如
set(map(tuple, list_of_lists1)).symmetric_difference(set(map(tuple, list_of_lists2)))
答案 15 :(得分：3)
以下是一些简单的 保留订单 方法来区分两个字符串列表。
<强>代码
使用pathlib的一种不寻常的方法：
Q2<-daily_SPEC %>%
group_by('Parameter Name', add=FALSE)%>%
summarize(Mean_by_chemical=mean(daily_SPEC$"Arithmetic Mean",
na.rm=TRUE))
Q2
Mean_by_chemical
1 105.401
这假设两个列表都包含具有等效开头的字符串。有关详细信息，请参阅docs。请注意，与设置操作相比，它并不是特别快。
使用itertools.zip_longest的直接实施：
import pathlib
temp1 = ["One", "Two", "Three", "Four"]
temp2 = ["One", "Two"]
p = pathlib.Path(*temp1)
r = p.relative_to(*temp2)
list(r.parts)
# ['Three', 'Four']
答案 16 :(得分：3)
如果你想要更像变更集的东西......可以使用Counter
from collections import Counter
def diff(a, b):
""" more verbose than needs to be, for clarity """
ca, cb = Counter(a), Counter(b)
to_add = cb - ca
to_remove = ca - cb
changes = Counter(to_add)
changes.subtract(to_remove)
return changes
lista = ['one', 'three', 'four', 'four', 'one']
listb = ['one', 'two', 'three']
In [127]: diff(lista, listb)
Out[127]: Counter({'two': 1, 'one': -1, 'four': -2})
# in order to go from lista to list b, you need to add a "two", remove a "one", and remove two "four"s
In [128]: diff(listb, lista)
Out[128]: Counter({'four': 2, 'one': 1, 'two': -1})
# in order to go from listb to lista, you must add two "four"s, add a "one", and remove a "two"
答案 17 :(得分：3)
这是另一种解决方案：
def diff(a, b):
xa = [i for i in set(a) if i not in b]
xb = [i for i in set(b) if i not in a]
return xa + xb
答案 18 :(得分：3)
单行版 arulmr 解决方案
def diff(listA, listB):
return set(listA) - set(listB) | set(listA) -set(listB)
答案 19 :(得分：2)
这可以用一行解决。 问题是两个列表（temp1和temp2）在第三个列表（temp3）中返回它们的差异。
temp3 = list(set(temp1).difference(set(temp2)))
答案 20 :(得分：2)
我们可以计算交集减去联合列表：
temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two', 'Five']
set(temp1+temp2)-(set(temp1)&set(temp2))
Out: set(['Four', 'Five', 'Three'])
答案 21 :(得分：2)
如果您应该从列表 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]
或
def list_diff(a, b):
return [x for x in a if x not in b]
答案 22 :(得分：1)
假设我们有两个列表
list1 = [1, 3, 5, 7, 9]
list2 = [1, 2, 3, 4, 5]
从上面的两个列表中我们可以看到列表2中存在项目1、3、5，而项目7、9中则没有。另一方面，列表1中存在项目1、3、5，而项目2、4中不存在。
返回包含项目7、9和2、4的新列表的最佳解决方案是什么？
以上所有答案都找到了解决方案，现在最最佳的是什么？
def difference(list1, list2):
new_list = []
for i in list1:
if i not in list2:
new_list.append(i)
for j in list2:
if j not in list1:
new_list.append(j)
return new_list
与
def sym_diff(list1, list2):
return list(set(list1).symmetric_difference(set(list2)))
使用时间我们可以看到结果
t1 = timeit.Timer("difference(list1, list2)", "from __main__ import difference,
list1, list2")
t2 = timeit.Timer("sym_diff(list1, list2)", "from __main__ import sym_diff,
list1, list2")
print('Using two for loops', t1.timeit(number=100000), 'Milliseconds')
print('Using two for loops', t2.timeit(number=100000), 'Milliseconds')
返回
[7, 9, 2, 4]
Using two for loops 0.11572412995155901 Milliseconds
Using symmetric_difference 0.11285737506113946 Milliseconds
Process finished with exit code 0
答案 23 :(得分：1)
我知道这个问题已经得到了很好的答案，但我希望使用 numpy 添加以下方法。
temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']
list(np.setdiff1d(temp1,temp2))
['Four', 'Three'] #Output
答案 24 :(得分：0)
这是区分两个列表（无论内容是什么）的简单方法，您可以得到如下所示的结果：
>>> from sets import Set
>>>
>>> l1 = ['xvda', False, 'xvdbb', 12, 'xvdbc']
>>> l2 = ['xvda', 'xvdbb', 'xvdbc', 'xvdbd', None]
>>>
>>> Set(l1).symmetric_difference(Set(l2))
Set([False, 'xvdbd', None, 12])
希望这会有所帮助。
答案 25 :(得分：0)
我更喜欢使用转换为集合，然后使用“ difference（）”函数。完整的代码是：
temp1 = ['One', 'Two', 'Three', 'Four' ]
temp2 = ['One', 'Two']
set1 = set(temp1)
set2 = set(temp2)
set3 = set1.difference(set2)
temp3 = list(set3)
print(temp3)
输出：
>>>print(temp3)
['Three', 'Four']
这是最容易理解的，如果将来使用大数据，将来会更容易，如果不需要重复，将其转换为集合将删除重复项。希望对您有所帮助；-）
答案 26 :(得分：0)
您可以循环浏览第一个列表，对于不在第二个列表中但在第一个列表中的每个项目，将其添加到第三个列表中。例如：
temp3 = []
for i in temp1:
if i not in temp2:
temp3.append(i)
print(temp3)
答案 27 :(得分：0)
这是@SuperNova 的 answer 的修改版本
def get_diff(a: list, b: list) -> list:
return list(set(a) ^ set(b))
答案 28 :(得分：-1)
(list(set(a)-set(b))+list(set(b)-set(a)))
答案 29 :(得分：-1)
apply plugin: 'com.github.johnrengelman.shadow'
shadowJar {
zip64 true
//classifier "shadow" can be mentioned according to need
mergeServiceFiles()
artifacts {
shadow(tasks.shadowJar.archivePath) {
builtBy shadowJar
}
}
}
artifacts {
archives shadowJar
}
distZip {
dependsOn shadowJar
//appendix='software'
eachFile { file ->
String path = file.relativePath
file.setPath(path.substring(path.indexOf("/")+1,path.length()))
}
doLast{
//operation to perform
}
}
distributions {
main {
contents {
//from and to can be mentioned here
}
}
}
例如如果def diffList(list1, list2): # returns the difference between two lists.
if len(list1) > len(list2):
return (list(set(list1) - set(list2)))
else:
return (list(set(list2) - set(list1)))
和list1 = [10, 15, 20, 25, 30, 35, 40]，则返回的列表将是list2 = [25, 40, 35]
答案 30 :(得分：-3)
tweets=['manoj', 'shekhar', 'manoj', 'rahul', 'mohit','jyohit','sankar','pappu']
netweets=['manoj','pappu', 'shekhar','mohit','gourav']
netweet = []
for i in tweets:
if i not in netweets:
netweet.append(i)
print(netweet)
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？