blocks|key|691882|text|在递归对象时，请考虑使用hasattr(obj,+'__iter__')。如果一个对象实现了你所知道的__iter__方法，你就可以遍历它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|691883|entityMap^0|C|O|1F|8|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|$]]

Consider using <code>hasattr(obj, '__iter__')</code> as you recurse through the object. If an object implements the <code>__iter__</code> method you know you can iterate over it.

blocks|key|908006|text|一种选择是将您运行的任何列表转换为以索引为键的字典。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908007|#+add+this+function+to+the+same+module
def+list_to_dict(l):
++++return+dict(zip(map(str,+range(len(l))),+l))|code-block|syntax|javascript|908008|​|908009|#+add+this+code+under+the+'if+type(d2[k])+==+dict'+block
++++++++++++++++++++elif+type(d2[k])+==+list:
++++++++++++++++++++++++dd(list_to_dict(d1[k]),+list_to_dict(d2[k]),+k)|908010|以下是您在注释中给出的示例字典的输出：|908011|>>>+d1+=+{"name":"Joe",+"Pets":[{"name":"spot",+"species":"dog"}]}
>>>+d2+=+{"name":"Joe",+"Pets":[{"name":"spot",+"species":"cat"}]}
>>>+dd(d1,+d2,+"base")
Changes+in+base
Changes+in+Pets
Changes+in+0
species+changed+in+d2+to+cat
Done+with+changes+in+0
Done+with+changes+in+Pets
Done+with+changes+in+base|908012|请注意，这将逐个索引进行比较，因此需要进行一些修改才能很好地处理添加或删除的列表项。|908013|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

One option would be to convert any lists you run into as dictionaries with the index as a key. For example:

<pre><code># add this function to the same module
def list_to_dict(l):
 return dict(zip(map(str, range(len(l))), l))
</code></pre>



<pre><code># add this code under the 'if type(d2[k]) == dict' block
 elif type(d2[k]) == list:
 dd(list_to_dict(d1[k]), list_to_dict(d2[k]), k)
</code></pre>

Here is the output with the sample dictionaries you gave in comments:

<pre><code>&gt;&gt;&gt; d1 = {"name":"Joe", "Pets":[{"name":"spot", "species":"dog"}]}
&gt;&gt;&gt; d2 = {"name":"Joe", "Pets":[{"name":"spot", "species":"cat"}]}
&gt;&gt;&gt; dd(d1, d2, "base")
Changes in base
Changes in Pets
Changes in 0
species changed in d2 to cat
Done with changes in 0
Done with changes in Pets
Done with changes in base
</code></pre>

Note that this will compare index by index, so it will need some modification to work well for list items being added or removed.

blocks|key|908062|text|您的函数应该从检查其参数的类型开始，编写函数以使其能够处理列表、字典、int和字符串。这样你就不需要复制任何东西，只需递归调用即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908063|Psuedocode：|908064|def+compare(d1,+d2):
+++++if+d1+and+d2+are+dicts
++++++++++++compare+the+keys,+pass+values+to+compare
+++++if+d1+and+d2+are+lists
++++++++++++compare+the+lists,+pass+values+to+compare
+++++if+d1+and+d2+are+strings/ints
++++++++++++compare+them|code-block|syntax|javascript|908065|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Your function should begin by checking the type of its arguments, write the function so that it can handle lists, dictionaries, ints, and strings. That way you don't have to duplicate anything, you just call recursively.

Psuedocode:

<pre><code>def compare(d1, d2):
 if d1 and d2 are dicts
 compare the keys, pass values to compare
 if d1 and d2 are lists
 compare the lists, pass values to compare
 if d1 and d2 are strings/ints
 compare them
</code></pre>

