blocks|key|873469|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|873470|temp3+=+set(temp1)+-+set(temp2)|code-block|syntax|javascript|873471|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this:

<pre><code>temp3 = set(temp1) - set(temp2)
</code></pre>

blocks|key|1616281|text|要获取temp1中但不在temp2 中的元素：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1616282|In+[5]:+list(set(temp1)+-+set(temp2))
Out[5]:+['Four',+'Three']|code-block|syntax|javascript|1616283|请注意，它是非对称 ：|1616284|In+[5]:+set([1,+2])+-+set([2,+3])
Out[5]:+set([1])+|1616285|您可能希望/希望它等于set([1,+3])。如果你确实想要set([1,+3])作为你的答案，你可以使用set([1,+2]).symmetric_difference(set([2,+3]))。|1616286|entityMap^0|3|5|C|5|0|0|0|0|B|B|U|B|1H|19|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

To get elements which are in <code>temp1</code> but not in <code>temp2</code> :
<pre><code>In [5]: list(set(temp1) - set(temp2))
Out[5]: ['Four', 'Three']
</code></pre>
Beware that it is asymmetric :
<pre><code>In [5]: set([1, 2]) - set([2, 3])
Out[5]: set([1]) 
</code></pre>
where you might expect/want it to equal <code>set([1, 3])</code>. If you do want <code>set([1, 3])</code> as your answer, you can use <code>set([1, 2]).symmetric_difference(set([2, 3]))</code>.

blocks|key|873485|text|temp3+=+[item+for+item+in+temp1+if+item+not+in+temp2]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|873486|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|1620045|text|由于目前的解决方案都没有生成元组，因此我将对其进行讨论：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1620046|temp3+=+tuple(set(temp1)+-+set(temp2))|code-block|syntax|javascript|1620047|或者：|1620048|#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))|1620049|与其他非元组生成此方向的答案一样，它保留了顺序|1620050|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

i'll toss in since none of the present solutions yield a tuple:

<pre><code>temp3 = tuple(set(temp1) - set(temp2))
</code></pre>

alternatively:

<pre><code>#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))
</code></pre>

Like the other non-tuple yielding answers in this direction, it preserves order

