blocks|key|3802993|text|这将有助于将dict2中的所有项目合并到dict1中|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3802994|for+item+in+dict2:
++++if+item+in+dict1:
++++++++for+leaf+in+dict2[item]:
++++++++++++dict1[item][leaf]+=+dict2[item][leaf]
++++else:
++++++++dict1[item]+=+dict2[item]|code-block|syntax|javascript|3802995|请测试一下，并告诉我们这是否是您想要的。|3802996|编辑：|BOLD|3802997|上面提到的解决方案只合并了一个级别，但正确地解决了OP给出的示例。要合并多个级别，应使用递归。|3802998|entityMap^0|6|5|K|5|0|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Z|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|10|8|@$9|11|A|12|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|13|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|S|$]]

This should help in merging all items from <code>dict2</code> into <code>dict1</code>:

<pre><code>for item in dict2:
 if item in dict1:
 for leaf in dict2[item]:
 dict1[item][leaf] = dict2[item][leaf]
 else:
 dict1[item] = dict2[item]
</code></pre>

Please test it and tell us whether this is what you wanted.

EDIT:

The above mentioned solution merges only one level, but correctly solves the example given by OP. To merge multiple levels, the recursion should be used.

blocks|key|3803041|text|这实际上是相当棘手的--特别是当你想要一个有用的错误消息时，当事情不一致的时候，同时正确地接受重复但一致的条目(这是这里没有其他答案做的……)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3803042|假设你没有大量的条目，递归函数是最简单的：|3803043|def+merge(a,+b,+path=None):
++++"merges+b+into+a"
++++if+path+is+None:+path+=+[]
++++for+key+in+b:
++++++++if+key+in+a:
++++++++++++if+isinstance(a[key],+dict)+and+isinstance(b[key],+dict):
++++++++++++++++merge(a[key],+b[key],+path+%2B+[str(key)])
++++++++++++elif+a[key]+==+b[key]:
++++++++++++++++pass+#+same+leaf+value
++++++++++++else:
++++++++++++++++raise+Exception('Conflict+at+%25s'+%25+'.'.join(path+%2B+[str(key)]))
++++++++else:
++++++++++++a[key]+=+b[key]
++++return+a

#+works
print(merge({1:{"a":"A"},2:{"b":"B"}},+{2:{"c":"C"},3:{"d":"D"}}))
#+has+conflict
merge({1:{"a":"A"},2:{"b":"B"}},+{1:{"a":"A"},2:{"b":"C"}})|code-block|syntax|javascript|3803044|请注意，这会使a发生变化--+b的内容会添加到a中(也会返回)。如果你想保留a，你可以叫它merge(dict(a),+b)。|offset|length|style|CODE|3803045|agf指出(如下)，你可能有两个以上的字典，在这种情况下，你可以使用：|3803046|reduce(merge,+[dict1,+dict2,+dict3...])|3803047|其中所有内容都将添加到dict1中。|3803048|注意--我编辑了我的初始答案，修改了第一个参数；这使得"reduce“更容易解释|3803049|ps在Python3中，您还需要from+functools+import+reduce|3803050|entityMap^0|0|0|0|7|1|F|1|N|1|12|1|19|H|0|0|0|0|0|G|S|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|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@$K|14|L|15|M|N]|$K|16|L|17|M|N]|$K|18|L|19|M|N]|$K|1A|L|1B|M|N]|$K|1C|L|1D|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1F|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1I|8|@$K|1J|L|1K|M|N]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|Z|$]]

this is actually quite tricky - particularly if you want a useful error message when things are inconsistent, while correctly accepting duplicate but consistent entries (something no other answer here does....)

assuming you don't have huge numbers of entries a recursive function is easiest:

<pre><code>def merge(a, b, path=None):
 "merges b into a"
 if path is None: path = []
 for key in b:
 if key in a:
 if isinstance(a[key], dict) and isinstance(b[key], dict):
 merge(a[key], b[key], path + [str(key)])
 elif a[key] == b[key]:
 pass # same leaf value
 else:
 raise Exception('Conflict at %s' % '.'.join(path + [str(key)]))
 else:
 a[key] = b[key]
 return a

# works
print(merge({1:{"a":"A"},2:{"b":"B"}}, {2:{"c":"C"},3:{"d":"D"}}))
# has conflict
merge({1:{"a":"A"},2:{"b":"B"}}, {1:{"a":"A"},2:{"b":"C"}})
</code></pre>

note that this mutates <code>a</code> - the contents of <code>b</code> are added to <code>a</code> (which is also returned). if you want to keep <code>a</code> you could call it like <code>merge(dict(a), b)</code>.

agf pointed out (below) that you may have more than two dicts, in which case you can use:

<pre><code>reduce(merge, [dict1, dict2, dict3...])
</code></pre>

where everything will be added to dict1.

[note - i edited my initial answer to mutate the first argument; that makes the "reduce" easier to explain]

ps in python 3, you will also need <code>from functools import reduce</code>

blocks|key|3803059|text|如果你有一个未知级别的字典，那么我建议使用递归函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3803060|def+combineDicts(dictionary1,+dictionary2):
++++output+=+{}
++++for+item,+value+in+dictionary1.iteritems():
++++++++if+dictionary2.has_key(item):
++++++++++++if+isinstance(dictionary2[item],+dict):
++++++++++++++++output[item]+=+combineDicts(value,+dictionary2.pop(item))
++++++++else:
++++++++++++output[item]+=+value
++++for+item,+value+in+dictionary2.iteritems():
+++++++++output[item]+=+value
++++return+output|code-block|syntax|javascript|3803061|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 have an unknown level of dictionaries, then I would suggest a recursive function:

<pre><code>def combineDicts(dictionary1, dictionary2):
 output = {}
 for item, value in dictionary1.iteritems():
 if dictionary2.has_key(item):
 if isinstance(dictionary2[item], dict):
 output[item] = combineDicts(value, dictionary2.pop(item))
 else:
 output[item] = value
 for item, value in dictionary2.iteritems():
 output[item] = value
 return output
</code></pre>

blocks|key|327255|text|这里有一个使用生成器的简单方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|327256|def+mergedicts(dict1,+dict2):
++++for+k+in+set(dict1.keys()).union(dict2.keys()):
++++++++if+k+in+dict1+and+k+in+dict2:
++++++++++++if+isinstance(dict1[k],+dict)+and+isinstance(dict2[k],+dict):
++++++++++++++++yield+(k,+dict(mergedicts(dict1[k],+dict2[k])))
++++++++++++else:
++++++++++++++++#+If+one+of+the+values+is+not+a+dict,+you+can't+continue+merging+it.
++++++++++++++++#+Value+from+second+dict+overrides+one+in+first+and+we+move+on.
++++++++++++++++yield+(k,+dict2[k])
++++++++++++++++#+Alternatively,+replace+this+with+exception+raiser+to+alert+you+of+value+conflicts
++++++++elif+k+in+dict1:
++++++++++++yield+(k,+dict1[k])
++++++++else:
++++++++++++yield+(k,+dict2[k])

dict1+=+{1:{"a":"A"},2:{"b":"B"}}
dict2+=+{2:{"c":"C"},3:{"d":"D"}}

print+dict(mergedicts(dict1,dict2))|code-block|syntax|javascript|327257|这将打印：|327258|{1:+{'a':+'A'},+2:+{'c':+'C',+'b':+'B'},+3:+{'d':+'D'}}|327259|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|$]]

Here's an easy way to do it using generators:

<pre><code>def mergedicts(dict1, dict2):
 for k in set(dict1.keys()).union(dict2.keys()):
 if k in dict1 and k in dict2:
 if isinstance(dict1[k], dict) and isinstance(dict2[k], dict):
 yield (k, dict(mergedicts(dict1[k], dict2[k])))
 else:
 # If one of the values is not a dict, you can't continue merging it.
 # Value from second dict overrides one in first and we move on.
 yield (k, dict2[k])
 # Alternatively, replace this with exception raiser to alert you of value conflicts
 elif k in dict1:
 yield (k, dict1[k])
 else:
 yield (k, dict2[k])

dict1 = {1:{"a":"A"},2:{"b":"B"}}
dict2 = {2:{"c":"C"},3:{"d":"D"}}

print dict(mergedicts(dict1,dict2))
</code></pre>

This prints:

<pre><code>{1: {'a': 'A'}, 2: {'c': 'C', 'b': 'B'}, 3: {'d': 'D'}}
</code></pre>

blocks|key|3803140|text|当然，代码将取决于解决合并冲突的规则。这里有一个版本，它可以接受任意数量的参数，并将它们递归合并到任意深度，而不使用任何对象突变。它使用以下规则来解决合并冲突：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3803141|3803142|字典优先于非dict值({"foo":+{...}}优先于参数优先于早期参数(如果按顺序合并{"a":+1}、{"a",+2}和{"a":+3}，则结果将为{"a":+3})|unordered-list-item|offset|length|style|CODE|3803143|3803144|try:
++++from+collections+import+Mapping
except+ImportError:
++++Mapping+=+dict

def+merge_dicts(*dicts):++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++"""+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++Return+a+new+dictionary+that+is+the+result+of+merging+the+arguments+together.+++
++++In+case+of+conflicts,+later+arguments+take+precedence+over+earlier+arguments.+++
++++"""+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++updated+=+{}++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++#+grab+all+keys+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++keys+=+set()++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++for+d+in+dicts:+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++keys+=+keys.union(set(d))+++++++++++++++++++++++++++++++++++++++++++++++++++

++++for+key+in+keys:++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++values+=+[d[key]+for+d+in+dicts+if+key+in+d]++++++++++++++++++++++++++++++++
++++++++#+which+ones+are+mapping+types?+(aka+dict)++++++++++++++++++++++++++++++++++
++++++++maps+=+[value+for+value+in+values+if+isinstance(value,+Mapping)]++++++++++++
++++++++if+maps:++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++#+if+we+have+any+mapping+types,+call+recursively+to+merge+them++++++++++
++++++++++++updated[key]+=+merge_dicts(*maps)+++++++++++++++++++++++++++++++++++++++
++++++++else:+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++#+otherwise,+just+grab+the+last+value+we+have,+since+later+arguments++++
++++++++++++#+take+precedence+over+earlier+arguments++++++++++++++++++++++++++++++++
++++++++++++updated[key]+=+values[-1]+++++++++++++++++++++++++++++++++++++++++++++++
++++return+updated++|code-block|syntax|javascript|3803145|entityMap^0|0|0|C|E|1A|8|1J|8|1S|8|26|8|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|T|8|@$F|U|G|V|H|I]|$F|W|G|X|H|I]|$F|Y|G|Z|H|I]|$F|10|G|11|H|I]|$F|12|G|13|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|15|8|@]|9|@]|A|$N|O]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|Q|$]]

The code will depend on your rules for resolving merge conflicts, of course. Here's a version which can take an arbitrary number of arguments and merges them recursively to an arbitrary depth, without using any object mutation. It uses the following rules to resolve merge conflicts:

<ul>
<li>dictionaries take precedence over non-dict values (<code>{"foo": {...}}</code> takes precedence over <code>{"foo": "bar"}</code>)</li>
<li>later arguments take precedence over earlier arguments (if you merge <code>{"a": 1}</code>, <code>{"a", 2}</code>, and <code>{"a": 3}</code> in order, the result will be <code>{"a": 3}</code>)</li>
</ul>

<pre class="lang-python prettyprint-override"><code>try:
 from collections import Mapping
except ImportError:
 Mapping = dict

def merge_dicts(*dicts): 
 """ 
 Return a new dictionary that is the result of merging the arguments together. 
 In case of conflicts, later arguments take precedence over earlier arguments. 
 """ 
 updated = {} 
 # grab all keys 
 keys = set() 
 for d in dicts: 
 keys = keys.union(set(d)) 

 for key in keys: 
 values = [d[key] for d in dicts if key in d] 
 # which ones are mapping types? (aka dict) 
 maps = [value for value in values if isinstance(value, Mapping)] 
 if maps: 
 # if we have any mapping types, call recursively to merge them 
 updated[key] = merge_dicts(*maps) 
 else: 
 # otherwise, just grab the last value we have, since later arguments 
 # take precedence over earlier arguments 
 updated[key] = values[-1] 
 return updated 
</code></pre>

blocks|key|326035|text|我一直在测试您的解决方案，并决定在我的项目中使用此解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326036|def+mergedicts(dict1,+dict2,+conflict,+no_conflict):
++++for+k+in+set(dict1.keys()).union(dict2.keys()):
++++++++if+k+in+dict1+and+k+in+dict2:
++++++++++++yield+(k,+conflict(dict1[k],+dict2[k]))
++++++++elif+k+in+dict1:
++++++++++++yield+(k,+no_conflict(dict1[k]))
++++++++else:
++++++++++++yield+(k,+no_conflict(dict2[k]))