blocks|key|692073|text|如果您希望以递归方式实现差异，我已经为python编写了一个包：https://github.com/seperman/deepdiff|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|692074|安装|692075|从PyPi安装：|692076|pip+install+deepdiff|code-block|syntax|javascript|692077|示例用法|692078|正在导入|692079|>>>+from+deepdiff+import+DeepDiff
>>>+from+pprint+import+pprint
>>>+from+__future__+import+print_function+#+In+case+running+on+Python+2|692080|同一对象返回空|692081|>>>+t1+=+{1:1,+2:2,+3:3}
>>>+t2+=+t1
>>>+print(DeepDiff(t1,+t2))
{}|692082|项目的类型已更改|692083|>>>+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}}}|692084|项的值已更改|692085|>>>+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}}}|692086|添加和/或删除项目|692087|>>>+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}}}|692088|字符串差异|692089|>>>+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'}}}|692090|字符串差异2|692091|>>>+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|692092|类型更改|692093|>>>+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]}}}|692094|列表差异|692095|>>>+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}}|692096|列表差异2：|692097|>>>+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}}}|692098|忽略顺序或重复项的列表差异：(使用与上面相同的字典)|692099|>>>+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)
{}|692100|包含字典的列表：|692101|>>>+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}}}|692102|集合：|692103|>>>+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]']}|692104|命名元组：|692105|>>>+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}}}|692106|自定义对象：|692107|>>>+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}}}|692108|已添加对象属性：|692109|>>>+t2.c+=+"new+attribute"
>>>+pprint(DeepDiff(t1,+t2))
{'attribute_added':+['root.c'],
+'values_changed':+{'root.b':+{'newvalue':+2,+'oldvalue':+1}}}|692110|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|692200|text|自己做一些事情来练习和学习是一件很有趣的事情，但我发现对于非琐碎的任务，准备好的和维护的包通常工作得更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|692201|考虑转换成json，并使用一些像样的“语义”json比较器，比如https://www.npmjs.com/package/compare-json或online+http://jsondiff.com。将需要字符串数字密钥。|offset|length|692202|如果您确实需要的话，可以尝试将jsondiff转换为python。|692203|Conversion+from+JavaScript+to+Python+code?|692204|entityMap|0|LINK|mutability|MUTABLE|url|https://www.npmjs.com/package/compare-json|1|http://jsondiff.com/|2|https://stackoverflow.com/questions/2346584/conversion-from-javascript-to-python-code^0|0|W|16|0|2A|J|1|0|0|0|16|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]|$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]|T|$5|M|N|O|A|$P|U]]]]

It is fun to do something yourselves to practice and learn, yet I find that for non-trivial tasks, the ready and maintained packages often work better. 

Consider convert to json and use some decent "semantic" json comparator say <a href="https://www.npmjs.com/package/compare-json" rel="nofollow noreferrer">https://www.npmjs.com/package/compare-json</a> or online <a href="http://jsondiff.com" rel="nofollow noreferrer">http://jsondiff.com</a>. Would need stringify number key.

If you can try translate jsondiff to python if you really need.

<a href="https://stackoverflow.com/questions/2346584/conversion-from-javascript-to-python-code">Conversion from JavaScript to Python code?</a>

blocks|key|908301|text|正如Serge建议的那样，我发现这个解决方案有助于快速获得关于两个字典是否匹配的布尔返回：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908302|import+json

def+match(d1,+d2):
++++return+json.dumps(d1,+sort_keys=True)+==+json.dumps(d2,+sort_keys=True)|code-block|syntax|javascript|908303|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|$]]

As suggested by Serge I found this solution helpful to get a quick boolean return on whether two dictionaries match "all the way down":

<pre><code>import json

def match(d1, d2):
 return json.dumps(d1, sort_keys=True) == json.dumps(d2, sort_keys=True)
</code></pre>

blocks|key|908331|text|下面是一个受Winston+Ewert启发的实现|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|908332|def+recursive_compare(d1,+d2,+level='root'):
++++if+isinstance(d1,+dict)+and+isinstance(d2,+dict):
++++++++if+d1.keys()+!=+d2.keys():
++++++++++++s1+=+set(d1.keys())
++++++++++++s2+=+set(d2.keys())
++++++++++++print('{:<20}+%2B+{}+-+{}'.format(level,+s1-s2,+s2-s1))
++++++++++++common_keys+=+s1+&+s2
++++++++else:
++++++++++++common_keys+=+set(d1.keys())

++++++++for+k+in+common_keys:
++++++++++++recursive_compare(d1[k],+d2[k],+level='{}.{}'.format(level,+k))

