具有不规则嵌套层次结构的嵌套字典处理

Question

如何处理一对具有部分键重叠的嵌套字典？

dict1 = {
    'A': {'a': 1},
    'B': 2,
    'C': {'c': 3},
    'D': {'d': {'dd': 4}}
}

dict2 = {
    'A': {'a': 1},
    'D': {'d': {'dd': 4}}
}

期望的输出应该是：

dict1 + dict2= {
    'A': {'a': 2},
    'B': 2,
    'C': {'c': 3},
    'D': {'d': {'dd': 8}}
}

按键添加平面字典很简单：

{k: dict1[k] + dict2[k] for k, v in dict2.items()}

我怎样才能对嵌套字典做同样的事情？

Answer 1

你可以尝试自己定义一个递归函数：

import json
from collections.abc import Mapping
from typing import Any


def _pretty_print_dict(label: str, d: Mapping[Any, Any]) -> None:
  """Pretty print a dictionary."""
  print(f'{label}:')
  print(json.dumps(d, indent=2, sort_keys=True))


def merge_mappings(m1: Mapping[Any, Any],
                   m2: Mapping[Any, Any]) -> Mapping[Any, Any]:
  """Merge two mappings recursively."""
  merged = {}
  for key in m1.keys() | m2.keys():
    if key in m1 and key in m2:
      if isinstance(m1[key], dict) and isinstance(m2[key], dict):
        merged[key] = merge_mappings(m1[key], m2[key])
      else:
        merged[key] = m1[key] + m2[key]
    elif key in m1:
      merged[key] = m1[key]
    else:
      merged[key] = m2[key]
  return merged


def main() -> None:
  d1 = {'A': {'a': 1}, 'B': 2, 'C': {'c': 3}, 'D': {'d': {'dd': 4}}}
  _pretty_print_dict('d1', d1)
  d2 = {'A': {'a': 1}, 'D': {'d': {'dd': 4}}}
  _pretty_print_dict('d2', d2)
  result = merge_mappings(d1, d2)
  _pretty_print_dict('result', result)


if __name__ == '__main__':
  main()

输出：

d1:
{
  "A": {
    "a": 1
  },
  "B": 2,
  "C": {
    "c": 3
  },
  "D": {
    "d": {
      "dd": 4
    }
  }
}
d2:
{
  "A": {
    "a": 1
  },
  "D": {
    "d": {
      "dd": 4
    }
  }
}
result:
{
  "A": {
    "a": 2
  },
  "B": 2,
  "C": {
    "c": 3
  },
  "D": {
    "d": {
      "dd": 8
    }
  }
}