dict1+=+{1:{"a":"A"},+2:{"b":"B"}}
dict2+=+{2:{"c":"C"},+3:{"d":"D"}}

#this+helper+function+allows+for+recursion+and+the+use+of+reduce
def+f2(x,+y):
++++return+dict(mergedicts(x,+y,+f2,+lambda+x:+x))

print+dict(mergedicts(dict1,+dict2,+f2,+lambda+x:+x))
print+dict(reduce(f2,+[dict1,+dict2]))|code-block|syntax|javascript|326037|将函数作为参数传递是扩展jterrace解决方案以表现为所有其他递归解决方案的关键。|326038|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|$]]

I've been testing your solutions and decided to use this one in my project:

<pre><code>def mergedicts(dict1, dict2, conflict, no_conflict):
 for k in set(dict1.keys()).union(dict2.keys()):
 if k in dict1 and k in dict2:
 yield (k, conflict(dict1[k], dict2[k]))
 elif k in dict1:
 yield (k, no_conflict(dict1[k]))
 else:
 yield (k, no_conflict(dict2[k]))

dict1 = {1:{"a":"A"}, 2:{"b":"B"}}
dict2 = {2:{"c":"C"}, 3:{"d":"D"}}

#this helper function allows for recursion and the use of reduce
def f2(x, y):
 return dict(mergedicts(x, y, f2, lambda x: x))

print dict(mergedicts(dict1, dict2, f2, lambda x: x))
print dict(reduce(f2, [dict1, dict2]))
</code></pre>

Passing functions as parameteres is key to extend jterrace solution to behave as all the other recursive solutions.

blocks|key|327310|text|这个问题的一个问题是，字典的值可以是任意复杂的数据片段。基于这些和其他答案，我想出了这个代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|327311|class+YamlReaderError(Exception):
++++pass

def+data_merge(a,+b):
++++"""merges+b+into+a+and+return+merged+result

++++NOTE:+tuples+and+arbitrary+objects+are+not+handled+as+it+is+totally+ambiguous+what+should+happen"""
++++key+=+None
++++#+##+debug+output
++++#+sys.stderr.write("DEBUG:+%25s+to+%25s\n"+%25(b,a))
++++try:
++++++++if+a+is+None+or+isinstance(a,+str)+or+isinstance(a,+unicode)+or+isinstance(a,+int)+or+isinstance(a,+long)+or+isinstance(a,+float):
++++++++++++#+border+case+for+first+run+or+if+a+is+a+primitive
++++++++++++a+=+b
++++++++elif+isinstance(a,+list):
++++++++++++#+lists+can+be+only+appended
++++++++++++if+isinstance(b,+list):
++++++++++++++++#+merge+lists
++++++++++++++++a.extend(b)
++++++++++++else:
++++++++++++++++#+append+to+list
++++++++++++++++a.append(b)
++++++++elif+isinstance(a,+dict):
++++++++++++#+dicts+must+be+merged
++++++++++++if+isinstance(b,+dict):
++++++++++++++++for+key+in+b:
++++++++++++++++++++if+key+in+a:
++++++++++++++++++++++++a[key]+=+data_merge(a[key],+b[key])
++++++++++++++++++++else:
++++++++++++++++++++++++a[key]+=+b[key]
++++++++++++else:
++++++++++++++++raise+YamlReaderError('Cannot+merge+non-dict+"%25s"+into+dict+"%25s"'+%25+(b,+a))
++++++++else:
++++++++++++raise+YamlReaderError('NOT+IMPLEMENTED+"%25s"+into+"%25s"'+%25+(b,+a))
++++except+TypeError,+e:
++++++++raise+YamlReaderError('TypeError+"%25s"+in+key+"%25s"+when+merging+"%25s"+into+"%25s"'+%25+(e,+key,+b,+a))
++++return+a|code-block|syntax|javascript|327312|我的用例是merging+YAML+files，我只需要处理可能的数据类型的一个子集。因此，我可以忽略元组和其他对象。对我来说，合理的合并逻辑意味着|offset|length|327313|327314|replace+scalars|unordered-list-item|327315|append+lists|327316|merge+dicts+by+adding+missing+keys+|327317|+updating+keys|327318|所有其他的和不可预见的事情都会导致错误。|327319|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ImmobilienScout24/yamlreader^0|0|0|5|I|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@$I|17|J|18|1|19]]|A|$]]|$1|K|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|N|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|N|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

One issue with this question is that the values of the dict can be arbitrarily complex pieces of data. Based upon these and other answers I came up with this code:


<pre><code>class YamlReaderError(Exception):
 pass

def data_merge(a, b):
 """merges b into a and return merged result

 NOTE: tuples and arbitrary objects are not handled as it is totally ambiguous what should happen"""
 key = None
 # ## debug output
 # sys.stderr.write("DEBUG: %s to %s\n" %(b,a))
 try:
 if a is None or isinstance(a, str) or isinstance(a, unicode) or isinstance(a, int) or isinstance(a, long) or isinstance(a, float):
 # border case for first run or if a is a primitive
 a = b
 elif isinstance(a, list):
 # lists can be only appended
 if isinstance(b, list):
 # merge lists
 a.extend(b)
 else:
 # append to list
 a.append(b)
 elif isinstance(a, dict):
 # dicts must be merged
 if isinstance(b, dict):
 for key in b:
 if key in a:
 a[key] = data_merge(a[key], b[key])
 else:
 a[key] = b[key]
 else:
 raise YamlReaderError('Cannot merge non-dict "%s" into dict "%s"' % (b, a))
 else:
 raise YamlReaderError('NOT IMPLEMENTED "%s" into "%s"' % (b, a))
 except TypeError, e:
 raise YamlReaderError('TypeError "%s" in key "%s" when merging "%s" into "%s"' % (e, key, b, a))
 return a
</code></pre>

My use case is <a href="https://github.com/ImmobilienScout24/yamlreader">merging YAML files</a> where I only have to deal with a subset of possible data types. Hence I can ignore tuples and other objects. For me a sensible merge logic means

<ul>
<li>replace scalars</li>
<li>append lists</li>
<li>merge dicts by adding missing keys and updating existing keys</li>
</ul>

Everything else and the unforeseens results in an error.

blocks|key|327339|text|这个版本的函数将占用N个字典，并且只有字典--不能传递任何不正确的参数，否则它将引发TypeError。合并本身考虑了键冲突，它不是覆盖字典中进一步向下合并的数据，而是创建一组值并附加到其中；不会丢失任何数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|327340|它可能不是页面上最有效的，但它是最全面的，当你合并你的2到N个字典时，你不会丢失任何信息。|327341|def+merge_dicts(*dicts):
++++if+not+reduce(lambda+x,+y:+isinstance(y,+dict)+and+x,+dicts,+True):
++++++++raise+TypeError,+"Object+in+*dicts+not+of+type+dict"
++++if+len(dicts)+<+2:
++++++++raise+ValueError,+"Requires+2+or+more+dict+objects"


++++def+merge(a,+b):
++++++++for+d+in+set(a.keys()).union(b.keys()):
++++++++++++if+d+in+a+and+d+in+b:
++++++++++++++++if+type(a[d])+==+type(b[d]):
++++++++++++++++++++if+not+isinstance(a[d],+dict):
++++++++++++++++++++++++ret+=+list({a[d],+b[d]})
++++++++++++++++++++++++if+len(ret)+==+1:+ret+=+ret[0]
++++++++++++++++++++++++yield+(d,+sorted(ret))
++++++++++++++++++++else:
++++++++++++++++++++++++yield+(d,+dict(merge(a[d],+b[d])))
++++++++++++++++else:
++++++++++++++++++++raise+TypeError,+"Conflicting+key:value+type+assignment"
++++++++++++elif+d+in+a:
++++++++++++++++yield+(d,+a[d])
++++++++++++elif+d+in+b:
++++++++++++++++yield+(d,+b[d])
++++++++++++else:
++++++++++++++++raise+KeyError

++++return+reduce(lambda+x,+y:+dict(merge(x,+y)),+dicts[1:],+dicts[0])

print+merge_dicts({1:1,2:{1:2}},{1:2,2:{3:1}},{4:4})|code-block|syntax|javascript|327342|输出：{1:+1，2，2：{1:+2，3:+1}，4:+4}|327343|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This version of the function will account for N number of dictionaries, and only dictionaries -- no improper parameters can be passed, or it will raise a TypeError. The merge itself accounts for key conflicts, and instead of overwriting data from a dictionary further down the merge chain, it creates a set of values and appends to that; no data is lost.

It might not be the most effecient on the page, but it's the most thorough and you're not going to lose any information when you merge your 2 to N dicts.

<pre><code>def merge_dicts(*dicts):
 if not reduce(lambda x, y: isinstance(y, dict) and x, dicts, True):
 raise TypeError, "Object in *dicts not of type dict"
 if len(dicts) &lt; 2:
 raise ValueError, "Requires 2 or more dict objects"


 def merge(a, b):
 for d in set(a.keys()).union(b.keys()):
 if d in a and d in b:
 if type(a[d]) == type(b[d]):
 if not isinstance(a[d], dict):
 ret = list({a[d], b[d]})
 if len(ret) == 1: ret = ret[0]
 yield (d, sorted(ret))
 else:
 yield (d, dict(merge(a[d], b[d])))
 else:
 raise TypeError, "Conflicting key:value type assignment"
 elif d in a:
 yield (d, a[d])
 elif d in b:
 yield (d, b[d])
 else:
 raise KeyError

 return reduce(lambda x, y: dict(merge(x, y)), dicts[1:], dicts[0])

print merge_dicts({1:1,2:{1:2}},{1:2,2:{3:1}},{4:4})
</code></pre>

output: {1: [1, 2], 2: {1: 2, 3: 1}, 4: 4}

blocks|key|2189665|text|我能想到的最简单的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2189666|#!/usr/bin/python

from+copy+import+deepcopy
def+dict_merge(a,+b):
++++if+not+isinstance(b,+dict):
++++++++return+b
++++result+=+deepcopy(a)
++++for+k,+v+in+b.iteritems():
++++++++if+k+in+result+and+isinstance(result[k],+dict):
++++++++++++++++result[k]+=+dict_merge(result[k],+v)
++++++++else:
++++++++++++result[k]+=+deepcopy(v)
++++return+result

a+=+{1:{"a":'A'},+2:{"b":'B'}}
b+=+{2:{"c":'C'},+3:{"d":'D'}}

print+dict_merge(a,b)|code-block|syntax|javascript|2189667|输出：|2189668|{1:+{'a':+'A'},+2:+{'c':+'C',+'b':+'B'},+3:+{'d':+'D'}}|2189669|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|$]]

Easiest way i can think of is :

<pre><code>#!/usr/bin/python

from copy import deepcopy
def dict_merge(a, b):
 if not isinstance(b, dict):
 return b
 result = deepcopy(a)
 for k, v in b.iteritems():
 if k in result and isinstance(result[k], dict):
 result[k] = dict_merge(result[k], v)
 else:
 result[k] = deepcopy(v)
 return result

a = {1:{"a":'A'}, 2:{"b":'B'}}
b = {2:{"c":'C'}, 3:{"d":'D'}}

print dict_merge(a,b)
</code></pre>

Output:

<pre><code>{1: {'a': 'A'}, 2: {'c': 'C', 'b': 'B'}, 3: {'d': 'D'}}
</code></pre>

blocks|key|3803367|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3803368|+字典合并|blockquote|offset|length|style|BOLD|3803369|3803370|3803371|由于这是一个规范问题(尽管有某些非一般性的问题)，因此我提供了解决此问题的规范Pythonic方法。|3803372|最简单的情况：“叶子是以空字典结尾的嵌套字典”：|3803373|d1+=+{'a':+{1:+{'foo':+{}},+2:+{}}}
d2+=+{'a':+{1:+{},+2:+{'bar':+{}}}}
d3+=+{'b':+{3:+{'baz':+{}}}}
d4+=+{'a':+{1:+{'quux':+{}}}}|code-block|syntax|javascript|3803374|这是最简单的递归情况，我推荐两种简单的方法：|3803375|def+rec_merge1(d1,+d2):
++++'''return+new+merged+dict+of+dicts'''
++++for+k,+v+in+d1.items():+#+in+Python+2,+use+.iteritems()!
++++++++if+k+in+d2:
++++++++++++d2[k]+=+rec_merge1(v,+d2[k])
++++d3+=+d1.copy()
++++d3.update(d2)
++++return+d3

