blocks|key|638593|text|如果你不关心项目的顺序或重复，可以使用set。如果您这样做，请使用list+comprehensions：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|638594|>>>+def+diff(first,+second):
++++++++second+=+set(second)
++++++++return+[item+for+item+in+first+if+item+not+in+second]

>>>+diff(A,+B)
[1,+3,+4]
>>>+diff(B,+A)
[5]
>>>+|code-block|syntax|javascript|638595|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/tutorial/datastructures.html#list-comprehensions^0|J|3|X|J|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

Use <code>set</code> if you don't care about items order or repetition. Use <a href="http://docs.python.org/tutorial/datastructures.html#list-comprehensions" rel="noreferrer">list comprehensions</a> if you do:

<pre><code>&gt;&gt;&gt; def diff(first, second):
 second = set(second)
 return [item for item in first if item not in second]

&gt;&gt;&gt; diff(A, B)
[1, 3, 4]
&gt;&gt;&gt; diff(B, A)
[5]
&gt;&gt;&gt; 
</code></pre>

blocks|key|855958|text|您可以执行以下操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|855959|list(set(A)-set(B))|code-block|syntax|javascript|855960|和|855961|list(set(B)-set(A))|855962|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|$]]

You can do a 

<pre><code>list(set(A)-set(B))
</code></pre>

and

<pre><code>list(set(B)-set(A))
</code></pre>

blocks|key|638612|text|一个线条：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|638613|diff+=+lambda+l1,l2:+[x+for+x+in+l1+if+x+not+in+l2]
diff(A,B)
diff(B,A)|code-block|syntax|javascript|638614|或者：|638615|diff+=+lambda+l1,l2:+filter(lambda+x:+x+not+in+l2,+l1)
diff(A,B)
diff(B,A)|638616|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|$]]

One liner:

<pre><code>diff = lambda l1,l2: [x for x in l1 if x not in l2]
diff(A,B)
diff(B,A)
</code></pre>

Or:

<pre><code>diff = lambda l1,l2: filter(lambda x: x not in l2, l1)
diff(A,B)
diff(B,A)
</code></pre>

blocks|key|638661|text|上面的例子使计算差异的问题变得微不足道。假设排序或重复数据删除肯定会使计算差异变得更容易，但如果您的比较无法承受这些假设，那么您将需要一个非平凡的diff算法实现。请参阅python标准库中的difflib。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|638662|#!+/usr/bin/python2
from+difflib+import+SequenceMatcher

A+=+[1,2,3,4]
B+=+[2,5]

squeeze=SequenceMatcher(+None,+A,+B+)

print+"A+-+B+=+[%25s]"%25(+reduce(+lambda+p,q:+p%2Bq,
+++++++++++++++++++++++++++++++map(+lambda+t:+squeeze.a[t[1]:t[2]],
++++++++++++++++++++++++++++++++++++filter(lambda+x:x[0]!='equal',
+++++++++++++++++++++++++++++++++++++++++++squeeze.get_opcodes()+)+)+)+)|code-block|syntax|javascript|638663|或者Python3..。|638664|#!+/usr/bin/python3
from+difflib+import+SequenceMatcher
from+functools+import+reduce

A+=+[1,2,3,4]
B+=+[2,5]

squeeze=SequenceMatcher(+None,+A,+B+)

print(+"A+-+B+=+[%25s]"%25(+reduce(+lambda+p,q:+p%2Bq,
+++++++++++++++++++++++++++++++map(+lambda+t:+squeeze.a[t[1]:t[2]],
++++++++++++++++++++++++++++++++++++filter(lambda+x:x[0]!='equal',
+++++++++++++++++++++++++++++++++++++++++++squeeze.get_opcodes()+)+)+)+)+)|638665|输出：|638666|A+-+B+=+[[1,+3,+4]]|638667|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|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The above examples trivialized the problem of calculating differences. Assuming sorting or de-duplication definitely make it easier to compute the difference, but if your comparison cannot afford those assumptions then you'll need a non-trivial implementation of a diff algorithm. See difflib in the python standard library.
<pre class="lang-py prettyprint-override"><code>#! /usr/bin/python2
from difflib import SequenceMatcher

A = [1,2,3,4]
B = [2,5]

squeeze=SequenceMatcher( None, A, B )

print &quot;A - B = [%s]&quot;%( reduce( lambda p,q: p+q,
 map( lambda t: squeeze.a[t[1]:t[2]],
 filter(lambda x:x[0]!='equal',
 squeeze.get_opcodes() ) ) ) )
