dict.py

字典的一些高级方法：
- 字典的递归合并
- 字典平铺
- 字典折叠

```
from copy import deepcopy

def prefix_dict(data, prefix_s=''):
    """
    把字典的每个key都带上前缀prefix_s
    :param data:
    :param prefix_s:
    :return:
    """
    return {prefix_s + k: v for k, v in data.items()}

def dict_unfold(data, con_s='.'):
    """
    平铺dict(如果下层还是dict)，需要递归，展开到下层的数据类型不是字典为止
    可能实用的地方：将文档类的数据格式化成更加关系化的样子可能有用
    :param data: 输入字典
    :param con_s: 层级间的连接符号
    :return: 深度不大于1的字典，嵌套的其他数据类型照旧
    """
    ret_di = {}
    for k, v in data.items():
        if isinstance(v, dict):
            v = dict_unfold(v)
            # 这里或许有不写到这一层的更好写法
            # for k_, v_ in v.items():
            #     ret_di.update({con_s.join([k, k_]): v_})
            ret_di.update(prefix_dict(v, prefix_s=k + con_s))
        else:
            ret_di.update({k: v})
    return ret_di

def dict_merge(a, b):
    """
    合并字典（以递归的方式）
    普通的dict.update()不能递归的合并，而是直接替换
    """
    if not isinstance(b, dict):
        return b
    result = deepcopy(a)
    for k, v in b.items():
        if k in result and isinstance(result[k], dict):
            result[k] = dict_merge(result[k], v)
        else:
            result[k] = deepcopy(v)
    return result

def dict_fold(data, split_="."):
    """折叠dict：将平铺后的字典再折叠起来"""
    result = {}
    for k, v in data.items():
        if split_ in k:
            ks = k.split(split_)
            d = result
            for i, k0 in enumerate(ks):
                if i < len(ks) - 1:
                    if k0 not in d:
                        d[k0] = {}
                    d = d[k0]
                else:
                    d[k0] = v
        else:
            result.update({k: v})
    return result

if __name__ == "__main__":
    d = {
        "name": "111",
        "job": {
            "company": "222",
            "title": "333",
            "location": "555",
            "abc": {
                "a": "a",
                "b": "b",
            }
        }
    }
    r = dict_unfold(d)
    print(r)
    r = dict_fold(r)
    print(r)

```