def+rec_merge2(d1,+d2):
++++'''update+first+dict+with+second+recursively'''
++++for+k,+v+in+d1.items():+#+in+Python+2,+use+.iteritems()!
++++++++if+k+in+d2:
++++++++++++d2[k]+=+rec_merge2(v,+d2[k])
++++d1.update(d2)
++++return+d1|3803376|我相信我更喜欢第二个而不是第一个，但请记住，第一个的原始状态必须从它的原点重建。用法如下：|3803377|>>>+from+functools+import+reduce+#+only+required+for+Python+3.
>>>+reduce(rec_merge1,+(d1,+d2,+d3,+d4))
{'a':+{1:+{'quux':+{},+'foo':+{}},+2:+{'bar':+{}}},+'b':+{3:+{'baz':+{}}}}
>>>+reduce(rec_merge2,+(d1,+d2,+d3,+d4))
{'a':+{1:+{'quux':+{},+'foo':+{}},+2:+{'bar':+{}}},+'b':+{3:+{'baz':+{}}}}|3803378|复杂的情况：“叶子是任何其他类型的：”|3803379|所以如果它们以dicts结尾，这是一个简单的例子，合并结束的空dicts。如果不是，就不是那么微不足道了。如果是字符串，如何合并它们？集合可以类似地更新，所以我们可以给出这种处理，但我们会丢失它们被合并的顺序。那么，顺序很重要吗？|3803380|因此，代替更多的信息，最简单的方法是在两个值都不是字典的情况下给它们标准的更新处理:即第二个字典的值将覆盖第一个字典，即使第二个字典的值是None，而第一个的值是包含大量信息的字典。|3803381|d1+=+{'a':+{1:+'foo',+2:+None}}
d2+=+{'a':+{1:+None,+2:+'bar'}}
d3+=+{'b':+{3:+'baz'}}
d4+=+{'a':+{1:+'quux'}}

from+collections.abc+import+MutableMapping

def+rec_merge(d1,+d2):
++++'''
++++Update+two+dicts+of+dicts+recursively,+
++++if+either+mapping+has+leaves+that+are+non-dicts,+
++++the+second's+leaf+overwrites+the+first's.
++++'''
++++for+k,+v+in+d1.items():
++++++++if+k+in+d2:
++++++++++++#+this+next+check+is+the+only+difference!
++++++++++++if+all(isinstance(e,+MutableMapping)+for+e+in+(v,+d2[k])):
++++++++++++++++d2[k]+=+rec_merge(v,+d2[k])
++++++++++++#+we+could+further+check+types+and+merge+as+appropriate+here.
++++d3+=+d1.copy()
++++d3.update(d2)
++++return+d3|3803382|而现在|3803383|from+functools+import+reduce
reduce(rec_merge,+(d1,+d2,+d3,+d4))|3803384|返回|3803385|{'a':+{1:+'quux',+2:+'bar'},+'b':+{3:+'baz'}}|3803386|适用於原问题：|3803387|我必须删除字母周围的大括号，并将它们放在单引号中，这样才能使其成为合法的Python+(否则它们将在Python+2.7%2B中设置文字)，并附加一个缺失的花括号：|3803388|dict1+=+{1:{"a":'A'},+2:{"b":'B'}}
dict2+=+{2:{"c":'C'},+3:{"d":'D'}}|3803389|rec_merge(dict1,+dict2)现在返回：|CODE|3803390|{1:+{'a':+'A'},+2:+{'c':+'C',+'b':+'B'},+3:+{'d':+'D'}}|3803391|这与原始问题的期望结果相匹配(在更改之后，例如，将{A}更改为'A'。)|3803392|entityMap^0|0|1|4|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|N|0|0|P|3|V|3|0^^$0|@$1|2|3|-4|4|5|6|1V|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1W|7|@$D|1X|E|1Y|F|G]]|8|@]|9|$]]|$1|H|3|-4|4|5|6|1Z|7|@]|8|@]|9|$]]|$1|I|3|-4|4|5|6|20|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|21|7|@]|8|@]|9|$]]|$1|L|3|M|4|5|6|22|7|@]|8|@]|9|$]]|$1|N|3|O|4|P|6|23|7|@]|8|@]|9|$Q|R]]|$1|S|3|T|4|5|6|24|7|@]|8|@]|9|$]]|$1|U|3|V|4|P|6|25|7|@]|8|@]|9|$Q|R]]|$1|W|3|X|4|5|6|26|7|@]|8|@]|9|$]]|$1|Y|3|Z|4|P|6|27|7|@]|8|@]|9|$Q|R]]|$1|10|3|11|4|5|6|28|7|@]|8|@]|9|$]]|$1|12|3|13|4|5|6|29|7|@]|8|@]|9|$]]|$1|14|3|15|4|5|6|2A|7|@]|8|@]|9|$]]|$1|16|3|17|4|P|6|2B|7|@]|8|@]|9|$Q|R]]|$1|18|3|19|4|5|6|2C|7|@]|8|@]|9|$]]|$1|1A|3|1B|4|P|6|2D|7|@]|8|@]|9|$Q|R]]|$1|1C|3|1D|4|5|6|2E|7|@]|8|@]|9|$]]|$1|1E|3|1F|4|P|6|2F|7|@]|8|@]|9|$Q|R]]|$1|1G|3|1H|4|5|6|2G|7|@]|8|@]|9|$]]|$1|1I|3|1J|4|5|6|2H|7|@]|8|@]|9|$]]|$1|1K|3|1L|4|P|6|2I|7|@]|8|@]|9|$Q|R]]|$1|1M|3|1N|4|5|6|2J|7|@$D|2K|E|2L|F|1O]]|8|@]|9|$]]|$1|1P|3|1Q|4|P|6|2M|7|@]|8|@]|9|$Q|R]]|$1|1R|3|1S|4|5|6|2N|7|@$D|2O|E|2P|F|1O]|$D|2Q|E|2R|F|1O]]|8|@]|9|$]]|$1|1T|3|-4|4|5|6|2S|7|@]|8|@]|9|$]]]|1U|$]]

<blockquote>
Dictionaries of dictionaries merge
</blockquote>
As this is the canonical question (in spite of certain non-generalities) I'm providing the canonical Pythonic approach to solving this issue.
<h1>Simplest Case: &quot;leaves are nested dicts that end in empty dicts&quot;:</h1>
<pre><code>d1 = {'a': {1: {'foo': {}}, 2: {}}}
d2 = {'a': {1: {}, 2: {'bar': {}}}}
d3 = {'b': {3: {'baz': {}}}}
d4 = {'a': {1: {'quux': {}}}}
</code></pre>
This is the simplest case for recursion, and I would recommend two naive approaches:
<pre><code>def rec_merge1(d1, d2):
 '''return new merged dict of dicts'''
 for k, v in d1.items(): # in Python 2, use .iteritems()!
 if k in d2:
 d2[k] = rec_merge1(v, d2[k])
 d3 = d1.copy()
 d3.update(d2)
 return d3

def rec_merge2(d1, d2):
 '''update first dict with second recursively'''
 for k, v in d1.items(): # in Python 2, use .iteritems()!
 if k in d2:
 d2[k] = rec_merge2(v, d2[k])
 d1.update(d2)
 return d1
</code></pre>
I believe I would prefer the second to the first, but keep in mind that the original state of the first would have to be rebuilt from its origin. Here's the usage:
<pre><code>&gt;&gt;&gt; from functools import reduce # only required for Python 3.
&gt;&gt;&gt; reduce(rec_merge1, (d1, d2, d3, d4))
{'a': {1: {'quux': {}, 'foo': {}}, 2: {'bar': {}}}, 'b': {3: {'baz': {}}}}
&gt;&gt;&gt; reduce(rec_merge2, (d1, d2, d3, d4))
{'a': {1: {'quux': {}, 'foo': {}}, 2: {'bar': {}}}, 'b': {3: {'baz': {}}}}
</code></pre>
<h1>Complex Case: &quot;leaves are of any other type:&quot;</h1>
So if they end in dicts, it's a simple case of merging the end empty dicts. If not, it's not so trivial. If strings, how do you merge them? Sets can be updated similarly, so we could give that treatment, but we lose the order in which they were merged. So does order matter?
So in lieu of more information, the simplest approach will be to give them the standard update treatment if both values are not dicts: i.e. the second dict's value will overwrite the first, even if the second dict's value is None and the first's value is a dict with a lot of info.
<pre><code>d1 = {'a': {1: 'foo', 2: None}}
d2 = {'a': {1: None, 2: 'bar'}}
d3 = {'b': {3: 'baz'}}
d4 = {'a': {1: 'quux'}}

from collections.abc import MutableMapping

def rec_merge(d1, d2):
 '''
 Update two dicts of dicts recursively, 
 if either mapping has leaves that are non-dicts, 
 the second's leaf overwrites the first's.
 '''
 for k, v in d1.items():
 if k in d2:
 # this next check is the only difference!
 if all(isinstance(e, MutableMapping) for e in (v, d2[k])):
 d2[k] = rec_merge(v, d2[k])
 # we could further check types and merge as appropriate here.
 d3 = d1.copy()
 d3.update(d2)
 return d3
</code></pre>
And now
<pre><code>from functools import reduce
reduce(rec_merge, (d1, d2, d3, d4))
</code></pre>
returns
<pre><code>{'a': {1: 'quux', 2: 'bar'}, 'b': {3: 'baz'}}
</code></pre>
<h1>Application to the original question:</h1>
I've had to remove the curly braces around the letters and put them in single quotes for this to be legit Python (else they would be set literals in Python 2.7+) as well as append a missing brace:
<pre><code>dict1 = {1:{&quot;a&quot;:'A'}, 2:{&quot;b&quot;:'B'}}
dict2 = {2:{&quot;c&quot;:'C'}, 3:{&quot;d&quot;:'D'}}
</code></pre>
and <code>rec_merge(dict1, dict2)</code> now returns:
<pre><code>{1: {'a': 'A'}, 2: {'c': 'C', 'b': 'B'}, 3: {'d': 'D'}}
</code></pre>
Which matches the desired outcome of the original question (after changing, e.g. the <code>{A}</code> to <code>'A'</code>.)

blocks|key|4088768|text|这个简单的递归过程将一个字典合并到另一个字典中，同时覆盖冲突的键：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4088769|#!/usr/bin/env+python2.7

def+merge_dicts(dict1,+dict2):
++++"""+Recursively+merges+dict2+into+dict1+"""
++++if+not+isinstance(dict1,+dict)+or+not+isinstance(dict2,+dict):
++++++++return+dict2
++++for+k+in+dict2:
++++++++if+k+in+dict1:
++++++++++++dict1[k]+=+merge_dicts(dict1[k],+dict2[k])
++++++++else:
++++++++++++dict1[k]+=+dict2[k]
++++return+dict1

print+(merge_dicts({1:{"a":"A"},+2:{"b":"B"}},+{2:{"c":"C"},+3:{"d":"D"}}))
print+(merge_dicts({1:{"a":"A"},+2:{"b":"B"}},+{1:{"a":"A"},+2:{"b":"C"}}))|code-block|syntax|javascript|4088770|输出：|4088771|{1:+{'a':+'A'},+2:+{'c':+'C',+'b':+'B'},+3:+{'d':+'D'}}
{1:+{'a':+'A'},+2:+{'b':+'C'}}|4088772|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|$]]

This simple recursive procedure will merge one dictionary into another while overriding conflicting keys:

<pre><code>#!/usr/bin/env python2.7

def merge_dicts(dict1, dict2):
 """ Recursively merges dict2 into dict1 """
 if not isinstance(dict1, dict) or not isinstance(dict2, dict):
 return dict2
 for k in dict2:
 if k in dict1:
 dict1[k] = merge_dicts(dict1[k], dict2[k])
 else:
 dict1[k] = dict2[k]
 return dict1

print (merge_dicts({1:{"a":"A"}, 2:{"b":"B"}}, {2:{"c":"C"}, 3:{"d":"D"}}))
print (merge_dicts({1:{"a":"A"}, 2:{"b":"B"}}, {1:{"a":"A"}, 2:{"b":"C"}}))
</code></pre>

Output:

<pre><code>{1: {'a': 'A'}, 2: {'c': 'C', 'b': 'B'}, 3: {'d': 'D'}}
{1: {'a': 'A'}, 2: {'b': 'C'}}
</code></pre>