</code></pre>
Or Python3...
<pre class="lang-py prettyprint-override"><code>#! /usr/bin/python3
from difflib import SequenceMatcher
from functools import reduce

A = [1,2,3,4]
B = [2,5]

squeeze=SequenceMatcher( None, A, B )

print( &quot;A - B = [%s]&quot;%( reduce( lambda p,q: p+q,
 map( lambda t: squeeze.a[t[1]:t[2]],
 filter(lambda x:x[0]!='equal',
 squeeze.get_opcodes() ) ) ) ) )

</code></pre>
Output:
<pre><code>A - B = [[1, 3, 4]]
</code></pre>

blocks|key|638777|text|A+=+[1,2,3,4]
B+=+[2,5]

#A+-+B
x+=+list(set(A)+-+set(B))
#B+-+A+
y+=+list(set(B)+-+set(A))

print+x
print+y+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|638778|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|$]]

<pre><code>A = [1,2,3,4]
B = [2,5]

#A - B
x = list(set(A) - set(B))
#B - A 
y = list(set(B) - set(A))

print x
print y 
</code></pre>

blocks|key|855951|text|您可能希望使用set而不是list。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|855952|entityMap^0|7|3|D|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

You would want to use a <code>set</code> instead of a <code>list</code>.

blocks|key|638729|text|如果您想以递归方式深入了解列表中的项，我为python：https://github.com/erasmose/deepdiff编写了一个包|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|638730|安装|638731|从PyPi安装：|638732|pip+install+deepdiff|code-block|syntax|javascript|638733|如果你是Python3用户，你还需要安装：|638734|pip+install+future+six|638735|示例用法|638736|>>>+from+deepdiff+import+DeepDiff
>>>+from+pprint+import+pprint
>>>+from+__future__+import+print_function|638737|同一对象返回空|638738|>>>+t1+=+{1:1,+2:2,+3:3}
>>>+t2+=+t1
>>>+ddiff+=+DeepDiff(t1,+t2)
>>>+print+(ddiff.changes)
++++{}|638739|项目的类型已更改|638740|>>>+t1+=+{1:1,+2:2,+3:3}
>>>+t2+=+{1:1,+2:"2",+3:3}
>>>+ddiff+=+DeepDiff(t1,+t2)
>>>+print+(ddiff.changes)
++++{'type_changes':+["root[2]:+2=<type+'int'>+vs.+2=<type+'str'>"]}|638741|项的值已更改|638742|>>>+t1+=+{1:1,+2:2,+3:3}
>>>+t2+=+{1:1,+2:4,+3:3}
>>>+ddiff+=+DeepDiff(t1,+t2)
>>>+print+(ddiff.changes)
++++{'values_changed':+['root[2]:+2+====>>+4']}|638743|添加和/或删除项目|638744|>>>+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.changes)
++++{'dic_item_added':+['root[5,+6]'],
+++++'dic_item_removed':+['root[4]'],
+++++'values_changed':+['root[2]:+2+====>>+4']}|638745|字符串差异|638746|>>>+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.changes,+indent+=+2)
++++{+'values_changed':+[+'root[2]:+2+====>>+4',
++++++++++++++++++++++++++"root[4]['b']:\n---+\n%2B%2B%2B+\n@@+-1+%2B1+@@\n-world\n%2Bworld!"]}
>>>
>>>+print+(ddiff.changes['values_changed'][1])
++++root[4]['b']:
++++---+
++++%2B%2B%2B+
++++@@+-1+%2B1+@@
++++-world
++++%2Bworld!|638747|字符串差异2|638748|>>>+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.changes,+indent+=+2)
++++{+'values_changed':+[+"root[4]['b']:\n---+\n%2B%2B%2B+\n@@+-1,5+%2B1,4+@@\n-world!\n-Goodbye!\n%2Bworld\n+1\n+2\n+End"]}
>>>
>>>+print+(ddiff.changes['values_changed'][0])
++++root[4]['b']:
++++---+
++++%2B%2B%2B+
++++@@+-1,5+%2B1,4+@@
++++-world!
++++-Goodbye!
++++%2Bworld
+++++1
+++++2
+++++End|638749|类型更改|638750|>>>+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.changes,+indent+=+2)
++++{+'type_changes':+[+"root[4]['b']:+[1,+2,+3]=<type+'list'>+vs.+world\n\n\nEnd=<type+'str'>"]}|638751|列表差异|638752|>>>+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,+2]}}
>>>+ddiff+=+DeepDiff(t1,+t2)
>>>+pprint+(ddiff.changes,+indent+=+2)
++++{+'list_removed':+["root[4]['b']:+[3]"]}|638753|列表差异2:请注意，它没有考虑顺序|638754|>>>+#+Note+that+it+DOES+NOT+take+order+into+account
...+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]}}
>>>+ddiff+=+DeepDiff(t1,+t2)
>>>+pprint+(ddiff.changes,+indent+=+2)
++++{+}|638755|包含字典的列表：|638756|>>>+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.changes,+indent+=+2)
++++{+'dic_item_removed':+["root[4]['b'][2][2]"],
++++++'values_changed':+["root[4]['b'][2][1]:+1+====>>+3"]}|638757|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/erasmose/deepdiff^0|S|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|@$1|2|3|4|5|6|7|26|8|@]|9|@$A|27|B|28|1|29]]|C|$]]|$1|D|3|E|5|6|7|2A|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|2B|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|2C|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|2D|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|2E|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|2F|8|@]|9|@]|C|$]]|$1|S|3|T|5|J|7|2G|8|@]|9|@]|C|$K|L]]|$1|U|3|V|5|6|7|2H|8|@]|9|@]|C|$]]|$1|W|3|X|5|J|7|2I|8|@]|9|@]|C|$K|L]]|$1|Y|3|Z|5|6|7|2J|8|@]|9|@]|C|$]]|$1|10|3|11|5|J|7|2K|8|@]|9|@]|C|$K|L]]|$1|12|3|13|5|6|7|2L|8|@]|9|@]|C|$]]|$1|14|3|15|5|J|7|2M|8|@]|9|@]|C|$K|L]]|$1|16|3|17|5|6|7|2N|8|@]|9|@]|C|$]]|$1|18|3|19|5|J|7|2O|8|@]|9|@]|C|$K|L]]|$1|1A|3|1B|5|6|7|2P|8|@]|9|@]|C|$]]|$1|1C|3|1D|5|J|7|2Q|8|@]|9|@]|C|$K|L]]|$1|1E|3|1F|5|6|7|2R|8|@]|9|@]|C|$]]|$1|1G|3|1H|5|J|7|2S|8|@]|9|@]|C|$K|L]]|$1|1I|3|1J|5|6|7|2T|8|@]|9|@]|C|$]]|$1|1K|3|1L|5|J|7|2U|8|@]|9|@]|C|$K|L]]|$1|1M|3|1N|5|6|7|2V|8|@]|9|@]|C|$]]|$1|1O|3|1P|5|J|7|2W|8|@]|9|@]|C|$K|L]]|$1|1Q|3|1R|5|6|7|2X|8|@]|9|@]|C|$]]|$1|1S|3|1T|5|J|7|2Y|8|@]|9|@]|C|$K|L]]|$1|1U|3|1V|5|6|7|2Z|8|@]|9|@]|C|$]]|$1|1W|3|1X|5|J|7|30|8|@]|9|@]|C|$K|L]]|$1|1Y|3|-4|5|6|7|31|8|@]|9|@]|C|$]]]|1Z|$20|$5|21|22|23|C|$24|25]]]]