++++elif+isinstance(d1,+list)+and+isinstance(d2,+list):
++++++++if+len(d1)+!=+len(d2):
++++++++++++print('{:<20}+len1={};+len2={}'.format(level,+len(d1),+len(d2)))
++++++++common_len+=+min(len(d1),+len(d2))

++++++++for+i+in+range(common_len):
++++++++++++recursive_compare(d1[i],+d2[i],+level='{}[{}]'.format(level,+i))

++++else:
++++++++if+d1+!=+d2:
++++++++++++print('{:<20}+{}+!=+{}'.format(level,+d1,+d2))

if+__name__+==+'__main__':
++++d1={'a':[0,2,3,8],+'b':0,+'d':{'da':7,+'db':[99,88]}}
++++d2={'a':[0,2,4],+'c':0,+'d':{'da':3,+'db':7}}

++++recursive_compare(d1,+d2)|code-block|syntax|javascript|908333|将返回：|908334|root+++++++++++++++++%2B+{'b'}+-+{'c'}
root.a+++++++++++++++len1=4;+len2=3
root.a[2]++++++++++++3+!=+4
root.d.db++++++++++++[99,+88]+!=+7
root.d.da++++++++++++7+!=+3|908335|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5904485/6284645^0|6|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Here's an implementation inspired by <a href="https://stackoverflow.com/a/5904485/6284645">Winston Ewert</a>

<pre><code>def recursive_compare(d1, d2, level='root'):
 if isinstance(d1, dict) and isinstance(d2, dict):
 if d1.keys() != d2.keys():
 s1 = set(d1.keys())
 s2 = set(d2.keys())
 print('{:&lt;20} + {} - {}'.format(level, s1-s2, s2-s1))
 common_keys = s1 &amp; s2
 else:
 common_keys = set(d1.keys())

 for k in common_keys:
 recursive_compare(d1[k], d2[k], level='{}.{}'.format(level, k))

 elif isinstance(d1, list) and isinstance(d2, list):
 if len(d1) != len(d2):
 print('{:&lt;20} len1={}; len2={}'.format(level, len(d1), len(d2)))
 common_len = min(len(d1), len(d2))

 for i in range(common_len):
 recursive_compare(d1[i], d2[i], level='{}[{}]'.format(level, i))

 else:
 if d1 != d2:
 print('{:&lt;20} {} != {}'.format(level, d1, d2))

if __name__ == '__main__':
 d1={'a':[0,2,3,8], 'b':0, 'd':{'da':7, 'db':[99,88]}}
 d2={'a':[0,2,4], 'c':0, 'd':{'da':3, 'db':7}}

 recursive_compare(d1, d2)
</code></pre>

will return:

<pre><code>root + {'b'} - {'c'}
root.a len1=4; len2=3
root.a[2] 3 != 4
root.d.db [99, 88] != 7
root.d.da 7 != 3
</code></pre>

blocks|key|908399|text|您可以尝试以下简单的实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908400|def+recursive_compare(obj1,+obj2):
"""+Compare+python+objects+recursively,+support+type:
"int,+float,+long,+basestring,+set,+datetime,+date,+dict,+Sequence"

Example:
>>>+recursive_compare([1,+2,+3],+[1,+2,+3])
>>>+True
>>>+recursive_compare([1,+2,+3],+[1,+2,+4])
>>>+False
>>>+recursive_compare({'a':+1},+{'a':+2})
>>>+False
"""

def+_diff(obj1,+obj2):
++++#+exclude+type+basestring+for+backward-compatible+python2:
++++#+<str,+unicode>
++++if+type(obj1)+!=+type(obj2)+and+not+isinstance(obj1,+basestring):
++++++++return+False

++++elif+isinstance(obj1,
++++++++++++++++++++(int,+float,+long,+basestring,+set,+datetime,+date)):
++++++++if+obj1+!=+obj2:
++++++++++++return+False

++++elif+isinstance(obj1,+dict):
++++++++keys+=+obj1.viewkeys()+&+obj2.viewkeys()
++++++++if+obj1+and+len(keys)+==+0+\
++++++++++++or+keys.difference(set(obj1.keys()))+\
++++++++++++++++or+keys.difference(set(obj2.keys())):
++++++++++++return+False

++++++++for+k+in+keys:
++++++++++++if+_diff(obj1[k],+obj2[k])+is+False:
++++++++++++++++return+False