blocks|key|326171|text|基于@andrew+cooke。此版本可处理字典的嵌套列表，还允许选项更新值|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326172|def+merge(a,+b,+path=None,+update=True):
++++"http://stackoverflow.com/questions/7204805/python-dictionaries-of-dictionaries-merge"
++++"merges+b+into+a"
++++if+path+is+None:+path+=+[]
++++for+key+in+b:
++++++++if+key+in+a:
++++++++++++if+isinstance(a[key],+dict)+and+isinstance(b[key],+dict):
++++++++++++++++merge(a[key],+b[key],+path+%2B+[str(key)])
++++++++++++elif+a[key]+==+b[key]:
++++++++++++++++pass+#+same+leaf+value
++++++++++++elif+isinstance(a[key],+list)+and+isinstance(b[key],+list):
++++++++++++++++for+idx,+val+in+enumerate(b[key]):
++++++++++++++++++++a[key][idx]+=+merge(a[key][idx],+b[key][idx],+path+%2B+[str(key),+str(idx)],+update=update)
++++++++++++elif+update:
++++++++++++++++a[key]+=+b[key]
++++++++++++else:
++++++++++++++++raise+Exception('Conflict+at+%25s'+%25+'.'.join(path+%2B+[str(key)]))
++++++++else:
++++++++++++a[key]+=+b[key]
++++return+a|code-block|syntax|javascript|326173|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|$]]

Based on @andrew cooke. This version handles nested lists of dicts and also allows the option to update the values
<pre class="lang-py prettyprint-override"><code>def merge(a, b, path=None, update=True):
 &quot;http://stackoverflow.com/questions/7204805/python-dictionaries-of-dictionaries-merge&quot;
 &quot;merges b into a&quot;
 if path is None: path = []
 for key in b:
 if key in a:
 if isinstance(a[key], dict) and isinstance(b[key], dict):
 merge(a[key], b[key], path + [str(key)])
 elif a[key] == b[key]:
 pass # same leaf value
 elif isinstance(a[key], list) and isinstance(b[key], list):
 for idx, val in enumerate(b[key]):
 a[key][idx] = merge(a[key][idx], b[key][idx], path + [str(key), str(idx)], update=update)
 elif update:
 a[key] = b[key]
 else:
 raise Exception('Conflict at %s' % '.'.join(path + [str(key)]))
 else:
 a[key] = b[key]
 return a
</code></pre>

blocks|key|4088842|text|这里我有另一个略有不同的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4088843|def+deepMerge(d1,+d2,+inconflict+=+lambda+v1,v2+:+v2)+:
'''+merge+d2+into+d1.+using+inconflict+function+to+resolve+the+leaf+conflicts+'''
++++for+k+in+d2:
++++++++if+k+in+d1+:+
++++++++++++if+isinstance(d1[k],+dict)+and+isinstance(d2[k],+dict)+:
++++++++++++++++deepMerge(d1[k],+d2[k],+inconflict)
++++++++++++elif+d1[k]+!=+d2[k]+:
++++++++++++++++d1[k]+=+inconflict(d1[k],+d2[k])
++++++++else+:
++++++++++++d1[k]+=+d2[k]
++++return+d1|code-block|syntax|javascript|4088844|默认情况下，它会解决冲突，支持第二个dict中的值，但你可以很容易地覆盖它，使用一些魔法，你甚至可以抛出异常。:)。|4088845|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|$]]

I have another slightly different solution here:

<pre><code>def deepMerge(d1, d2, inconflict = lambda v1,v2 : v2) :
''' merge d2 into d1. using inconflict function to resolve the leaf conflicts '''
 for k in d2:
 if k in d1 : 
 if isinstance(d1[k], dict) and isinstance(d2[k], dict) :
 deepMerge(d1[k], d2[k], inconflict)
 elif d1[k] != d2[k] :
 d1[k] = inconflict(d1[k], d2[k])
 else :
 d1[k] = d2[k]
 return d1
</code></pre>

By default it resolves conflicts in favor of values from the second dict, but you can easily override this, with some witchery you may be able to even throw exceptions out of it. :).

blocks|key|3803583|text|andrew+cookes+answer有一个小问题:在某些情况下，当你修改返回的字典时，它会修改第二个参数b。具体来说，这是因为这一行：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3803584|if+key+in+a:
++++...
else:
++++a[key]+=+b[key]|code-block|syntax|javascript|3803585|如果b[key]是一个dict，它将被简单地分配给a，这意味着对该dict的任何后续修改都将同时影响a和b。|3803586|a={}
b={'1':{'2':'b'}}
c={'1':{'3':'c'}}
merge(merge(a,b),+c)+#+{'1':+{'3':+'c',+'2':+'b'}}
a+#+{'1':+{'3':+'c',+'2':+'b'}}+(as+expected)
b+#+{'1':+{'3':+'c',+'2':+'b'}}+<----
c+#+{'1':+{'3':+'c'}}+(unmodified)|3803587|要解决此问题，必须将该行替换为以下内容：|3803588|if+isinstance(b[key],+dict):
++++a[key]+=+clone_dict(b[key])
else:
++++a[key]+=+b[key]|3803589|其中，clone_dict是：|3803590|def+clone_dict(obj):
++++clone+=+{}
++++for+key,+value+in+obj.iteritems():
++++++++if+isinstance(value,+dict):
++++++++++++clone[key]+=+clone_dict(value)
++++++++else:
++++++++++++clone[key]+=+value
++++return|3803591|还是这样。这显然没有考虑到list，set和其他东西，但我希望它说明了试图合并dicts时的陷阱。|3803592|为了完整起见，这里是我的版本，您可以向它传递多个dicts|3803593|def+merge_dicts(*args):
++++def+clone_dict(obj):
++++++++clone+=+{}
++++++++for+key,+value+in+obj.iteritems():
++++++++++++if+isinstance(value,+dict):
++++++++++++++++clone[key]+=+clone_dict(value)
++++++++++++else:
++++++++++++++++clone[key]+=+value
++++++++return

++++def+merge(a,+b,+path=[]):
++++++++for+key+in+b:
++++++++++++if+key+in+a:
++++++++++++++++if+isinstance(a[key],+dict)+and+isinstance(b[key],+dict):
++++++++++++++++++++merge(a[key],+b[key],+path+%2B+[str(key)])
++++++++++++++++elif+a[key]+==+b[key]:
++++++++++++++++++++pass
++++++++++++++++else:
++++++++++++++++++++raise+Exception('Conflict+at+`{path}\''.format(path='.'.join(path+%2B+[str(key)])))
++++++++++++else:
++++++++++++++++if+isinstance(b[key],+dict):
++++++++++++++++++++a[key]+=+clone_dict(b[key])
++++++++++++++++else:
++++++++++++++++++++a[key]+=+b[key]
++++++++return+a
++++return+reduce(merge,+args,+{})|3803594|entityMap^0|1I|1|0|0|2|6|B|4|P|1|X|4|1E|1|1G|1|0|0|0|0|3|A|0|0|D|4|I|3|13|5|0|O|5|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1M|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1N|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|10|3|11|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|12|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|13|$]]

There's a slight problem with andrew cookes answer: In some cases it modifies the second argument <code>b</code> when you modify the returned dict. Specifically it's because of this line:

<pre><code>if key in a:
 ...
else:
 a[key] = b[key]
</code></pre>

If <code>b[key]</code> is a <code>dict</code>, it will simply be assigned to <code>a</code>, meaning any subsequent modifications to that <code>dict</code> will affect both <code>a</code> and <code>b</code>.

<pre><code>a={}
b={'1':{'2':'b'}}
c={'1':{'3':'c'}}
merge(merge(a,b), c) # {'1': {'3': 'c', '2': 'b'}}
a # {'1': {'3': 'c', '2': 'b'}} (as expected)
b # {'1': {'3': 'c', '2': 'b'}} &lt;----
c # {'1': {'3': 'c'}} (unmodified)
</code></pre>

To fix this, the line would have to be substituted with this:

<pre><code>if isinstance(b[key], dict):
 a[key] = clone_dict(b[key])
else:
 a[key] = b[key]
</code></pre>

Where <code>clone_dict</code> is:

<pre><code>def clone_dict(obj):
 clone = {}
 for key, value in obj.iteritems():
 if isinstance(value, dict):
 clone[key] = clone_dict(value)
 else:
 clone[key] = value
 return
</code></pre>

Still. This obviously doesn't account for <code>list</code>, <code>set</code> and other stuff, but I hope it illustrates the pitfalls when trying to merge <code>dicts</code>.

And for completeness sake, here is my version, where you can pass it multiple <code>dicts</code>:

<pre><code>def merge_dicts(*args):
 def clone_dict(obj):
 clone = {}
 for key, value in obj.iteritems():
 if isinstance(value, dict):
 clone[key] = clone_dict(value)
 else:
 clone[key] = value
 return

 def merge(a, b, path=[]):
 for key in b:
 if key in a:
 if isinstance(a[key], dict) and isinstance(b[key], dict):
 merge(a[key], b[key], path + [str(key)])
 elif a[key] == b[key]:
 pass
 else:
 raise Exception('Conflict at `{path}\''.format(path='.'.join(path + [str(key)])))
 else:
 if isinstance(b[key], dict):
 a[key] = clone_dict(b[key])
 else:
 a[key] = b[key]
 return a
 return reduce(merge, args, {})
</code></pre>

blocks|key|3803642|text|因为dictviews支持集合操作，所以我能够大大简化jterrace的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3803643|def+merge(dict1,+dict2):
++++for+k+in+dict1.keys()+-+dict2.keys():
++++++++yield+(k,+dict1[k])

++++for+k+in+dict2.keys()+-+dict1.keys():
++++++++yield+(k,+dict2[k])

++++for+k+in+dict1.keys()+&+dict2.keys():
++++++++yield+(k,+dict(merge(dict1[k],+dict2[k])))|code-block|syntax|javascript|3803644|任何尝试组合dict和non+dict+(从技术上讲，具有'keys‘方法的对象和没有'keys’方法的对象)都将引发AttributeError。这包括对函数的初始调用和递归调用。这正是我想要的，所以我把它留下了。您可以很容易地捕获由递归调用抛出的AttributeErrors，然后生成您想要的任何值。|3803645|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|$]]

Since dictviews support set operations, I was able to greatly simplify jterrace's answer.

<pre><code>def merge(dict1, dict2):
 for k in dict1.keys() - dict2.keys():
 yield (k, dict1[k])

 for k in dict2.keys() - dict1.keys():
 yield (k, dict2[k])

 for k in dict1.keys() &amp; dict2.keys():
 yield (k, dict(merge(dict1[k], dict2[k])))
</code></pre>

Any attempt to combine a dict with a non dict (technically, an object with a 'keys' method and an object without a 'keys' method) will raise an AttributeError. This includes both the initial call to the function and recursive calls. This is exactly what I wanted so I left it. You could easily catch an AttributeErrors thrown by the recursive call and then yield any value you please.

blocks|key|3803679|text|我有两个字典(a和b)，每个字典都可以包含任意数量的嵌套字典。我想递归地合并它们，让b优先于a。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3803680|考虑到嵌套字典是树，我想要的是：|3803681|如果在a|3803682|To中的相应路径中找到叶，则更新a，以便b中到每个叶的每条路径都将在a的覆盖子树中表示。b+|unordered-list-item|3803683|保持所有b叶节点保持不变。|3803684|3803685|3803686|​|3803687|现有的答案对我来说有点复杂，并留下了一些细节。我整理了以下代码，这些代码通过了我的数据集的单元测试。|3803688|++def+merge_map(a,+b):
++++if+not+isinstance(a,+dict)+or+not+isinstance(b,+dict):
++++++return+b

++++for+key+in+b.keys():
++++++a[key]+=+merge_map(a[key],+b[key])+if+key+in+a+else+b[key]
++++return+a|code-block|syntax|javascript|3803689|示例(为清晰起见进行了格式化)：|3803690|+a+=+{
++++1+:+{'a':+'red',+
+++++++++'b':+{'blue':+'fish',+'yellow':+'bear'+},
+++++++++'c':+{+'orange':+'dog'},
++++},
++++2+:+{'d':+'green'},
++++3:+'e'
++}

++b+=+{
++++1+:+{'b':+'white'},
++++2+:+{'d':+'black'},
++++3:+'e'
++}