In case you want the difference recursively going deep into items of your list, I have written a package for python: <a href="https://github.com/erasmose/deepdiff" rel="noreferrer">https://github.com/erasmose/deepdiff</a>

<h2>Installation</h2>

Install from PyPi:

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

If you are Python3 you need to also install:

<pre><code>pip install future six
</code></pre>

<h2>Example usage</h2>

<pre><code>&gt;&gt;&gt; from deepdiff import DeepDiff
&gt;&gt;&gt; from pprint import pprint
&gt;&gt;&gt; from __future__ import print_function
</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; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; print (ddiff.changes)
 {}
</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; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; print (ddiff.changes)
 {'type_changes': ["root[2]: 2=&lt;type 'int'&gt; vs. 2=&lt;type 'str'&gt;"]}
</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; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; print (ddiff.changes)
 {'values_changed': ['root[2]: 2 ====&gt;&gt; 4']}
</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.changes)
 {'dic_item_added': ['root[5, 6]'],
 'dic_item_removed': ['root[4]'],
 'values_changed': ['root[2]: 2 ====&gt;&gt; 4']}
</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.changes, indent = 2)
 { 'values_changed': [ 'root[2]: 2 ====&gt;&gt; 4',
 "root[4]['b']:\n--- \n+++ \n@@ -1 +1 @@\n-world\n+world!"]}