++++elif+isinstance(obj1,+collections.Sequence):
++++++++#+require+sorted+sequence+object
++++++++if+len(obj1)+!=+len(obj2):
++++++++++++return+False

++++++++for+i+in+range(len(obj1)):
++++++++++++if+_diff(obj1[i],+obj2[i])+is+False:
++++++++++++++++return+False

++++else:
++++++++raise+TypeError('do+not+support+type+{}+to+compare'.format(
++++++++++++type(obj1)))

return+False+if+_diff(obj1,+obj2)+is+False+else+True|code-block|syntax|javascript|908401|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 try the following simple implementation

<pre><code>def recursive_compare(obj1, obj2):
""" Compare python objects recursively, support type:
"int, float, long, basestring, set, datetime, date, dict, Sequence"

Example:
&gt;&gt;&gt; recursive_compare([1, 2, 3], [1, 2, 3])
&gt;&gt;&gt; True
&gt;&gt;&gt; recursive_compare([1, 2, 3], [1, 2, 4])
&gt;&gt;&gt; False
&gt;&gt;&gt; recursive_compare({'a': 1}, {'a': 2})
&gt;&gt;&gt; False
"""

def _diff(obj1, obj2):
 # exclude type basestring for backward-compatible python2:
 # &lt;str, unicode&gt;
 if type(obj1) != type(obj2) and not isinstance(obj1, basestring):
 return False

 elif isinstance(obj1,
 (int, float, long, basestring, set, datetime, date)):
 if obj1 != obj2:
 return False

 elif isinstance(obj1, dict):
 keys = obj1.viewkeys() &amp; obj2.viewkeys()
 if obj1 and len(keys) == 0 \
 or keys.difference(set(obj1.keys())) \
 or keys.difference(set(obj2.keys())):
 return False

 for k in keys:
 if _diff(obj1[k], obj2[k]) is False:
 return False

 elif isinstance(obj1, collections.Sequence):
 # require sorted sequence object
 if len(obj1) != len(obj2):
 return False

 for i in range(len(obj1)):
 if _diff(obj1[i], obj2[i]) is False:
 return False

 else:
 raise TypeError('do not support type {} to compare'.format(
 type(obj1)))

return False if _diff(obj1, obj2) is False else True
</code></pre>

So I have a python dictionary, call it <code>d1</code>, and a version of that dictionary at a later point in time, call it <code>d2</code>. I want to find all the changes between <code>d1</code> and <code>d2</code>. In other words, everything that was added, removed or changed. The tricky bit is that the values can be ints, strings, lists, or dicts, so it needs to be recursive. This is what I have so far:

<pre><code>def dd(d1, d2, ctx=""):
 print "Changes in " + ctx
 for k in d1:
 if k not in d2:
 print k + " removed from d2"
 for k in d2:
 if k not in d1:
 print k + " added in d2"
 continue
 if d2[k] != d1[k]:
 if type(d2[k]) not in (dict, list):
 print k + " changed in d2 to " + str(d2[k])
 else:
 if type(d1[k]) != type(d2[k]):
 print k + " changed to " + str(d2[k])
 continue
 else:
 if type(d2[k]) == dict:
 dd(d1[k], d2[k], k)
 continue
 print "Done with changes in " + ctx
 return
</code></pre>

It works just fine unless the value is a list. I cant quite come up with an elegant way to deal with lists, without having a huge, slightly changed version of this function repeated after a <code>if(type(d2) == list)</code>. 

Any thoughts?

EDIT: This differs from <a href="https://stackoverflow.com/questions/4197312/diff-multidimensional-dictionaries-in-python" title="this post">this post</a> because the keys can change

Recursive diff of two dictionaries (keys and values)?

Python

所以我有一个python字典，称为d1，稍后还有一个版本，称为d2。我想找出d1和d2之间的所有变化。换句话说，所有添加、删除或更改的内容。棘手的一点是，值可以是it、string、list或dict，因此它需要是递归的。这就是我到目前为止所知道的：def dd(d1, d2, ctx=""):    print "C...

问两个字典(键和值)的递归比较？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问两个字典(键和值)的递归比较？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问两个字典(键和值)的递归比较？
EN