++>>>+merge_map(a,+b)
++{1:+{'a':+'red',+
+++++++'b':+'white',
+++++++'c':+{'orange':+'dog'},},
+++2:+{'d':+'black'},
+++3:+'e'}|3803691|b中需要维护的路径包括：|3803692|3803693|1+->+'b'+->+'white'|3803694|2+->+'d'+->+'black'|3803695|3+->+'e'.|3803696|3803697|a具有以下唯一且无冲突的路径：|3803698|3803699|1+->+'a'+->+'red'+|3803700|1+->+'c'+->+'orange'+->+'dog'|3803701|3803702|因此，它们仍然显示在合并后的地图中。|3803703|entityMap^0|7|1|9|1|16|1|1A|1|0|0|3|1|0|G|1|K|1|Y|1|18|1|0|4|1|0|0|0|0|0|0|0|0|0|1|0|0|0|J|0|0|J|0|0|8|0|0|0|1|0|0|0|H|0|0|T|0|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|C]|$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|M|3|N|5|L|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2G|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|2H|8|@]|D|@]|E|$]]|$1|U|3|V|5|W|7|2I|8|@]|D|@]|E|$X|Y]]|$1|Z|3|10|5|6|7|2J|8|@]|D|@]|E|$]]|$1|11|3|12|5|W|7|2K|8|@]|D|@]|E|$X|Y]]|$1|13|3|14|5|6|7|2L|8|@$9|2M|A|2N|B|C]]|D|@]|E|$]]|$1|15|3|-4|5|6|7|2O|8|@]|D|@]|E|$]]|$1|16|3|17|5|L|7|2P|8|@$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|18|3|19|5|L|7|2S|8|@$9|2T|A|2U|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|L|7|2V|8|@$9|2W|A|2X|B|C]]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|2Y|8|@]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|2Z|8|@$9|30|A|31|B|C]]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|32|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|L|7|33|8|@$9|34|A|35|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|L|7|36|8|@$9|37|A|38|B|C]]|D|@]|E|$]]|$1|1K|3|-4|5|6|7|39|8|@]|D|@]|E|$]]|$1|1L|3|1M|5|6|7|3A|8|@]|D|@]|E|$]]|$1|1N|3|-4|5|6|7|3B|8|@]|D|@]|E|$]]]|1O|$]]

I had two dictionaries (<code>a</code> and <code>b</code>) which could each contain any number of nested dictionaries. I wanted to recursively merge them, with <code>b</code> taking precedence over <code>a</code>.

Considering the nested dictionaries as trees, what I wanted was:

<ul>
<li>To update <code>a</code> so that every path to every leaf in <code>b</code> would be represented in <code>a</code></li>
<li>To overwrite subtrees of <code>a</code> if a leaf is found in the corresponding path in <code>b</code>

<ul>
<li>Maintain the invariant that all <code>b</code> leaf nodes remain leafs.</li>
</ul></li>
</ul>

The existing answers were a little complicated for my taste and left some details on the shelf. I hacked together the following, which passes unit tests for my data set.

<pre><code> def merge_map(a, b):
 if not isinstance(a, dict) or not isinstance(b, dict):
 return b

 for key in b.keys():
 a[key] = merge_map(a[key], b[key]) if key in a else b[key]
 return a
</code></pre>

Example (formatted for clarity):

<pre><code> a = {
 1 : {'a': 'red', 
 'b': {'blue': 'fish', 'yellow': 'bear' },
 'c': { 'orange': 'dog'},
 },
 2 : {'d': 'green'},
 3: 'e'
 }

 b = {
 1 : {'b': 'white'},
 2 : {'d': 'black'},
 3: 'e'
 }


 &gt;&gt;&gt; merge_map(a, b)
 {1: {'a': 'red', 
 'b': 'white',
 'c': {'orange': 'dog'},},
 2: {'d': 'black'},
 3: 'e'}
</code></pre>

The paths in <code>b</code> that needed to be maintained were:

<ul>
<li><code>1 -&gt; 'b' -&gt; 'white'</code></li>
<li><code>2 -&gt; 'd' -&gt; 'black'</code></li>
<li><code>3 -&gt; 'e'</code>.</li>
</ul>

<code>a</code> had the unique and non-conflicting paths of:

<ul>
<li><code>1 -&gt; 'a' -&gt; 'red'</code> </li>
<li><code>1 -&gt; 'c' -&gt; 'orange' -&gt; 'dog'</code></li>
</ul>

so they are still represented in the merged map.

blocks|key|2189997|text|class+Utils(object):

++++"""

++++>>>+a+=+{+'first'+:+{+'all_rows'+:+{+'pass'+:+'dog',+'number'+:+'1'+}+}+}
++++>>>+b+=+{+'first'+:+{+'all_rows'+:+{+'fail'+:+'cat',+'number'+:+'5'+}+}+}
++++>>>+Utils.merge_dict(b,+a)+==+{+'first'+:+{+'all_rows'+:+{+'pass'+:+'dog',+'fail'+:+'cat',+'number'+:+'5'+}+}+}
++++True

++++>>>+main+=+{'a':+{'b':+{'test':+'bug'},+'c':+'C'}}
++++>>>+suply+=+{'a':+{'b':+2,+'d':+'D',+'c':+{'test':+'bug2'}}}
++++>>>+Utils.merge_dict(main,+suply)+==+{'a':+{'b':+{'test':+'bug'},+'c':+'C',+'d':+'D'}}
++++True

++++"""

++++@staticmethod
++++def+merge_dict(main,+suply):
++++++++"""
++++++++获取融合的字典，以main为主,suply补充,冲突时以main为准
++++++++:return:
++++++++"""
++++++++for+key,+value+in+suply.items():
++++++++++++if+key+in+main:
++++++++++++++++if+isinstance(main[key],+dict):
++++++++++++++++++++if+isinstance(value,+dict):
++++++++++++++++++++++++Utils.merge_dict(main[key],+value)
++++++++++++++++++++else:
++++++++++++++++++++++++pass
++++++++++++++++else:
++++++++++++++++++++pass
++++++++++++else:
++++++++++++++++main[key]+=+value
++++++++return+main

if+__name__+==+'__main__':
++++import+doctest
++++doctest.testmod()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2189998|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>class Utils(object):

 """

 &gt;&gt;&gt; a = { 'first' : { 'all_rows' : { 'pass' : 'dog', 'number' : '1' } } }
 &gt;&gt;&gt; b = { 'first' : { 'all_rows' : { 'fail' : 'cat', 'number' : '5' } } }
 &gt;&gt;&gt; Utils.merge_dict(b, a) == { 'first' : { 'all_rows' : { 'pass' : 'dog', 'fail' : 'cat', 'number' : '5' } } }
 True

 &gt;&gt;&gt; main = {'a': {'b': {'test': 'bug'}, 'c': 'C'}}
 &gt;&gt;&gt; suply = {'a': {'b': 2, 'd': 'D', 'c': {'test': 'bug2'}}}
 &gt;&gt;&gt; Utils.merge_dict(main, suply) == {'a': {'b': {'test': 'bug'}, 'c': 'C', 'd': 'D'}}
 True

 """

 @staticmethod
 def merge_dict(main, suply):
 """
 获取融合的字典，以main为主,suply补充,冲突时以main为准
 :return:
 """
 for key, value in suply.items():
 if key in main:
 if isinstance(main[key], dict):
 if isinstance(value, dict):
 Utils.merge_dict(main[key], value)
 else:
 pass
 else:
 pass
 else:
 main[key] = value
 return main

if __name__ == '__main__':
 import doctest
 doctest.testmod()
</code></pre>

blocks|key|4089059|text|概述|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4089060|下面的方法将字典的深度合并问题细分为：|4089061|4089062|一个参数化的浅层合并函数merge(f)(a,b)，它使用函数f来合并两个字典a和dicts|ordered-list-item|CODE|4089063|4089064|与merge一起使用的|4089065|递归合并函数f|4089066|4089067|4089068|Implementation|4089069|合并两个(非嵌套的)字典的函数可以用很多方式编写。我个人喜欢|4089070|def+merge(f):
++++def+merge(a,b):+
++++++++keys+=+a.keys()+%7C+b.keys()
++++++++return+{key:f(a.get(key),+b.get(key))+for+key+in+keys}
++++return+merge|code-block|syntax|javascript|4089071|4089072|定义适当的递归合并函数f的一个好方法是使用multipledispatch，它允许定义根据参数类型沿不同路径求值的函数。|4089073|from+multipledispatch+import+dispatch

#for+anything+that+is+not+a+dict+return
@dispatch(object,+object)
def+f(a,+b):
++++return+b+if+b+is+not+None+else+a

#for+dicts+recurse+
@dispatch(dict,+dict)
def+f(a,b):
++++return+merge(f)(a,b)|4089074|4089075|示例|4089076|要合并两个嵌套的字典，只需使用merge(f)，例如：|4089077|dict1+=+{1:{"a":"A"},2:{"b":"B"}}
dict2+=+{2:{"c":"C"},3:{"d":"D"}}
merge(f)(dict1,+dict2)
#returns+{1:+{'a':+'A'},+2:+{'b':+'B',+'c':+'C'},+3:+{'d':+'D'}}+|4089078|4089079|备注：|4089080|这种方法的优点是：|4089081|4089082|该函数由较小的函数构建而成，每个函数只做一件事，这使得代码更易于推理和测试|unordered-list-item|4089083|4089084|4089085|该行为不是硬编码的，但可以根据需要进行更改和扩展，从而提高代码的重用性(请参阅下面的示例)。|4089086|4089087|4089088|Customization|4089089|一些答案还考虑了包含列表的词典，例如其他(可能嵌套的)词典。在这种情况下，可能需要映射到列表上，并根据位置合并它们。这可以通过向合并函数f添加另一个定义来完成|4089090|import+itertools
@dispatch(list,+list)
def+f(a,b):
++++return+[merge(f)(*arg)+for+arg+in+itertools.zip_longest(a,+b)]|4089091|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/multipledispatch^0|0|2|0|0|0|C|D|V|1|13|1|0|0|1|5|0|6|1|0|0|0|0|E|0|0|0|0|B|1|L|G|0|0|0|0|0|2|0|F|8|0|0|0|0|3|0|0|0|0|0|0|0|0|0|0|D|0|1W|1|0|0^^$0|@$1|2|3|4|5|6|7|27|8|@$9|28|A|29|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|2A|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|2C|8|@$9|2D|A|2E|B|L]|$9|2F|A|2G|B|L]|$9|2H|A|2I|B|L]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|2J|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|2K|8|@$9|2L|A|2M|B|L]]|D|@]|E|$]]|$1|P|3|Q|5|K|7|2N|8|@$9|2O|A|2P|B|L]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|2R|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|2S|8|@$9|2T|A|2U|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|2V|8|@]|D|@]|E|$]]|$1|X|3|Y|5|Z|7|2W|8|@]|D|@]|E|$10|11]]|$1|12|3|-4|5|6|7|2X|8|@]|D|@]|E|$]]|$1|13|3|14|5|6|7|2Y|8|@$9|2Z|A|30|B|L]]|D|@$9|31|A|32|1|33]]|E|$]]|$1|15|3|16|5|Z|7|34|8|@]|D|@]|E|$10|11]]|$1|17|3|-4|5|6|7|35|8|@]|D|@]|E|$]]|$1|18|3|19|5|6|7|36|8|@$9|37|A|38|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|6|7|39|8|@$9|3A|A|3B|B|L]]|D|@]|E|$]]|$1|1C|3|1D|5|Z|7|3C|8|@]|D|@]|E|$10|11]]|$1|1E|3|-4|5|6|7|3D|8|@]|D|@]|E|$]]|$1|1F|3|1G|5|6|7|3E|8|@$9|3F|A|3G|B|C]]|D|@]|E|$]]|$1|1H|3|1I|5|6|7|3H|8|@]|D|@]|E|$]]|$1|1J|3|-4|5|6|7|3I|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|1M|7|3J|8|@]|D|@]|E|$]]|$1|1N|3|-4|5|6|7|3K|8|@]|D|@]|E|$]]|$1|1O|3|-4|5|6|7|3L|8|@]|D|@]|E|$]]|$1|1P|3|1Q|5|1M|7|3M|8|@]|D|@]|E|$]]|$1|1R|3|-4|5|6|7|3N|8|@]|D|@]|E|$]]|$1|1S|3|-4|5|6|7|3O|8|@]|D|@]|E|$]]|$1|1T|3|1U|5|6|7|3P|8|@$9|3Q|A|3R|B|C]]|D|@]|E|$]]|$1|1V|3|1W|5|6|7|3S|8|@$9|3T|A|3U|B|L]]|D|@]|E|$]]|$1|1X|3|1Y|5|Z|7|3V|8|@]|D|@]|E|$10|11]]|$1|1Z|3|-4|5|6|7|3W|8|@]|D|@]|E|$]]]|20|$21|$5|22|23|24|E|$25|26]]]]