&gt;&gt;&gt;
&gt;&gt;&gt; print (ddiff.changes['values_changed'][1])
 root[4]['b']:
 --- 
 +++ 
 @@ -1 +1 @@
 -world
 +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.changes, indent = 2)
 { 'values_changed': [ "root[4]['b']:\n--- \n+++ \n@@ -1,5 +1,4 @@\n-world!\n-Goodbye!\n+world\n 1\n 2\n End"]}
&gt;&gt;&gt;
&gt;&gt;&gt; print (ddiff.changes['values_changed'][0])
 root[4]['b']:
 --- 
 +++ 
 @@ -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.changes, indent = 2)
 { 'type_changes': [ "root[4]['b']: [1, 2, 3]=&lt;type 'list'&gt; vs. world\n\n\nEnd=&lt;type 'str'&gt;"]}
</code></pre>

List difference

<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, 2]}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (ddiff.changes, indent = 2)
 { 'list_removed': ["root[4]['b']: [3]"]}
</code></pre>

List difference 2: Note that it DOES NOT take order into account

<pre><code>&gt;&gt;&gt; # Note that it DOES NOT take order into account
... 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]}}
&gt;&gt;&gt; ddiff = DeepDiff(t1, t2)
&gt;&gt;&gt; pprint (ddiff.changes, indent = 2)
 { }
</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.changes, indent = 2)
 { 'dic_item_removed': ["root[4]['b'][2][2]"],
 'values_changed': ["root[4]['b'][2][1]: 1 ====&gt;&gt; 3"]}
</code></pre>

blocks|key|638929|text|简单的代码，如果你想要多个项目，它会给你不同的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|638930|a=[1,2,3,3,4]
b=[2,4]
tmp+=+copy.deepcopy(a)
for+k+in+b:
++++if+k+in+tmp:
++++++++tmp.remove(k)
print(tmp)|code-block|syntax|javascript|638931|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|$]]

Simple code that gives you the difference with multiple items if you want that: 

<pre><code>a=[1,2,3,3,4]
b=[2,4]
tmp = copy.deepcopy(a)
for k in b:
 if k in tmp:
 tmp.remove(k)
print(tmp)
</code></pre>

blocks|key|856309|text|添加一个答案，以处理我们想要与重复有严格差异的情况，即，在第一个列表中有我们想要保留在结果中的重复。例如，为了得到，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|856310|[1,+1,+1,+2]+-+[1,+1]+-->+[1,+2]|code-block|syntax|javascript|856311|我们可以使用额外的计数器来实现优雅的差分函数。|856312|from+collections+import+Counter

def+diff(first,+second):
++++secondCntr+=+Counter(second)
++++second+=+set(second)
++++res+=+[]
++++for+i+in+first:
++++++++if+i+not+in+second:
++++++++++++res.append(i)
++++++++elif+i+in+secondCntr:
++++++++++++if+secondCntr[i]+>+0:
++++++++++++++++secondCntr[i]+-=+1
++++++++++++else:
++++++++++++++++res.append(i)++++++++
++++return+res|856313|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|$]]

Adding an answer to take care of the case where we want a strict difference with repetitions, i.e., there are repetitions in the first list that we want to keep in the result. e.g. to get,
<pre><code>[1, 1, 1, 2] - [1, 1] --&gt; [1, 2]
</code></pre>
We could use an additional counter to have an elegant difference function.
<pre><code>from collections import Counter

def diff(first, second):
 secondCntr = Counter(second)
 second = set(second)
 res = []
 for i in first:
 if i not in second:
 res.append(i)
 elif i in secondCntr:
 if secondCntr[i] &gt; 0:
 secondCntr[i] -= 1
 else:
 res.append(i) 
 return res
</code></pre>

blocks|key|639099|text|我在这个线程中看不到一个在A中保留重复的解决方案。当A的一个元素与B的一个元素匹配时，这个元素必须在B中删除，这样当相同的元素在A中再次出现时，如果这个元素在B中只出现一次，它就必须出现在差异中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|639100|def+diff(first,+second):
+++l2+=+list(second)
+++l3+=+[]
+++for+el+in+first:
++++++if+el+in+l2:
+++++++++l2.remove(el)
++++++else:
+++++++++l3+%2B=+[el]
+++return+l3