blocks|key|4117861|text|现有的解决方案都提供以下两种解决方案之一：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4117862|输入列表的顺序比O(n*m)+performance.|4117863|Preserve+|unordered-list-item|4117864|快。|4117865|4117866|4117867|但到目前为止，还没有一种解决方案同时具备这两种功能。如果你想两者兼得，试试这个：|4117868|s+=+set(temp2)
temp3+=+[x+for+x+in+temp1+if+x+not+in+s]|code-block|syntax|javascript|4117869|性能测试|offset|length|style|BOLD|4117870|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)|4117871|结果：|4117872|4.34620224079+#+ars'+answer
4.2770634955++#+This+answer
30.7715615392+#+matt+b's+answer|4117873|我提出的方法以及保持顺序也比集合减法(略)快，因为它不需要构造不必要的集合。如果第一个列表比第二个列表长得多，并且哈希开销很大，那么性能差异将更加明显。下面是演示这一点的第二个测试：|4117874|init+=+'''
temp1+=+[str(i)+for+i+in+range(100000)]
temp2+=+[str(i+*+2)+for+i+in+range(50)]
'''|4117875|4117876|11.3836875916+#+ars'+answer
3.63890368748+#+this+answer+(3+times+faster!)
37.7445402279+#+matt+b's+answer|4117877|entityMap^0|0|0|0|0|0|0|0|0|0|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|1F|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1I|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1J|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1K|8|@$T|1L|U|1M|V|W]]|9|@]|A|$]]|$1|X|3|Y|5|O|7|1N|8|@]|9|@]|A|$P|Q]]|$1|Z|3|10|5|6|7|1O|8|@]|9|@]|A|$]]|$1|11|3|12|5|O|7|1P|8|@]|9|@]|A|$P|Q]]|$1|13|3|14|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|15|3|16|5|O|7|1R|8|@]|9|@]|A|$P|Q]]|$1|17|3|10|5|6|7|1S|8|@]|9|@]|A|$]]|$1|18|3|19|5|O|7|1T|8|@]|9|@]|A|$P|Q]]|$1|1A|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|1B|$]]

The existing solutions all offer either one or the other of:

<ul>
<li>Faster than O(n*m) performance.</li>
<li>Preserve order of input list.</li>
</ul>

But so far no solution has both. If you want both, try this:

<pre><code>s = set(temp2)
temp3 = [x for x in temp1 if x not in s]
</code></pre>

Performance test

<pre><code>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)
</code></pre>

Results:

<pre><code>4.34620224079 # ars' answer
4.2770634955 # This answer
30.7715615392 # matt b's answer
</code></pre>

The method I presented as well as preserving order is also (slightly) faster than the set subtraction because it doesn't require construction of an unnecessary set. The performance difference would be more noticable if the first list is considerably longer than the second and if hashing is expensive. Here's a second test demonstrating this:

<pre><code>init = '''
temp1 = [str(i) for i in range(100000)]
temp2 = [str(i * 2) for i in range(50)]
'''
</code></pre>

Results:

<pre><code>11.3836875916 # ars' answer
3.63890368748 # this answer (3 times faster!)
37.7445402279 # matt b's answer
</code></pre>

blocks|key|4117905|text|这可能比Mark的列表理解更快：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4117906|list(itertools.filterfalse(set(temp2).__contains__,+temp1))|code-block|syntax|javascript|4117907|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

this could be even faster than Mark's list comprehension:

<pre><code>list(itertools.filterfalse(set(temp2).__contains__, temp1))
</code></pre>

blocks|key|2709528|text|使用下面的简单函数可以找到两个列表(比如list1和list2)之间的差异。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2709529|def+diff(list1,+list2):
++++c+=+set(list1).union(set(list2))++#+or+c+=+set(list1)+%7C+set(list2)
++++d+=+set(list1).intersection(set(list2))++#+or+d+=+set(list1)+&+set(list2)
++++return+list(c+-+d)|code-block|syntax|javascript|2709530|或|2709531|def+diff(list1,+list2):
++++return+list(set(list1).symmetric_difference(set(list2)))++#+or+return+list(set(list1)+%5E+set(list2))|2709532|通过使用上面的函数，可以使用diff(temp2,+temp1)或diff(temp1,+temp2)找到差异。这两种方法都会给出结果['Four',+'Three']。您不必担心列表的顺序或先给出哪个列表。|offset|length|style|CODE|2709533|Python+doc+reference|2709534|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/sets.html#set-objects^0|0|0|0|0|E|I|X|I|1V|H|0|0|K|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@$M|15|N|16|O|P]|$M|17|N|18|O|P]|$M|19|N|1A|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@$M|1C|N|1D|1|1E]]|A|$]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

The difference between two lists (say list1 and list2) can be found using the following simple function.

<pre><code>def diff(list1, list2):
 c = set(list1).union(set(list2)) # or c = set(list1) | set(list2)
 d = set(list1).intersection(set(list2)) # or d = set(list1) &amp; set(list2)
 return list(c - d)
</code></pre>

or

<pre><code>def diff(list1, list2):
 return list(set(list1).symmetric_difference(set(list2))) # or return list(set(list1) ^ set(list2))
</code></pre>

By Using the above function, the difference can be found using <code>diff(temp2, temp1)</code> or <code>diff(temp1, temp2)</code>. Both will give the result <code>['Four', 'Three']</code>. You don't have to worry about the order of the list or which list is to be given first.

<a href="https://docs.python.org/2/library/sets.html#set-objects" rel="noreferrer">Python doc reference</a>

blocks|key|4117965|text|这是另一种解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4117966|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+%2B+xb|code-block|syntax|javascript|4117967|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is another solution:

<pre><code>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
</code></pre>

blocks|key|2709589|text|如果对差异列表的元素进行排序和设置，则可以使用朴素的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2709590|list1=[1,2,3,4,5]
list2=[1,2,3]

print+list1[len(list2):]|code-block|syntax|javascript|2709591|或者使用原生的set方法：|2709592|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)|2709593|朴素的解决方案:+0.0787101593292|2709594|原生集合解决方案:+0.998837615564|2709595|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You could use a naive method if the elements of the difflist are sorted and sets.

<pre><code>list1=[1,2,3,4,5]
list2=[1,2,3]

print list1[len(list2):]
</code></pre>

or with native set methods:

<pre><code>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)
</code></pre>

Naive solution: 0.0787101593292

Native set solution: 0.998837615564

blocks|key|1620166|text|arulmr解决方案的单行版本|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1620167|def+diff(listA,+listB):
++++return+set(listA)+-+set(listB)+%7C+set(listA)+-set(listB)|code-block|syntax|javascript|1620168|entityMap^0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

single line version of arulmr solution

<pre><code>def diff(listA, listB):
 return set(listA) - set(listB) | set(listA) -set(listB)
</code></pre>

blocks|key|2709651|text|如果你遇到TypeError:+unhashable+type:+'list'，你需要把列表或集合转换成元组，例如|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2709652|set(map(tuple,+list_of_lists1)).symmetric_difference(set(map(tuple,+list_of_lists2)))|code-block|syntax|javascript|2709653|另请参阅How+to+compare+a+list+of+lists/sets+in+python?|2709654|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/6105777/how-to-compare-a-list-of-lists-sets-in-python^0|5|Y|0|0|4|1A|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

If you run into <code>TypeError: unhashable type: 'list'</code> you need to turn lists or sets into tuples, e.g.

<pre><code>set(map(tuple, list_of_lists1)).symmetric_difference(set(map(tuple, list_of_lists2)))
</code></pre>

See also <a href="https://stackoverflow.com/questions/6105777/how-to-compare-a-list-of-lists-sets-in-python">How to compare a list of lists/sets in python?</a>

blocks|key|1616431|text|如果您希望以递归方式实现差异，我已经为python编写了一个包：https://github.com/seperman/deepdiff|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1616432|安装|1616433|从PyPi安装：|1616434|pip+install+deepdiff|code-block|syntax|javascript|1616435|示例用法|1616436|正在导入|1616437|>>>+from+deepdiff+import+DeepDiff
>>>+from+pprint+import+pprint
>>>+from+__future__+import+print_function+#+In+case+running+on+Python+2|1616438|同一对象返回空|1616439|>>>+t1+=+{1:1,+2:2,+3:3}
>>>+t2+=+t1
>>>+print(DeepDiff(t1,+t2))
{}|1616440|项目的类型已更改|1616441|>>>+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}}}|1616442|项的值已更改|1616443|>>>+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}}}|1616444|添加和/或删除项目|1616445|>>>+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}}}|1616446|字符串差异|1616447|>>>+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'}}}|1616448|字符串差异2|1616449|>>>+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'
++++++++++++++++++++++++++++++++++++++++++++++++'%2B%2B%2B+\n'
++++++++++++++++++++++++++++++++++++++++++++++++'@@+-1,5+%2B1,4+@@\n'
++++++++++++++++++++++++++++++++++++++++++++++++'-world!\n'
++++++++++++++++++++++++++++++++++++++++++++++++'-Goodbye!\n'
++++++++++++++++++++++++++++++++++++++++++++++++'%2Bworld\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"])
---+
%2B%2B%2B+
@@+-1,5+%2B1,4+@@
-world!
-Goodbye!
%2Bworld
+1
+2
+End|1616450|类型更改|1616451|>>>+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]}}}|1616452|列表差异|1616453|>>>+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}}|1616454|列表差异2：|1616455|>>>+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}}}|1616456|忽略顺序或重复项的列表差异：(使用与上面相同的字典)|1616457|>>>+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)
{}|1616458|包含字典的列表：|1616459|>>>+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}}}|1616460|集合：|1616461|>>>+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]']}|1616462|命名元组：|1616463|>>>+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}}}|1616464|自定义对象：|1616465|>>>+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}}}|1616466|已添加对象属性：|1616467|>>>+t2.c+=+"new+attribute"
>>>+pprint(DeepDiff(t1,+t2))
{'attribute_added':+['root.c'],
+'values_changed':+{'root.b':+{'newvalue':+2,+'oldvalue':+1}}}|1616468|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/seperman/deepdiff^0|W|10|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2O|8|@]|9|@$A|2P|B|2Q|1|2R]]|C|$]]|$1|D|3|E|5|6|7|2S|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|2T|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|2U|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|2V|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|2W|8|@]|9|@]|C|$]]|$1|Q|3|R|5|J|7|2X|8|@]|9|@]|C|$K|L]]|$1|S|3|T|5|6|7|2Y|8|@]|9|@]|C|$]]|$1|U|3|V|5|J|7|2Z|8|@]|9|@]|C|$K|L]]|$1|W|3|X|5|6|7|30|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|J|7|31|8|@]|9|@]|C|$K|L]]|$1|10|3|11|5|6|7|32|8|@]|9|@]|C|$]]|$1|12|3|13|5|J|7|33|8|@]|9|@]|C|$K|L]]|$1|14|3|15|5|6|7|34|8|@]|9|@]|C|$]]|$1|16|3|17|5|J|7|35|8|@]|9|@]|C|$K|L]]|$1|18|3|19|5|6|7|36|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|J|7|37|8|@]|9|@]|C|$K|L]]|$1|1C|3|1D|5|6|7|38|8|@]|9|@]|C|$]]|$1|1E|3|1F|5|J|7|39|8|@]|9|@]|C|$K|L]]|$1|1G|3|1H|5|6|7|3A|8|@]|9|@]|C|$]]|$1|1I|3|1J|5|J|7|3B|8|@]|9|@]|C|$K|L]]|$1|1K|3|1L|5|6|7|3C|8|@]|9|@]|C|$]]|$1|1M|3|1N|5|J|7|3D|8|@]|9|@]|C|$K|L]]|$1|1O|3|1P|5|6|7|3E|8|@]|9|@]|C|$]]|$1|1Q|3|1R|5|J|7|3F|8|@]|9|@]|C|$K|L]]|$1|1S|3|1T|5|6|7|3G|8|@]|9|@]|C|$]]|$1|1U|3|1V|5|J|7|3H|8|@]|9|@]|C|$K|L]]|$1|1W|3|1X|5|6|7|3I|8|@]|9|@]|C|$]]|$1|1Y|3|1Z|5|J|7|3J|8|@]|9|@]|C|$K|L]]|$1|20|3|21|5|6|7|3K|8|@]|9|@]|C|$]]|$1|22|3|23|5|J|7|3L|8|@]|9|@]|C|$K|L]]|$1|24|3|25|5|6|7|3M|8|@]|9|@]|C|$]]|$1|26|3|27|5|J|7|3N|8|@]|9|@]|C|$K|L]]|$1|28|3|29|5|6|7|3O|8|@]|9|@]|C|$]]|$1|2A|3|2B|5|J|7|3P|8|@]|9|@]|C|$K|L]]|$1|2C|3|2D|5|6|7|3Q|8|@]|9|@]|C|$]]|$1|2E|3|2F|5|J|7|3R|8|@]|9|@]|C|$K|L]]|$1|2G|3|-4|5|6|7|3S|8|@]|9|@]|C|$]]]|2H|$2I|$5|2J|2K|2L|C|$2M|2N]]]]

In case you want the difference recursively, I have written a package for python:
<a href="https://github.com/seperman/deepdiff">https://github.com/seperman/deepdiff</a>

<h2>Installation</h2>

Install from PyPi:

<pre><code>pip install deepdiff
</code></pre>

<h2>Example usage</h2>

Importing

<pre><code>&gt;&gt;&gt; from deepdiff import DeepDiff
&gt;&gt;&gt; from pprint import pprint
&gt;&gt;&gt; from __future__ import print_function # In case running on Python 2
</code></pre>

Same object returns empty

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3}
&gt;&gt;&gt; t2 = t1
&gt;&gt;&gt; print(DeepDiff(t1, t2))
{}
</code></pre>

Type of an item has changed

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3}
&gt;&gt;&gt; t2 = {1:1, 2:"2", 3:3}
&gt;&gt;&gt; pprint(DeepDiff(t1, t2), indent=2)
{ 'type_changes': { 'root[2]': { 'newtype': &lt;class 'str'&gt;,
 'newvalue': '2',
 'oldtype': &lt;class 'int'&gt;,
 'oldvalue': 2}}}
</code></pre>

Value of an item has changed

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3}
&gt;&gt;&gt; t2 = {1:1, 2:4, 3:3}
&gt;&gt;&gt; pprint(DeepDiff(t1, t2), indent=2)
{'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
</code></pre>

Item added and/or removed

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:4}
&gt;&gt;&gt; t2 = {1:1, 2:4, 3:3, 5:5, 6:6}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (ddiff)
{'dic_item_added': ['root[5]', 'root[6]'],
 'dic_item_removed': ['root[4]'],
 'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
</code></pre>

String difference

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world"}}
&gt;&gt;&gt; t2 = {1:1, 2:4, 3:3, 4:{"a":"hello", "b":"world!"}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (ddiff, indent = 2)
{ 'values_changed': { 'root[2]': {'newvalue': 4, 'oldvalue': 2},
 "root[4]['b']": { 'newvalue': 'world!',
 'oldvalue': 'world'}}}
</code></pre>

String difference 2

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world!\nGoodbye!\n1\n2\nEnd"}}
&gt;&gt;&gt; t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n1\n2\nEnd"}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; 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'}}}

&gt;&gt;&gt; 
&gt;&gt;&gt; print (ddiff['values_changed']["root[4]['b']"]["diff"])
--- 
+++ 
@@ -1,5 +1,4 @@
-world!
-Goodbye!
+world
 1
 2
 End
</code></pre>

Type change

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
&gt;&gt;&gt; t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n\n\nEnd"}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (ddiff, indent = 2)
{ 'type_changes': { "root[4]['b']": { 'newtype': &lt;class 'str'&gt;,
 'newvalue': 'world\n\n\nEnd',
 'oldtype': &lt;class 'list'&gt;,
 'oldvalue': [1, 2, 3]}}}
</code></pre>

List difference

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3, 4]}}
&gt;&gt;&gt; t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2]}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (ddiff, indent = 2)
{'iterable_item_removed': {"root[4]['b'][2]": 3, "root[4]['b'][3]": 4}}
</code></pre>

List difference 2:

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
&gt;&gt;&gt; t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; 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}}}
</code></pre>

List difference ignoring order or duplicates: (with the same dictionaries as above)

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
&gt;&gt;&gt; t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2, ignore_order=True)
&gt;&gt;&gt; print (ddiff)
{}
</code></pre>

List that contains dictionary:

<pre><code>&gt;&gt;&gt; t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:1, 2:2}]}}
&gt;&gt;&gt; t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:3}]}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (ddiff, indent = 2)
{ 'dic_item_removed': ["root[4]['b'][2][2]"],
 'values_changed': {"root[4]['b'][2][1]": {'newvalue': 3, 'oldvalue': 1}}}
</code></pre>

Sets:

<pre><code>&gt;&gt;&gt; t1 = {1, 2, 8}
&gt;&gt;&gt; t2 = {1, 2, 3, 5}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (DeepDiff(t1, t2))
{'set_item_added': ['root[3]', 'root[5]'], 'set_item_removed': ['root[8]']}
</code></pre>

Named Tuples:

<pre><code>&gt;&gt;&gt; from collections import namedtuple
&gt;&gt;&gt; Point = namedtuple('Point', ['x', 'y'])
&gt;&gt;&gt; t1 = Point(x=11, y=22)
&gt;&gt;&gt; t2 = Point(x=11, y=23)
&gt;&gt;&gt; pprint (DeepDiff(t1, t2))
{'values_changed': {'root.y': {'newvalue': 23, 'oldvalue': 22}}}
</code></pre>

Custom objects:

<pre><code>&gt;&gt;&gt; class ClassA(object):
... a = 1
... def __init__(self, b):
... self.b = b
... 
&gt;&gt;&gt; t1 = ClassA(1)
&gt;&gt;&gt; t2 = ClassA(2)
&gt;&gt;&gt; 
&gt;&gt;&gt; pprint(DeepDiff(t1, t2))
{'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
</code></pre>

Object attribute added:

<pre><code>&gt;&gt;&gt; t2.c = "new attribute"
&gt;&gt;&gt; pprint(DeepDiff(t1, t2))
{'attribute_added': ['root.c'],
 'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
</code></pre>

blocks|key|2709830|text|如果你真的在研究性能，那就使用numpy吧！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2709831|这里是完整的笔记本，作为github的要点，并对list，numpy和pandas进行了比较。|2709832|https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451|offset|length|2709833|​|2709834|📷|atomic|2709835|2709836|entityMap|0|LINK|mutability|MUTABLE|url|1|IMAGE|IMMUTABLE|imageUrl|https://i.stack.imgur.com/lhT55.png|imageAlt^0|0|0|0|1V|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@$F|13|G|14|1|15]]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|17|8|@]|9|@$F|18|G|19|1|1A]]|A|$]]|$1|M|3|I|5|6|7|1B|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|E]]|U|$5|V|R|W|A|$X|Y|Z|-4]]]]

If you are really looking into performance, then use numpy!

Here is the full notebook as a gist on github with comparison between list, numpy, and pandas.

<a href="https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451" rel="noreferrer">https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451</a>

<a href="https://i.stack.imgur.com/lhT55.png" rel="noreferrer"><img src="https://i.stack.imgur.com/lhT55.png" alt="enter image description here"></a>

blocks|key|1620260|text|如果你想要更像变更集的东西...可以使用计数器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1620261|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"|code-block|syntax|javascript|1620262|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

if you want something more like a changeset... could use Counter

<pre><code>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"
</code></pre>

blocks|key|871606|text|我想要的东西可以接受两个列表，并且可以做bash中的diff所做的事情。由于这个问题是在你搜索"python+diff+two+lists“时首先出现的，而且不是很具体，所以我会把我想出来的东西贴出来。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|871607|使用difflib中的SequenceMather，您可以像diff一样比较两个列表。其他答案都不会告诉你差异发生的位置，但这个答案可以。有些答案只给出了一个方向上的差异。有些对元素进行了重新排序。有些不处理重复的内容。但是这个解决方案给了你两个列表之间真正的区别：|871608|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])|code-block|syntax|javascript|871609|这将输出以下内容：|871610|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']|871611|当然，如果您的应用程序做出了与其他答案相同的假设，您将从这些假设中获益最多。但是，如果您正在寻找真正的diff功能，那么这是唯一的选择。|871612|例如，其他答案都无法回答：|871613|a+=+[1,2,3,4,5]
b+=+[5,4,3,2,1]|871614|但这一条是：|871615|++2nd+has+[5,+4,+3,+2]
both+have+[1]
++1st+has+[2,+3,+4,+5]|871616|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.5/library/difflib.html#difflib.SequenceMatcher^0|K|4|Q|4|0|2|7|B|E|U|4|B|E|0|0|0|0|0|1F|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@$9|1K|A|1L|1|1M]]|E|$]]|$1|H|3|I|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1O|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1P|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1T|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1U|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1V|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1W|8|@]|D|@]|E|$K|L]]|$1|10|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]]]

I wanted something that would take two lists and could do what <code>diff</code> in <code>bash</code> does. Since this question pops up first when you search for "python diff two lists" and is not very specific, I will post what I came up with.

Using <a href="https://docs.python.org/3.5/library/difflib.html#difflib.SequenceMatcher" rel="noreferrer"><code>SequenceMather</code></a> from <code>difflib</code> you can compare two lists like <code>diff</code> does. None of the other answers will tell you the position where the difference occurs, but this one does. Some answers give the difference in only one direction. Some reorder the elements. Some don't handle duplicates. But this solution gives you a true difference between two lists:

<pre><code>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])
</code></pre>

This outputs:

<pre><code>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']
</code></pre>

Of course, if your application makes the same assumptions the other answers make, you will benefit from them the most. But if you are looking for a true <code>diff</code> functionality, then this is the only way to go.

For example, none of the other answers could handle:

<pre><code>a = [1,2,3,4,5]
b = [5,4,3,2,1]
</code></pre>

But this one does:

<pre><code> 2nd has [5, 4, 3, 2]
both have [1]
 1st has [2, 3, 4, 5]
</code></pre>

blocks|key|871624|text|可以使用python+XOR运算符来完成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|871625|871626|这将删除每个列表中的重复项|unordered-list-item|871627|这将显示temp1与temp2的差异以及temp2与temp1的差异。|871628|871629|871630|set(temp1)+%5E+set(temp2)|code-block|syntax|javascript|871631|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|W|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|P|$]]

Can be done using python XOR operator.

<ul>
<li>This will remove the duplicates in each list</li>
<li>This will show difference of temp1 from temp2 and temp2 from temp1.</li>
</ul>

<hr>

<pre><code>set(temp1) ^ set(temp2)
</code></pre>

blocks|key|4118450|text|对于最简单的情况，这里有一个Counter答案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4118451|这比上面做双向差异的方法更短，因为它只做问题所要求的:生成第一个列表中的内容的列表，而不是第二个列表中的内容。|4118452|from+collections+import+Counter

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

c1+=+Counter(lst1)
c2+=+Counter(lst2)
diff+=+list((c1+-+c2).elements())|code-block|syntax|javascript|4118453|或者，根据您的可读性偏好，它可以构成一个很好的一行程序：|4118454|diff+=+list((Counter(lst1)+-+Counter(lst2)).elements())|4118455|输出：|4118456|['Three',+'Four']|4118457|请注意，如果您只是迭代list(...)调用，则可以将其删除。|4118458|因为这个解决方案使用了计数器，所以它可以正确地处理数量，而不是许多基于集合的答案。例如，在此输入上：|4118459|lst1+=+['One',+'Two',+'Two',+'Two',+'Three',+'Three',+'Four']
lst2+=+['One',+'Two']|4118460|输出为：|4118461|['Two',+'Two',+'Three',+'Three',+'Four']|4118462|entityMap^0|E|7|0|0|0|0|0|0|0|B|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|1K|8|@]|D|@]|E|$]]|$1|12|3|13|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|14|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|15|$]]

Here's a <code>Counter</code> answer for the simplest case.

This is shorter than the one above that does two-way diffs because it only does exactly what the question asks: generate a list of what's in the first list but not the second.

<pre><code>from collections import Counter

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

c1 = Counter(lst1)
c2 = Counter(lst2)
diff = list((c1 - c2).elements())
</code></pre>

Alternatively, depending on your readability preferences, it makes for a decent one-liner:

<pre><code>diff = list((Counter(lst1) - Counter(lst2)).elements())
</code></pre>

Output:

<pre><code>['Three', 'Four']
</code></pre>

Note that you can remove the <code>list(...)</code> call if you are just iterating over it.

Because this solution uses counters, it handles quantities properly vs the many set-based answers. For example on this input:

<pre><code>lst1 = ['One', 'Two', 'Two', 'Two', 'Three', 'Three', 'Four']
lst2 = ['One', 'Two']
</code></pre>

The output is:

<pre><code>['Two', 'Two', 'Three', 'Three', 'Four']
</code></pre>

blocks|key|2710047|text|我们可以计算列表的交集减去并集：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2710048|temp1+=+['One',+'Two',+'Three',+'Four']
temp2+=+['One',+'Two',+'Five']

set(temp1%2Btemp2)-(set(temp1)&set(temp2))

Out:+set(['Four',+'Five',+'Three'])+|code-block|syntax|javascript|2710049|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

We can calculate intersection minus union of lists:

<pre><code>temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two', 'Five']

set(temp1+temp2)-(set(temp1)&amp;set(temp2))

Out: set(['Four', 'Five', 'Three']) 
</code></pre>

blocks|key|2710067|text|这可以用一行代码来解决。给出两个列表(temp1和temp2)，在第三个列表(temp3)中返回它们的差异。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2710068|temp3+=+list(set(temp1).difference(set(temp2)))|code-block|syntax|javascript|2710069|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This can be solved with one line.
The question is given two lists (temp1 and temp2) return their difference in a third list (temp3).

<pre><code>temp3 = list(set(temp1).difference(set(temp2)))
</code></pre>

blocks|key|2710129|text|我在这个游戏中有点太晚了，但是你可以用这个来比较上面提到的一些代码的性能，两个最快的竞争者是，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2710130|list(set(x).symmetric_difference(set(y)))
list(set(x)+%5E+set(y))|code-block|syntax|javascript|2710131|我为初级的编码道歉。|2710132|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))%2Blist(set(y)-set(y))))
++++++++times+=+("1+=+"+%2B+str(time.clock()+-+start))
++++++++return+(lists,times)

++++elif+z+==+1:
++++++++start+=+time.clock()
++++++++lists+=+(str(list(set(x).symmetric_difference(set(y)))))
++++++++times+=+("2+=+"+%2B+str(time.clock()+-+start))
++++++++return+(lists,times)

++++elif+z+==+2:
++++++++start+=+time.clock()
++++++++lists+=+(str(list(set(x)+%5E+set(y))))
++++++++times+=+("3+=+"+%2B+str(time.clock()+-+start))
++++++++return+(lists,times)

++++elif+z+==+3:
++++++++start+=+time.clock()
++++++++lists+=+(filterfalse(set(y).__contains__,+x))
++++++++times+=+("4+=+"+%2B+str(time.clock()+-+start))
++++++++return+(lists,times)

++++elif+z+==+4:
++++++++start+=+time.clock()
++++++++lists+=+(tuple(set(x)+-+set(y)))
++++++++times+=+("5+=+"+%2B+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+=+"+%2B+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+%2B+Yarray))
++++++++times+=+("7+=+"+%2B+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"+%2B+str(tests+%2B+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])|2710133|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I am little too late in the game for this but you can do a comparison of performance of some of the above mentioned code with this, two of the fastest contenders are,

<pre><code>list(set(x).symmetric_difference(set(y)))
list(set(x) ^ set(y))
</code></pre>

I apologize for the elementary level of coding.

<pre><code>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])
</code></pre>

blocks|key|2710148|text|最简单的方法是，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2710149|使用set().difference(set())|offset|length|style|BOLD|2710150|list_a+=+[1,2,3]
list_b+=+[2,3]
print+set(list_a).difference(set(list_b))|code-block|syntax|javascript|2710151|答案是set([1])|CODE|2710152|可以打印为列表，|2710153|print+list(set(list_a).difference(set(list_b)))|2710154|entityMap^0|0|2|N|0|0|3|8|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Z|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|10|8|@$D|11|E|12|F|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|S|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|T|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|U|$]]

most simple way,

use set().difference(set())

<pre><code>list_a = [1,2,3]
list_b = [2,3]
print set(list_a).difference(set(list_b))
</code></pre>

answer is <code>set([1])</code>

can print as a list,

<pre><code>print list(set(list_a).difference(set(list_b)))
</code></pre>

blocks|key|4118613|text|下面是区分两个字符串列表的几种简单的order-preserving方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4118614|代码|4118615|一种使用pathlib的不同寻常的方法|CODE|4118616|import+pathlib


temp1+=+["One",+"Two",+"Three",+"Four"]
temp2+=+["One",+"Two"]

p+=+pathlib.Path(*temp1)
r+=+p.relative_to(*temp2)
list(r.parts)
#+['Three',+'Four']|code-block|syntax|javascript|4118617|这假设两个列表都包含具有相同开头的字符串。有关更多详细信息，请参阅docs。请注意，与集合操作相比，它的速度并不是特别快。|4118618|4118619|使用itertools.zip_longest的简单实现|4118620|import+itertools+as+it


[x+for+x,+y+in+it.zip_longest(temp1,+temp2)+if+x+!=+y]
#+['Three',+'Four']|4118621|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/pathlib.html#module-pathlib|1|https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.relative_to|2|https://docs.python.org/3/library/itertools.html#itertools.zip_longest^0|I|G|0|0|2|0|4|7|4|7|0|0|0|X|4|1|0|0|2|L|2|L|2|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1E|8|@$9|1F|A|1G|B|J]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|K|3|L|5|M|7|1K|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|1L|8|@]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|R|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1Q|8|@$9|1R|A|1S|B|J]]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|U|3|V|5|M|7|1W|8|@]|D|@]|E|$N|O]]|$1|W|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]|16|$5|Z|10|11|E|$12|17]]]]

Here are a few simple, order-preserving ways of diffing two lists of strings.

Code

An unusual approach using <a href="https://docs.python.org/3/library/pathlib.html#module-pathlib" rel="nofollow noreferrer"><code>pathlib</code></a>:

<pre><code>import pathlib


temp1 = ["One", "Two", "Three", "Four"]
temp2 = ["One", "Two"]

p = pathlib.Path(*temp1)
r = p.relative_to(*temp2)
list(r.parts)
# ['Three', 'Four']
</code></pre>

This assumes both lists contain strings with equivalent beginnings. See the <a href="https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.relative_to" rel="nofollow noreferrer">docs</a> for more details. Note, it is not particularly fast compared to set operations.

<hr>

A straight-forward implementation using <a href="https://docs.python.org/3/library/itertools.html#itertools.zip_longest" rel="nofollow noreferrer"><code>itertools.zip_longest</code></a>:

<pre><code>import itertools as it


[x for x, y in it.zip_longest(temp1, temp2) if x != y]
# ['Three', 'Four']
</code></pre>

blocks|key|4118647|text|这里有一个区分两个列表的简单方法(不管是什么内容)，你可以得到如下结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4118648|>>>+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])|code-block|syntax|javascript|4118649|希望这能对你有所帮助。|4118650|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is an simple way to distinguish two lists (whatever the contents are), you can get the result as shown below :

<pre><code>&gt;&gt;&gt; from sets import Set
&gt;&gt;&gt;
&gt;&gt;&gt; l1 = ['xvda', False, 'xvdbb', 12, 'xvdbc']
&gt;&gt;&gt; l2 = ['xvda', 'xvdbb', 'xvdbc', 'xvdbd', None]
&gt;&gt;&gt;
&gt;&gt;&gt; Set(l1).symmetric_difference(Set(l2))
Set([False, 'xvdbd', None, 12])
</code></pre>

Hope this will helpful.

blocks|key|1620466|text|假设我们有两个列表|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1620467|list1+=+[1,+3,+5,+7,+9]
list2+=+[1,+2,+3,+4,+5]|code-block|syntax|javascript|1620468|从上面的两个列表中我们可以看到，第1、3、5项存在于list2中，而第7、9项则不存在。另一方面，项1、3、5存在于list1中，而项2、4不存在。|1620469|返回包含项目7、9和2、4的新列表的最佳解决方案是什么？|1620470|上面所有的答案都找到了解决方案，现在什么是最优的呢？|1620471|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|1620472|对比|1620473|def+sym_diff(list1,+list2):
++++return+list(set(list1).symmetric_difference(set(list2)))|1620474|使用timeit我们可以看到结果|1620475|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')|1620476|返回|1620477|[7,+9,+2,+4]
Using+two+for+loops+0.11572412995155901+Milliseconds
Using+symmetric_difference+0.11285737506113946+Milliseconds

Process+finished+with+exit+code+0|1620478|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Let's say we have two lists

<pre><code>list1 = [1, 3, 5, 7, 9]
list2 = [1, 2, 3, 4, 5]
</code></pre>

we can see from the above two lists that items 1, 3, 5 exist in list2 and items 7, 9 do not. On the other hand, items 1, 3, 5 exist in list1 and items 2, 4 do not.

What is the best solution to return a new list containing items 7, 9 and 2, 4?

All answers above find the solution, now whats the most optimal?

<pre><code>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
</code></pre>

versus

<pre><code>def sym_diff(list1, list2):
 return list(set(list1).symmetric_difference(set(list2)))
</code></pre>

Using timeit we can see the results

<pre><code>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')
</code></pre>

returns

<pre><code>[7, 9, 2, 4]
Using two for loops 0.11572412995155901 Milliseconds
Using symmetric_difference 0.11285737506113946 Milliseconds

Process finished with exit code 0
</code></pre>

blocks|key|871813|text|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)))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|871814|例如，如果为list1+=+[10,+15,+20,+25,+30,+35,+40]和list2+=+[25,+40,+35]，则返回的列表将为output+=+[10,+20,+30,+15]|unstyled|offset|length|style|CODE|871815|entityMap^0|0|6|10|17|K|20|P|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]|$G|S|H|T|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|U|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>def diffList(list1, list2): # returns the difference between two lists.
 if len(list1) &gt; len(list2):
 return (list(set(list1) - set(list2)))
 else:
 return (list(set(list2) - set(list1)))
</code></pre>

e.g. if <code>list1 = [10, 15, 20, 25, 30, 35, 40]</code> and <code>list2 = [25, 40, 35]</code> then the returned list will be <code>output = [10, 20, 30, 15]</code>

blocks|key|2710334|text|我更喜欢使用转换为集合，然后使用"difference()“函数。完整的代码是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2710335|temp1+=+['One',+'Two',+'Three',+'Four'++]+++++++++++++++++++
temp2+=+['One',+'Two']
set1+=+set(temp1)
set2+=+set(temp2)
set3+=+set1.difference(set2)
temp3+=+list(set3)
print(temp3)|code-block|syntax|javascript|2710336|输出：|2710337|>>>print(temp3)
['Three',+'Four']|2710338|这是最容易理解的，而且将来如果你处理大数据，如果不需要重复数据，将其转换为集合将会删除重复数据。希望它能有所帮助;-)|2710339|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I prefer to use converting to sets and then using the "difference()" function. The full code is :

<pre><code>temp1 = ['One', 'Two', 'Three', 'Four' ] 
temp2 = ['One', 'Two']
set1 = set(temp1)
set2 = set(temp2)
set3 = set1.difference(set2)
temp3 = list(set3)
print(temp3)

</code></pre>

Output:

<pre><code>&gt;&gt;&gt;print(temp3)
['Three', 'Four']
</code></pre>

It's the easiest to undersand, and morover in future if you work with large data, converting it to sets will remove duplicates if duplicates are not required. Hope it helps ;-)

blocks|key|2710366|text|您可以循环浏览第一个列表，对于不在第二个列表中但在第一个列表中的每个项目，将其添加到第三个列表中。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2710367|temp3+=+[]
for+i+in+temp1:
++++if+i+not+in+temp2:
++++++++temp3.append(i)
print(temp3)|code-block|syntax|javascript|2710368|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can cycle through the first list and, for every item that isn't in the second list but is in the first list, add it to the third list. E.g:
<pre><code>temp3 = []
for i in temp1:
 if i not in temp2:
 temp3.append(i)
print(temp3)
</code></pre>

blocks|key|2710385|text|我知道这个问题已经得到了很好的答案，但我希望使用numpy添加以下方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2710386|temp1+=+['One',+'Two',+'Three',+'Four']
temp2+=+['One',+'Two']

list(np.setdiff1d(temp1,temp2))

['Four',+'Three']+#Output|code-block|syntax|javascript|2710387|entityMap^0|O|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I know this question got great answers already but I wish to add the following method using <code>numpy</code>.
<pre><code>temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']

list(np.setdiff1d(temp1,temp2))

['Four', 'Three'] #Output
</code></pre>

blocks|key|871861|text|如果您应该从list+a中删除所有值，这些值出现在list+b中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|871862|def+list_diff(a,+b):
++++r+=+[]

++++for+i+in+a:
++++++++if+i+not+in+b:
++++++++++++r.append(i)
++++return+r|code-block|syntax|javascript|871863|list_diff(1,2,2，1)|871864|结果:+2,2|871865|或|871866|def+list_diff(a,+b):
++++return+[x+for+x+in+a+if+x+not+in+b]|871867|entityMap^0|B|1|U|1|0|0|0|0|0|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

If you should remove all values from list a, which are present in list b.
<pre><code>def list_diff(a, b):
 r = []

 for i in a:
 if i not in b:
 r.append(i)
 return r
</code></pre>
list_diff([1,2,2], [1])
Result: [2,2]
or
<pre><code>def list_diff(a, b):
 return [x for x in a if x not in b]
</code></pre>

blocks|key|871872|text|这是@SuperNova的answer的一个修改版本|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|871873|def+get_diff(a:+list,+b:+list)+->+list:
++++return+list(set(a)+%5E+set(b))|code-block|syntax|javascript|871874|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/38240169/11430726^0|D|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Here is a modified version of @SuperNova's <a href="https://stackoverflow.com/a/38240169/11430726">answer</a>
<pre><code>def get_diff(a: list, b: list) -&gt; list:
 return list(set(a) ^ set(b))
</code></pre>

blocks|key|2710479|text|根据@arkolec的回答，下面是一个用于比较列表、元组和集合的实用程序类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2710480|from+difflib+import+SequenceMatcher

class+ListDiffer:

++++def+__init__(self,+left,+right,+strict:bool=False):
++++++++assert+isinstance(left,+(list,+tuple,+set)),+"left+must+be+list,+tuple+or+set"
++++++++assert+isinstance(right,+(list,+tuple,+set)),+"right+must+be+list,+tuple+or+set"
++++++++self.l+=+list(left)+if+isinstance(left,+(tuple,+set))+else+left
++++++++self.r+=+list(right)+if+isinstance(left,+(tuple,+set))+else+right

++++++++if+strict:
++++++++++++assert+isinstance(left,+right.__class__),+\
++++++++++++++++f'left+type+({left.__class__.__name__})+must+equal+right+type+({right.__class__.__name__})'

++++++++self.diffs+=+[]
++++++++self.equal+=+[]

++++++++for+tag,+i,+j,+k,+l+in+SequenceMatcher(None,+self.l,+self.r).get_opcodes():
++++++++++++if+tag+in+['delete',+'replace',+'insert']:
++++++++++++++++self.diffs.append((tag,+i,+j,+k,+l))
++++++++++++elif+tag+==+'equal':
++++++++++++++++[self.equal.append(v)+for+v+in+left[i:j]]
++++++++++++++++


++++def+has_diffs(self):
++++++++return+len(self.diffs)+>+0


++++def+only_left(self):
++++++++a+=+self.l[:]
++++++++[a.remove(v)+for+v+in+self.equal]
++++++++return+a

++++def+only_right(self):
++++++++a+=+self.r[:]
++++++++[a.remove(v)+for+v+in+self.equal]
++++++++return+a


++++def+__str__(self,+verbose:bool=False):
++++++++iD+=+0
++++++++sb+=+[]
++++++++if+verbose:
++++++++++++sb.append(f"left:+{self.l}\n")
++++++++++++sb.append(f"right:+{self.r}\n")
++++++++++++sb.append(f"diffs:+")
++++++++for+tag,+i,+j,+k,+l+in+self.diffs:
++++++++++++s+=+f"({iD})"
++++++++++++if+iD+>+0:+sb.append('+%7C+')
++++++++++++if+tag+in+('delete',+'replace'):+s+=+f'{s}+l:{self.l[i:j]}'
++++++++++++if+tag+in+('insert',+'replace'):+s+=+f'{s}+r:{self.r[k:l]}'
++++++++++++sb.append(s)
++++++++++++iD+=+iD+%2B+1

++++++++if+verbose:
++++++++++++sb.append(f"\nequal:+{self.equal}")
++++++++return+''.join(sb)

++++def+__repr__(self)+->+str:
++++++++return+"<ListDiffer>+{}".format(self.__str__())|code-block|syntax|javascript|2710481|用法：|2710482|left+=+['a','b','c']
right+=+['aa','b','c','d']
#+right+=+('aa','b','c','d')
ld+=+ListDiffer(left,+right,+strict=True)
print(f'ld.has_diffs():+{ld.has_diffs()}')
print(f'ld:+{ld}')
print(f'ld.only_left():+{ld.only_left()}')
print(f'ld.only_right():+{ld.only_right()}')|2710483|输出：|2710484|ld.has_diffs():+True
ld:+(0)+l:['a']+r:['aa']+%7C+(1)+r:['d']
ld.only_left():+['a']
ld.only_right():+['aa',+'d']|2710485|我不能谈论性能，但是你可以使用ld.only_left()来得到你想要的结果。|offset|length|style|CODE|2710486|entityMap^0|0|0|0|0|0|0|F|E|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Following on @arkolec's answer, here is a utility class for comparing lists, tuples and sets:
<pre><code>from difflib import SequenceMatcher

class ListDiffer:

 def __init__(self, left, right, strict:bool=False):
 assert isinstance(left, (list, tuple, set)), &quot;left must be list, tuple or set&quot;
 assert isinstance(right, (list, tuple, set)), &quot;right must be list, tuple or set&quot;
 self.l = list(left) if isinstance(left, (tuple, set)) else left
 self.r = list(right) if isinstance(left, (tuple, set)) else right

 if strict:
 assert isinstance(left, right.__class__), \
 f'left type ({left.__class__.__name__}) must equal right type ({right.__class__.__name__})'

 self.diffs = []
 self.equal = []

 for tag, i, j, k, l in SequenceMatcher(None, self.l, self.r).get_opcodes():
 if tag in ['delete', 'replace', 'insert']:
 self.diffs.append((tag, i, j, k, l))
 elif tag == 'equal':
 [self.equal.append(v) for v in left[i:j]]
 


 def has_diffs(self):
 return len(self.diffs) &gt; 0


 def only_left(self):
 a = self.l[:]
 [a.remove(v) for v in self.equal]
 return a

 def only_right(self):
 a = self.r[:]
 [a.remove(v) for v in self.equal]
 return a


 def __str__(self, verbose:bool=False):
 iD = 0
 sb = []
 if verbose:
 sb.append(f&quot;left: {self.l}\n&quot;)
 sb.append(f&quot;right: {self.r}\n&quot;)
 sb.append(f&quot;diffs: &quot;)
 for tag, i, j, k, l in self.diffs:
 s = f&quot;({iD})&quot;
 if iD &gt; 0: sb.append(' | ')
 if tag in ('delete', 'replace'): s = f'{s} l:{self.l[i:j]}'
 if tag in ('insert', 'replace'): s = f'{s} r:{self.r[k:l]}'
 sb.append(s)
 iD = iD + 1

 if verbose:
 sb.append(f&quot;\nequal: {self.equal}&quot;)
 return ''.join(sb)

 def __repr__(self) -&gt; str:
 return &quot;&lt;ListDiffer&gt; {}&quot;.format(self.__str__())
</code></pre>
Usage:
<pre><code>left = ['a','b','c']
right = ['aa','b','c','d']
# right = ('aa','b','c','d')
ld = ListDiffer(left, right, strict=True)
print(f'ld.has_diffs(): {ld.has_diffs()}')
print(f'ld: {ld}')
print(f'ld.only_left(): {ld.only_left()}')
print(f'ld.only_right(): {ld.only_right()}')
</code></pre>
Output:
<pre><code>ld.has_diffs(): True
ld: (0) l:['a'] r:['aa'] | (1) r:['d']
ld.only_left(): ['a']
ld.only_right(): ['aa', 'd']
</code></pre>
I cannot speak to performance but you could use <code>ld.only_left()</code> to get the result you are looking for.

I have two lists in Python, like these:
<pre><code>temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']
</code></pre>
I need to create a third list with items from the first list which aren't present in the second one. From the example I have to get
<pre><code>temp3 = ['Three', 'Four']
</code></pre>
Are there any fast ways without cycles and checking?

Get difference between two lists

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我在Python中有两个列表，如下所示：temp1 = ['One', 'Two', 'Three', 'Four']temp2 = ['One', 'Two']我需要用第一个列表中没有出现在第二个列表中的条目创建第三个列表。从这个例子中，我必须得到temp3 = ['Three', 'Four']有没有不需要循环和检...

问获取两个列表之间的差异
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取两个列表之间的差异EN