Overview
The following approach subdivides the problem of a deep merge of dicts into:
<ol>
<li>A parameterized shallow merge function <code>merge(f)(a,b)</code> that uses a
function <code>f</code> to merge two dicts <code>a</code> and <code>b</code>
</li>
<li>A recursive merger function <code>f</code> to be used together with <code>merge</code>
</li>
</ol>
<hr />
Implementation
A function for merging two (non nested) dicts can be written in a lot of ways. I personally like
<pre><code>def merge(f):
 def merge(a,b): 
 keys = a.keys() | b.keys()
 return {key:f(a.get(key), b.get(key)) for key in keys}
 return merge
</code></pre>
<hr />
A nice way of defining an appropriate recursive merger function <code>f</code> is using <a href="https://pypi.python.org/pypi/multipledispatch" rel="nofollow noreferrer">multipledispatch</a> which allows to define functions that evaluate along different paths depending on the type of their arguments.
<pre><code>from multipledispatch import dispatch

#for anything that is not a dict return
@dispatch(object, object)
def f(a, b):
 return b if b is not None else a

#for dicts recurse 
@dispatch(dict, dict)
def f(a,b):
 return merge(f)(a,b)
</code></pre>
<hr />
Example
To merge two nested dicts simply use <code>merge(f)</code> e.g.:
<pre><code>dict1 = {1:{&quot;a&quot;:&quot;A&quot;},2:{&quot;b&quot;:&quot;B&quot;}}
dict2 = {2:{&quot;c&quot;:&quot;C&quot;},3:{&quot;d&quot;:&quot;D&quot;}}
merge(f)(dict1, dict2)
#returns {1: {'a': 'A'}, 2: {'b': 'B', 'c': 'C'}, 3: {'d': 'D'}} 
</code></pre>
<hr />
Notes:
The advantages of this approach are:
<ul>
<li>The function is build from smaller functions that each do a single thing
which makes the code simpler to reason about and test
</li>
<li>The behaviour is not hard-coded but can be changed and extended as needed which improves code reuse (see example below).
</li>
</ul>
<hr />
Customization
Some answers also considered dicts that contain lists e.g. of other (potentially nested) dicts. In this case one might want map over the lists and merge them based on position. This can be done by adding another definition to the merger function <code>f</code>:
<pre><code>import itertools
@dispatch(list, list)
def f(a,b):
 return [merge(f)(*arg) for arg in itertools.zip_longest(a, b)]
</code></pre>

blocks|key|4089122|text|基于@andrew+cooke的回答。它以一种更好的方式处理嵌套列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4089123|def+deep_merge_lists(original,+incoming):
++++"""
++++Deep+merge+two+lists.+Modifies+original.
++++Recursively+call+deep+merge+on+each+correlated+element+of+list.+
++++If+item+type+in+both+elements+are
+++++a.+dict:+Call+deep_merge_dicts+on+both+values.
+++++b.+list:+Recursively+call+deep_merge_lists+on+both+values.
+++++c.+any+other+type:+Value+is+overridden.
+++++d.+conflicting+types:+Value+is+overridden.

++++If+length+of+incoming+list+is+more+that+of+original+then+extra+values+are+appended.
++++"""
++++common_length+=+min(len(original),+len(incoming))
++++for+idx+in+range(common_length):
++++++++if+isinstance(original[idx],+dict)+and+isinstance(incoming[idx],+dict):
++++++++++++deep_merge_dicts(original[idx],+incoming[idx])

++++++++elif+isinstance(original[idx],+list)+and+isinstance(incoming[idx],+list):
++++++++++++deep_merge_lists(original[idx],+incoming[idx])

++++++++else:
++++++++++++original[idx]+=+incoming[idx]

++++for+idx+in+range(common_length,+len(incoming)):
++++++++original.append(incoming[idx])


def+deep_merge_dicts(original,+incoming):
++++"""
++++Deep+merge+two+dictionaries.+Modifies+original.
++++For+key+conflicts+if+both+values+are:
+++++a.+dict:+Recursively+call+deep_merge_dicts+on+both+values.
+++++b.+list:+Call+deep_merge_lists+on+both+values.
+++++c.+any+other+type:+Value+is+overridden.
+++++d.+conflicting+types:+Value+is+overridden.

++++"""
++++for+key+in+incoming:
++++++++if+key+in+original:
++++++++++++if+isinstance(original[key],+dict)+and+isinstance(incoming[key],+dict):
++++++++++++++++deep_merge_dicts(original[key],+incoming[key])

++++++++++++elif+isinstance(original[key],+list)+and+isinstance(incoming[key],+list):
++++++++++++++++deep_merge_lists(original[key],+incoming[key])

++++++++++++else:
++++++++++++++++original[key]+=+incoming[key]
++++++++else:
++++++++++++original[key]+=+incoming[key]|code-block|syntax|javascript|4089124|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|$]]

Based on answers from @andrew cooke.
It takes care of nested lists in a better way.

<pre><code>def deep_merge_lists(original, incoming):
 """
 Deep merge two lists. Modifies original.
 Recursively call deep merge on each correlated element of list. 
 If item type in both elements are
 a. dict: Call deep_merge_dicts on both values.
 b. list: Recursively call deep_merge_lists on both values.
 c. any other type: Value is overridden.
 d. conflicting types: Value is overridden.

 If length of incoming list is more that of original then extra values are appended.
 """
 common_length = min(len(original), len(incoming))
 for idx in range(common_length):
 if isinstance(original[idx], dict) and isinstance(incoming[idx], dict):
 deep_merge_dicts(original[idx], incoming[idx])

 elif isinstance(original[idx], list) and isinstance(incoming[idx], list):
 deep_merge_lists(original[idx], incoming[idx])

 else:
 original[idx] = incoming[idx]

 for idx in range(common_length, len(incoming)):
 original.append(incoming[idx])


def deep_merge_dicts(original, incoming):
 """
 Deep merge two dictionaries. Modifies original.
 For key conflicts if both values are:
 a. dict: Recursively call deep_merge_dicts on both values.
 b. list: Call deep_merge_lists on both values.
 c. any other type: Value is overridden.
 d. conflicting types: Value is overridden.

 """
 for key in incoming:
 if key in original:
 if isinstance(original[key], dict) and isinstance(incoming[key], dict):
 deep_merge_dicts(original[key], incoming[key])

 elif isinstance(original[key], list) and isinstance(incoming[key], list):
 deep_merge_lists(original[key], incoming[key])

 else:
 original[key] = incoming[key]
 else:
 original[key] = incoming[key]
</code></pre>

blocks|key|4089142|text|Short-n-甜蜜：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4089143|from+collections.abc+import+MutableMapping+as+Map

def+nested_update(d,+v):
"""
Nested+update+of+dict-like+'d'+with+dict-like+'v'.
"""

for+key+in+v:
++++if+key+in+d+and+isinstance(d[key],+Map)+and+isinstance(v[key],+Map):
++++++++nested_update(d[key],+v[key])
++++else:
++++++++d[key]+=+v[key]|code-block|syntax|javascript|4089144|它的工作方式类似于Python的dict.update方法(并且是在其上构建的)。当它就地更新dict+d时，它返回None+(如果你愿意，你总是可以添加return+d+)。v中的键将覆盖d中的任何现有键(它不会尝试解释字典的内容)。|offset|length|style|CODE|4089145|它也适用于其他(“类字典”)映射。|4089146|entityMap^0|0|0|G|B|1G|1|1M|4|25|8|2G|1|2N|1|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|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|P|$]]

Short-n-sweet:

<pre><code>from collections.abc import MutableMapping as Map

def nested_update(d, v):
"""
Nested update of dict-like 'd' with dict-like 'v'.
"""

for key in v:
 if key in d and isinstance(d[key], Map) and isinstance(v[key], Map):
 nested_update(d[key], v[key])
 else:
 d[key] = v[key]
</code></pre>

This works like (and is build on) Python's <code>dict.update</code> method. It returns <code>None</code> (you can always add <code>return d</code> if you prefer) as it updates dict <code>d</code> in-place. Keys in <code>v</code> will overwrite any existing keys in <code>d</code> (it does not try to interpret the dict's contents). 

It will also work for other ("dict-like") mappings.

blocks|key|2190182|text|嘿，我也有同样的问题，但我想了一个解决方案，我会把它贴在这里，以防它对其他人也有用，基本上是合并嵌套字典并添加值，对我来说，我需要计算一些概率，所以这个方法很有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2190183|#used+to+copy+a+nested+dict+to+a+nested+dict
def+deepupdate(target,+src):
++++for+k,+v+in+src.items():
++++++++if+k+in+target:
++++++++++++for+k2,+v2+in+src[k].items():
++++++++++++++++if+k2+in+target[k]:
++++++++++++++++++++target[k][k2]%2B=v2
++++++++++++++++else:
++++++++++++++++++++target[k][k2]+=+v2
++++++++else:
++++++++++++target[k]+=+copy.deepcopy(v)|code-block|syntax|javascript|2190184|通过使用上面的方法，我们可以合并：|2190185|目标=+{'6,6'：{'6,63'：1}，'63,4'：{'4,4'：1}，'4,4'：{'4,3'：1}，'6,63'：{'63,4'：1}}|2190186|src+=+{'5,4'：{'4,4'：1}，'5,5'：{'5,4'：1}，'4,4'：{'4,3'：1}}|2190187|这将变成：{'5,5'：{'5,4'：1}，'5,4'：{'4,4'：1}，'6,6'：{'6,63'：1}，'63,4'：{'4,4'：1}，'4,4'：{'4,3'：2}，'6,63'：{'63,4'：1}}|2190188|另请注意此处的更改：|2190189|目标=+{'6,6'：{'6,63'：1}，'6,63'：{'63,4'：1}，'4,4'：{'4,3'：1}，'63,4'：{'4,4'：1}}|offset|length|style|BOLD|2190190|src+=+{'5,4'：{'4,4'：1}，'4,3'：{'3,4'：1}，'4,4'：{'4,9'：1}，'3,4'：{'4,4'：1}，'5,5'：{'5,4'：1}}|2190191|=+{'5,4'：{'4,4'：1}，'4,3'：{'3,4'：1}，'6,63'：{'63,4'：1}，'5,5'：{'5,4'：1}，'6,6'：{'6,63'：1}，'3,4'：{'4,4'：1}，'63,4'：{'4,4'：1}，merge‘4，4’：{'4,3'：1，'4,9'：1}}|2190192|别忘了还要添加要复制的导入：|2190193|import+copy|2190194|entityMap^0|0|0|0|0|0|0|0|14|F|0|13|F|0|0|43|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@$S|1E|T|1F|U|V]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1G|8|@$S|1H|T|1I|U|V]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1J|8|@$S|1K|T|1L|U|V]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

hey there I also had the same problem but I though of a solution and I will post it here, in case it is also useful for others, basically merging nested dictionaries and also adding the values, for me I needed to calculate some probabilities so this one worked great:

<pre><code>#used to copy a nested dict to a nested dict
def deepupdate(target, src):
 for k, v in src.items():
 if k in target:
 for k2, v2 in src[k].items():
 if k2 in target[k]:
 target[k][k2]+=v2
 else:
 target[k][k2] = v2
 else:
 target[k] = copy.deepcopy(v)
</code></pre>

by using the above method we can merge:

target = {'6,6': {'6,63': 1}, '63,4': {'4,4': 1}, '4,4': {'4,3': 1}, '6,63': {'63,4': 1}}

src = {'5,4': {'4,4': 1}, '5,5': {'5,4': 1}, '4,4': {'4,3': 1}}

and this will become:
{'5,5': {'5,4': 1}, '5,4': {'4,4': 1}, '6,6': {'6,63': 1}, '63,4': {'4,4': 1}, '4,4': {'4,3': 2}, '6,63': {'63,4': 1}}

also notice the changes here:

target = {'6,6': {'6,63': 1}, '6,63': {'63,4': 1}, '4,4': {'4,3': 1}, '63,4': {'4,4': 1}}

src = {'5,4': {'4,4': 1}, '4,3': {'3,4': 1}, '4,4': {'4,9': 1}, '3,4': {'4,4': 1}, '5,5': {'5,4': 1}}

merge = {'5,4': {'4,4': 1}, '4,3': {'3,4': 1}, '6,63': {'63,4': 1}, '5,5': {'5,4': 1}, '6,6': {'6,63': 1}, '3,4': {'4,4': 1}, '63,4': {'4,4': 1}, '4,4': {'4,3': 1, '4,9': 1}}