l1+=+[1,+2,+1,+3,+4]
l2+=+[1,+2,+3,+3]
diff(l1,+l2)
>>>+[1,+4]|code-block|syntax|javascript|639101|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|$]]

I don't see a solution in this thread that preserves duplication in A. When an element of A matches with an element of B, this element has to be removed in B so that when the same element occurs again in A, it has to appear in the difference if this element appears only once in B.
<pre><code>def diff(first, second):
 l2 = list(second)
 l3 = []
 for el in first:
 if el in l2:
 l2.remove(el)
 else:
 l3 += [el]
 return l3

l1 = [1, 2, 1, 3, 4]
l2 = [1, 2, 3, 3]
diff(l1, l2)
&gt;&gt;&gt; [1, 4]
</code></pre>

blocks|key|856208|text|当看一下In-operator的TimeComplexity时，在最坏的情况下，它与O(n)一起工作。即使是布景。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|856209|因此，当比较两个数组时，我们的TimeComplexity在最好的情况下是O(n)，在最坏的情况下是O(n%5E2)。|856210|另一种(但不幸的是更复杂的)解决方案，在最好和最坏的情况下都使用O(n)，是这样的：|856211|#+Compares+the+difference+of+list+a+and+b
#+uses+a+callback+function+to+compare+items
def+diff(a,+b,+callback):
++a_missing_in_b+=+[]
++ai+=+0
++bi+=+0

++a+=+sorted(a,+callback)
++b+=+sorted(b,+callback)

++while+(ai+<+len(a))+and+(bi+<+len(b)):

++++cmp+=+callback(a[ai],+b[bi])
++++if+cmp+<+0:
++++++a_missing_in_b.append(a[ai])
++++++ai+%2B=+1
++++elif+cmp+>+0:
++++++#+Item+b+is+missing+in+a
++++++bi+%2B=+1
++++else:
++++++#+a+and+b+intersecting+on+this+item
++++++ai+%2B=+1
++++++bi+%2B=+1

++#+if+a+and+b+are+not+of+same+length,+we+need+to+add+the+remaining+items
++for+ai+in+xrange(ai,+len(a)):
++++a_missing_in_b.append(a[ai])


++return+a_missing_in_b|code-block|syntax|javascript|856212|例如：|856213|>>>+a=[1,2,3]
>>>+b=[2,4,6]
>>>+diff(a,+b,+cmp)
[1,+3]|856214|entityMap|0|LINK|mutability|MUTABLE|url|https://wiki.python.org/moin/TimeComplexity^0|G|E|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|C|$K|L]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

When having a look at <a href="https://wiki.python.org/moin/TimeComplexity" rel="nofollow">TimeComplexity</a> of In-operator, in worst case it works with O(n). Even for Sets.

So when comparing two arrays we'll have a TimeComplexity of O(n) in best case and O(n^2) in worst case.

An alternative (but unfortunately more complex) solution, which works with O(n) in best and worst case is this one:

<pre><code># Compares the difference of list a and b
# uses a callback function to compare items
def diff(a, b, callback):
 a_missing_in_b = []
 ai = 0
 bi = 0

 a = sorted(a, callback)
 b = sorted(b, callback)

 while (ai &lt; len(a)) and (bi &lt; len(b)):

 cmp = callback(a[ai], b[bi])
 if cmp &lt; 0:
 a_missing_in_b.append(a[ai])
 ai += 1
 elif cmp &gt; 0:
 # Item b is missing in a
 bi += 1
 else:
 # a and b intersecting on this item
 ai += 1
 bi += 1

 # if a and b are not of same length, we need to add the remaining items
 for ai in xrange(ai, len(a)):
 a_missing_in_b.append(a[ai])


 return a_missing_in_b
</code></pre>

e.g.

<pre><code>&gt;&gt;&gt; a=[1,2,3]
&gt;&gt;&gt; b=[2,4,6]
&gt;&gt;&gt; diff(a, b, cmp)
[1, 3]
</code></pre>

In Python, what is the best way to compute the difference between two lists?

example

<pre><code>A = [1,2,3,4]
B = [2,5]

A - B = [1,3,4]
B - A = [5]
</code></pre>

Compute list difference

Python

在Python中，计算两个列表之间差异的最佳方法是什么？示例A = [1,2,3,4]B = [2,5]A - B = [1,3,4]B - A = [5]

问计算列表差异
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算列表差异EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算列表差异
EN