dont forget to also add the import for copy:

<pre><code>import copy
</code></pre>

blocks|key|3804005|text|如果有人想要另一种方法来解决这个问题，这里是我的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3804006|的优点是：简短、声明性和函数式(递归，没有变化)。|offset|length|style|BOLD|3804007|潜在的缺点：这可能不是你想要的合并。有关语义，请参阅文档字符串。|3804008|def+deep_merge(a,+b):
++++"""
++++Merge+two+values,+with+`b`+taking+precedence+over+`a`.

++++Semantics:
++++-+If+either+`a`+or+`b`+is+not+a+dictionary,+`a`+will+be+returned+only+if
++++++`b`+is+`None`.+Otherwise+`b`+will+be+returned.
++++-+If+both+values+are+dictionaries,+they+are+merged+as+follows:
++++++++*+Each+key+that+is+found+only+in+`a`+or+only+in+`b`+will+be+included+in
++++++++++the+output+collection+with+its+value+intact.
++++++++*+For+any+key+in+common+between+`a`+and+`b`,+the+corresponding+values
++++++++++will+be+merged+with+the+same+semantics.
++++"""
++++if+not+isinstance(a,+dict)+or+not+isinstance(b,+dict):
++++++++return+a+if+b+is+None+else+b
++++else:
++++++++#+If+we're+here,+both+a+and+b+must+be+dictionaries+or+subtypes+thereof.

++++++++#+Compute+set+of+all+keys+in+both+dictionaries.
++++++++keys+=+set(a.keys())+%7C+set(b.keys())

++++++++#+Build+output+dictionary,+merging+recursively+values+with+common+keys,
++++++++#+where+`None`+is+used+to+mean+the+absence+of+a+value.
++++++++return+{
++++++++++++key:+deep_merge(a.get(key),+b.get(key))
++++++++++++for+key+in+keys
++++++++}|code-block|syntax|javascript|3804009|entityMap^0|0|0|4|0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

In case someone wants yet another approach to this problem, here's my solution.

Virtues: short, declarative, and functional in style (recursive, does no mutation).

Potential Drawback: This might not be the merge you're looking for. Consult the docstring for semantics.

<pre class="lang-py prettyprint-override"><code>def deep_merge(a, b):
 """
 Merge two values, with `b` taking precedence over `a`.

 Semantics:
 - If either `a` or `b` is not a dictionary, `a` will be returned only if
 `b` is `None`. Otherwise `b` will be returned.
 - If both values are dictionaries, they are merged as follows:
 * Each key that is found only in `a` or only in `b` will be included in
 the output collection with its value intact.
 * For any key in common between `a` and `b`, the corresponding values
 will be merged with the same semantics.
 """
 if not isinstance(a, dict) or not isinstance(b, dict):
 return a if b is None else b
 else:
 # If we're here, both a and b must be dictionaries or subtypes thereof.

 # Compute set of all keys in both dictionaries.
 keys = set(a.keys()) | set(b.keys())

 # Build output dictionary, merging recursively values with common keys,
 # where `None` is used to mean the absence of a value.
 return {
 key: deep_merge(a.get(key), b.get(key))
 for key in keys
 }
</code></pre>

blocks|key|4089316|text|from+collections+import+defaultdict
from+itertools+import+chain

class+DictHelper:

@staticmethod
def+merge_dictionaries(*dictionaries,+override=True):
++++merged_dict+=+defaultdict(set)
++++all_unique_keys+=+set(chain(*[list(dictionary.keys())+for+dictionary+in+dictionaries]))++#+Build+a+set+using+all+dict+keys
++++for+key+in+all_unique_keys:
++++++++keys_value_type+=+list(set(filter(lambda+obj_type:+obj_type+!=+type(None),+[type(dictionary.get(key,+None))+for+dictionary+in+dictionaries])))
++++++++#+Establish+the+object+type+for+each+key,+return+None+if+key+is+not+present+in+dict+and+remove+None+from+final+result
++++++++if+len(keys_value_type)+!=+1:
++++++++++++raise+Exception("Different+objects+type+for+same+key:+{keys_value_type}".format(keys_value_type=keys_value_type))

++++++++if+keys_value_type[0]+==+list:
++++++++++++values+=+list(chain(*[dictionary.get(key,+[])+for+dictionary+in+dictionaries]))++#+Extract+the+value+for+each+key
++++++++++++merged_dict[key].update(values)

++++++++elif+keys_value_type[0]+==+dict:
++++++++++++#+Extract+all+dictionaries+by+key+and+enter+in+recursion
++++++++++++dicts_to_merge+=+list(filter(lambda+obj:+obj+!=+None,+[dictionary.get(key,+None)+for+dictionary+in+dictionaries]))
++++++++++++merged_dict[key]+=+DictHelper.merge_dictionaries(*dicts_to_merge)

++++++++else:
++++++++++++#+if+override+=>+get+value+from+last+dictionary+else+make+a+list+of+all+values
++++++++++++values+=+list(filter(lambda+obj:+obj+!=+None,+[dictionary.get(key,+None)+for+dictionary+in+dictionaries]))
++++++++++++merged_dict[key]+=+values[-1]+if+override+else+values

++++return+dict(merged_dict)



if+__name__+==+'__main__':
++d1+=+{'aaaaaaaaa':+['to+short',+'to+long'],+'bbbbb':+['to+short',+'to+long'],+"cccccc":+["the+is+a+test"]}
++d2+=+{'aaaaaaaaa':+['field+is+not+a+bool'],+'bbbbb':+['field+is+not+a+bool']}
++d3+=+{'aaaaaaaaa':+['filed+is+not+a+string',+"to+short"],+'bbbbb':+['field+is+not+an+integer']}
++print(DictHelper.merge_dictionaries(d1,+d2,+d3))

++d4+=+{"a":+{"x":+1,+"y":+2,+"z":+3,+"d":+{"x1":+10}}}
++d5+=+{"a":+{"x":+10,+"y":+20,+"d":+{"x2":+20}}}
++print(DictHelper.merge_dictionaries(d4,+d5))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4089317|输出：|unstyled|4089318|{'bbbbb':+{'to+long',+'field+is+not+an+integer',+'to+short',+'field+is+not+a+bool'},+
'aaaaaaaaa':+{'to+long',+'to+short',+'filed+is+not+a+string',+'field+is+not+a+bool'},+
'cccccc':+{'the+is+a+test'}}

{'a':+{'y':+20,+'d':+{'x1':+10,+'x2':+20},+'z':+3,+'x':+10}}|4089319|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>from collections import defaultdict
from itertools import chain

class DictHelper:

@staticmethod
def merge_dictionaries(*dictionaries, override=True):
 merged_dict = defaultdict(set)
 all_unique_keys = set(chain(*[list(dictionary.keys()) for dictionary in dictionaries])) # Build a set using all dict keys
 for key in all_unique_keys:
 keys_value_type = list(set(filter(lambda obj_type: obj_type != type(None), [type(dictionary.get(key, None)) for dictionary in dictionaries])))
 # Establish the object type for each key, return None if key is not present in dict and remove None from final result
 if len(keys_value_type) != 1:
 raise Exception("Different objects type for same key: {keys_value_type}".format(keys_value_type=keys_value_type))

 if keys_value_type[0] == list:
 values = list(chain(*[dictionary.get(key, []) for dictionary in dictionaries])) # Extract the value for each key
 merged_dict[key].update(values)

 elif keys_value_type[0] == dict:
 # Extract all dictionaries by key and enter in recursion
 dicts_to_merge = list(filter(lambda obj: obj != None, [dictionary.get(key, None) for dictionary in dictionaries]))
 merged_dict[key] = DictHelper.merge_dictionaries(*dicts_to_merge)

 else:
 # if override =&gt; get value from last dictionary else make a list of all values
 values = list(filter(lambda obj: obj != None, [dictionary.get(key, None) for dictionary in dictionaries]))
 merged_dict[key] = values[-1] if override else values

 return dict(merged_dict)



if __name__ == '__main__':
 d1 = {'aaaaaaaaa': ['to short', 'to long'], 'bbbbb': ['to short', 'to long'], "cccccc": ["the is a test"]}
 d2 = {'aaaaaaaaa': ['field is not a bool'], 'bbbbb': ['field is not a bool']}
 d3 = {'aaaaaaaaa': ['filed is not a string', "to short"], 'bbbbb': ['field is not an integer']}
 print(DictHelper.merge_dictionaries(d1, d2, d3))

 d4 = {"a": {"x": 1, "y": 2, "z": 3, "d": {"x1": 10}}}
 d5 = {"a": {"x": 10, "y": 20, "d": {"x2": 20}}}
 print(DictHelper.merge_dictionaries(d4, d5))
</code></pre>

Output:

<pre><code>{'bbbbb': {'to long', 'field is not an integer', 'to short', 'field is not a bool'}, 
'aaaaaaaaa': {'to long', 'to short', 'filed is not a string', 'field is not a bool'}, 
'cccccc': {'the is a test'}}

{'a': {'y': 20, 'd': {'x1': 10, 'x2': 20}, 'z': 3, 'x': 10}}
</code></pre>

blocks|key|327711|text|你可以试试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|327712|327713|Installation|offset|length|style|BOLD|327714|$+pip3+install+mergedeep|code-block|syntax|javascript|327715|使用|327716|from+mergedeep+import+merge

a+=+{"keyA":+1}
b+=+{"keyB":+{"sub1":+10}}
c+=+{"keyB":+{"sub2":+20}}

merge(a,+b,+c)+

print(a)
#+{"keyA":+1,+"keyB":+{"sub1":+10,+"sub2":+20}}|327717|327718|有关选项的完整列表，请查看docs!|blockquote|327719|327720|entityMap|0|LINK|mutability|MUTABLE|url|https://mergedeep.readthedocs.io/en/latest/^0|0|0|0|C|0|0|0|2|0|0|0|D|4|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|16|8|@$E|17|F|18|G|H]]|9|@]|A|$]]|$1|I|3|J|5|K|7|19|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|1A|8|@$E|1B|F|1C|G|H]]|9|@]|A|$]]|$1|P|3|Q|5|K|7|1D|8|@]|9|@]|A|$L|M]]|$1|R|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1F|8|@]|9|@$E|1G|F|1H|1|1I]]|A|$]]|$1|V|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

You could try <a href="https://github.com/clarketm/mergedeep" rel="noreferrer">mergedeep</a>.

<hr>

Installation

<pre class="lang-sh prettyprint-override"><code>$ pip3 install mergedeep
</code></pre>

Usage

<pre class="lang-py prettyprint-override"><code>from mergedeep import merge

a = {"keyA": 1}
b = {"keyB": {"sub1": 10}}
c = {"keyB": {"sub2": 20}}

merge(a, b, c) 

print(a)
# {"keyA": 1, "keyB": {"sub1": 10, "sub2": 20}}
</code></pre>

<blockquote>
 For a full list of options, check out the <a href="https://mergedeep.readthedocs.io/en/latest/" rel="noreferrer">docs</a>!
</blockquote>

blocks|key|3804086|text|看一看toolz+package|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3804087|import+toolz
dict1={1:{"a":"A"},2:{"b":"B"}}
dict2={2:{"c":"C"},3:{"d":"D"}}
toolz.merge_with(toolz.merge,dict1,dict2)|code-block|syntax|javascript|3804088|给出|3804089|{1:+{'a':+'A'},+2:+{'b':+'B',+'c':+'C'},+3:+{'d':+'D'}}|3804090|entityMap|0|LINK|mutability|MUTABLE|url|https://toolz.readthedocs.io/en/latest/^0|3|5|3|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

take a look at <a href="https://toolz.readthedocs.io/en/latest/" rel="nofollow noreferrer"><code>toolz</code> package</a>

<pre><code>import toolz
dict1={1:{"a":"A"},2:{"b":"B"}}
dict2={2:{"c":"C"},3:{"d":"D"}}
toolz.merge_with(toolz.merge,dict1,dict2)
</code></pre>

gives

<pre><code>{1: {'a': 'A'}, 2: {'b': 'B', 'c': 'C'}, 3: {'d': 'D'}}
</code></pre>

blocks|key|3804092|text|下面的函数将b合并成a。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3804093|def+mergedicts(a,+b):
++++for+key+in+b:
++++++++if+isinstance(a.get(key),+dict)+or+isinstance(b.get(key),+dict):
++++++++++++mergedicts(a[key],+b[key])
++++++++else:
++++++++++++a[key]+=+b[key]
++++return+a|code-block|syntax|javascript|3804094|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|$]]

The following function merges b into a.

<pre><code>def mergedicts(a, b):
 for key in b:
 if isinstance(a.get(key), dict) or isinstance(b.get(key), dict):
 mergedicts(a[key], b[key])
 else:
 a[key] = b[key]
 return a
</code></pre>

blocks|key|2190357|text|还有一个细微的变化：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2190358|这是一个纯粹的基于python3集的深度更新函数。它通过一次循环遍历一个级别来更新嵌套字典，并调用自身来更新每个下一级别的字典值：|2190359|def+deep_update(dict_original,+dict_update):
++++if+isinstance(dict_original,+dict)+and+isinstance(dict_update,+dict):
++++++++output=dict(dict_original)
++++++++keys_original=set(dict_original.keys())
++++++++keys_update=set(dict_update.keys())
++++++++similar_keys=keys_original.intersection(keys_update)
++++++++similar_dict={key:deep_update(dict_original[key],+dict_update[key])+for+key+in+similar_keys}
++++++++new_keys=keys_update.difference(keys_original)
++++++++new_dict={key:dict_update[key]+for+key+in+new_keys}
++++++++output.update(similar_dict)
++++++++output.update(new_dict)
++++++++return+output
++++else:
++++++++return+dict_update|code-block|syntax|javascript|2190360|一个简单的例子：|2190361|x={'a':{'b':{'c':1,+'d':1}}}
y={'a':{'b':{'d':2,+'e':2}},+'f':2}

print(deep_update(x,+y))
>>>+{'a':+{'b':+{'c':+1,+'d':+2,+'e':+2}},+'f':+2}|2190362|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

And just another slight variation:

Here is a pure python3 set based deep update function. It updates nested dictionaries by looping through one level at a time and calls itself to update each next level of dictionary values:

<pre><code>def deep_update(dict_original, dict_update):
 if isinstance(dict_original, dict) and isinstance(dict_update, dict):
 output=dict(dict_original)
 keys_original=set(dict_original.keys())
 keys_update=set(dict_update.keys())
 similar_keys=keys_original.intersection(keys_update)
 similar_dict={key:deep_update(dict_original[key], dict_update[key]) for key in similar_keys}
 new_keys=keys_update.difference(keys_original)
 new_dict={key:dict_update[key] for key in new_keys}
 output.update(similar_dict)
 output.update(new_dict)
 return output
 else:
 return dict_update
</code></pre>

A simple example:

<pre><code>x={'a':{'b':{'c':1, 'd':1}}}
y={'a':{'b':{'d':2, 'e':2}}, 'f':2}

print(deep_update(x, y))
&gt;&gt;&gt; {'a': {'b': {'c': 1, 'd': 2, 'e': 2}}, 'f': 2}
</code></pre>

blocks|key|4089428|text|换个答案怎么样？！？这也避免了突变/副作用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4089429|def+merge(dict1,+dict2):
++++output+=+{}

++++#+adds+keys+from+`dict1`+if+they+do+not+exist+in+`dict2`+and+vice-versa
++++intersection+=+{**dict2,+**dict1}

++++for+k_intersect,+v_intersect+in+intersection.items():
++++++++if+k_intersect+not+in+dict1:
++++++++++++v_dict2+=+dict2[k_intersect]
++++++++++++output[k_intersect]+=+v_dict2

++++++++elif+k_intersect+not+in+dict2:
++++++++++++output[k_intersect]+=+v_intersect

++++++++elif+isinstance(v_intersect,+dict):
++++++++++++v_dict2+=+dict2[k_intersect]
++++++++++++output[k_intersect]+=+merge(v_intersect,+v_dict2)

++++++++else:
++++++++++++output[k_intersect]+=+v_intersect

++++return+output|code-block|syntax|javascript|4089430|dict1+=+{1:{"a":{"A"}},+2:{"b":{"B"}}}
dict2+=+{2:{"c":{"C"}},+3:{"d":{"D"}}}
dict3+=+{1:{"a":{"A"}},+2:{"b":{"B"},"c":{"C"}},+3:{"d":{"D"}}}

assert+dict3+==+merge(dict1,+dict2)|4089431|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|D|7|M|8|@]|9|@]|A|$E|F]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

How about another answer?!? This one also avoids mutation/side effects:

<pre class="lang-py prettyprint-override"><code>def merge(dict1, dict2):
 output = {}

 # adds keys from `dict1` if they do not exist in `dict2` and vice-versa
 intersection = {**dict2, **dict1}

 for k_intersect, v_intersect in intersection.items():
 if k_intersect not in dict1:
 v_dict2 = dict2[k_intersect]
 output[k_intersect] = v_dict2

 elif k_intersect not in dict2:
 output[k_intersect] = v_intersect

 elif isinstance(v_intersect, dict):
 v_dict2 = dict2[k_intersect]
 output[k_intersect] = merge(v_intersect, v_dict2)

 else:
 output[k_intersect] = v_intersect

 return output

</code></pre>

<pre class="lang-py prettyprint-override"><code>dict1 = {1:{"a":{"A"}}, 2:{"b":{"B"}}}
dict2 = {2:{"c":{"C"}}, 3:{"d":{"D"}}}
dict3 = {1:{"a":{"A"}}, 2:{"b":{"B"},"c":{"C"}}, 3:{"d":{"D"}}}

assert dict3 == merge(dict1, dict2)
</code></pre>

blocks|key|2190386|text|我有一个迭代式的解决方案-在处理大字典时效果要好得多&很多字典(例如json等)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2190387|import+collections


def+merge_dict_with_subdicts(dict1:+dict,+dict2:+dict)+->+dict:
++++"""
++++similar+behaviour+to+builtin+dict.update+-+but+knows+how+to+handle+nested+dicts
++++"""
++++q+=+collections.deque([(dict1,+dict2)])
++++while+len(q)+>+0:
++++++++d1,+d2+=+q.pop()
++++++++for+k,+v+in+d2.items():
++++++++++++if+k+in+d1+and+isinstance(d1[k],+dict)+and+isinstance(v,+dict):
++++++++++++++++q.append((d1[k],+v))
++++++++++++else:
++++++++++++++++d1[k]+=+v

++++return+dict1|code-block|syntax|javascript|2190388|请注意，这将使用d2中的值覆盖d1，以防它们不是两个dict。(与python的dict.update()相同)|offset|length|style|CODE|2190389|一些测试：|2190390|def+test_deep_update():
++++d+=+dict()
++++merge_dict_with_subdicts(d,+{"a":+4})
++++assert+d+==+{"a":+4}

++++new_dict+=+{
++++++++"b":+{
++++++++++++"c":+{
++++++++++++++++"d":+6
++++++++++++}
++++++++}
++++}
++++merge_dict_with_subdicts(d,+new_dict)
++++assert+d+==+{
++++++++"a":+4,
++++++++"b":+{
++++++++++++"c":+{
++++++++++++++++"d":+6
++++++++++++}
++++++++}
++++}

++++new_dict+=+{
++++++++"a":+3,
++++++++"b":+{
++++++++++++"f":+7
++++++++}
++++}
++++merge_dict_with_subdicts(d,+new_dict)
++++assert+d+==+{
++++++++"a":+3,
++++++++"b":+{
++++++++++++"c":+{
++++++++++++++++"d":+6
++++++++++++},
++++++++++++"f":+7
++++++++}
++++}

++++#+test+a+case+where+one+of+the+dicts+has+dict+as+value+and+the+other+has+something+else
++++new_dict+=+{
++++++++'a':+{
++++++++++++'b':+4
++++++++}
++++}
++++merge_dict_with_subdicts(d,+new_dict)
++++assert+d['a']['b']+==+4|2190391|我已经测试了大约1200个字典-这种方法花费了0.4秒，而递归解决方案花费了大约2.5秒。|2190392|entityMap^0|0|0|14|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I have an iterative solution - works much much better with big dicts &amp; a lot of them (for example jsons etc): 

<pre><code>import collections


def merge_dict_with_subdicts(dict1: dict, dict2: dict) -&gt; dict:
 """
 similar behaviour to builtin dict.update - but knows how to handle nested dicts
 """
 q = collections.deque([(dict1, dict2)])
 while len(q) &gt; 0:
 d1, d2 = q.pop()
 for k, v in d2.items():
 if k in d1 and isinstance(d1[k], dict) and isinstance(v, dict):
 q.append((d1[k], v))
 else:
 d1[k] = v

 return dict1
</code></pre>

note that this will use the value in d2 to override d1, in case they are not both dicts. (same as python's <code>dict.update()</code>)

some tests:

<pre><code>def test_deep_update():
 d = dict()
 merge_dict_with_subdicts(d, {"a": 4})
 assert d == {"a": 4}

 new_dict = {
 "b": {
 "c": {
 "d": 6
 }
 }
 }
 merge_dict_with_subdicts(d, new_dict)
 assert d == {
 "a": 4,
 "b": {
 "c": {
 "d": 6
 }
 }
 }

 new_dict = {
 "a": 3,
 "b": {
 "f": 7
 }
 }
 merge_dict_with_subdicts(d, new_dict)
 assert d == {
 "a": 3,
 "b": {
 "c": {
 "d": 6
 },
 "f": 7
 }
 }

 # test a case where one of the dicts has dict as value and the other has something else
 new_dict = {
 'a': {
 'b': 4
 }
 }
 merge_dict_with_subdicts(d, new_dict)
 assert d['a']['b'] == 4

</code></pre>

I've tested with around ~1200 dicts - this method took 0.4 seconds, while the recursive solution took ~2.5 seconds.

blocks|key|2190417|text|我还没有对此进行过广泛的测试，因此，鼓励您提供反馈。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2190418|from+collections+import+defaultdict

dict1+=+defaultdict(list)

dict2=+defaultdict(list)

dict3=+defaultdict(list)


dict1=+dict(zip(Keys[+],values[+]))

dict2+=+dict(zip(Keys[+],values[+]))


def+mergeDict(dict1,+dict2):

++++dict3+=+{**dict1,+**dict2}

++++for+key,+value+in+dict3.items():

++++++++if+key+in+dict1+and+key+in+dict2:

+++++++++++dict3[key]+=+[value+,+dict1[key]]

++++return+dict3

dict3+=+mergeDict(dict1,+dict2)

#sort+keys+alphabetically.

dict3.keys()|code-block|syntax|javascript|2190419|Merge+two+dictionaries+and+add+values+of+common+keys|offset|length|2190420|entityMap|0|LINK|mutability|MUTABLE|url|https://thispointer.com/how-to-merge-two-or-more-dictionaries-in-python/^0|0|0|0|1G|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|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

I have not extensively tested this, so, your feedback is encouraged.
<pre><code>from collections import defaultdict

dict1 = defaultdict(list)

dict2= defaultdict(list)

dict3= defaultdict(list)


dict1= dict(zip(Keys[ ],values[ ]))

dict2 = dict(zip(Keys[ ],values[ ]))


def mergeDict(dict1, dict2):

 dict3 = {**dict1, **dict2}

 for key, value in dict3.items():

 if key in dict1 and key in dict2:

 dict3[key] = [value , dict1[key]]

 return dict3

dict3 = mergeDict(dict1, dict2)

#sort keys alphabetically.

dict3.keys()
</code></pre>
<a href="https://thispointer.com/how-to-merge-two-or-more-dictionaries-in-python/" rel="nofollow noreferrer">Merge two dictionaries and add values of common keys</a>

I need to merge multiple dictionaries, here's what I have for instance:

<pre><code>dict1 = {1:{"a":{A}}, 2:{"b":{B}}}

dict2 = {2:{"c":{C}}, 3:{"d":{D}}
</code></pre>

With <code>A</code> <code>B</code> <code>C</code> and <code>D</code> being leaves of the tree, like <code>{"info1":"value", "info2":"value2"}</code>

There is an unknown level(depth) of dictionaries, it could be <code>{2:{"c":{"z":{"y":{C}}}}}</code>

In my case it represents a directory/files structure with nodes being docs and leaves being files.

I want to merge them to obtain:

<pre><code> dict3 = {1:{"a":{A}}, 2:{"b":{B},"c":{C}}, 3:{"d":{D}}}
</code></pre>

I'm not sure how I could do that easily with Python.

How to merge dictionaries of dictionaries?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我需要合并多个字典，下面是我所拥有的示例：dict1 = {1:{"a":{A}}, 2:{"b":{B}}}dict2 = {2:{"c":{C}}, 3:{"d":{D}}A B C和D是树的叶子，就像{"info1":"value", "info2":"value2"}一样有一个未知级别(深度)的字典，它可能是{...

问如何合并字典中的字典？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何合并字典中的字典？EN