tmp 字典合并

inpt = {‘a1.v‘: 5, ‘a2.b1‘: 44, ‘a2.b2‘: 424, ‘c1.cc.e‘: 3, ‘c1.cc.f‘: 33, ‘ac‘: 6, ‘a.bf.r.t‘: 9}
# 逐个合并前的dic
dics = []


# key不会做为其他key的前缀
# e:{‘a‘:12,‘a.b‘:34}
# 但允许
# e:{‘a.b1‘:12,‘a.b2‘:34}

def f():
    # 原始key
    ks0 = inpt.keys()
    # 遍历
    for i in ks0:
        child = {}
        # 拆分key
        ks, v = i.split(‘.‘), inpt[i]
        k = ks[- 1]
        child[k] = v
        for ii in range(-2, -len(ks) - 1, -1):
            # 从内向外建立dic
            thisChild = {}
            k = ks[ii]
            thisChild[k] = child
            child = thisChild
        dics.append(child)


def getDepth(d):
    r = 0
    while type(d) == dict:
        for k in d.keys():
            if k is None:
                break
            r += 1
            d = d[k]
    return r


f()


def getNestedDic(keys, tail=None):
    len_, ret = len(keys), tail
    for i in range(-1, -len_ - 1, -1):
        ret = {keys[i]: ret}
    return ret


def getNestedDicTail(dic, keys):
    if not type(dic) == dict:
        return dic
    return dic[keys[-1]]


def getDicChild(d, keys, tail=None):
    ‘‘‘
    求key链路下的dic
    {‘a‘:{‘b‘:{‘c‘:4}}},[‘a‘,‘r‘]
    <class ‘dict‘>: {‘b‘: {‘c‘: 4}, ‘r‘: {}}
    {‘a‘:{‘b‘:{‘c‘:4}}},[‘a‘]
    <class ‘dict‘>: {‘b‘: {‘c‘: 4}}
    {‘a‘:{‘b‘:{‘c‘:4},‘b2‘:{‘c2‘:44}}},[‘a‘,‘r‘]
    <class ‘dict‘>: {‘b‘: {‘c‘: 4}, ‘b2‘: {‘c2‘: 44}, ‘r‘: {}}
    {‘b‘:4}, [‘b1‘,‘gg‘]
    <class ‘dict‘>: {‘b‘: 4, ‘b1‘: {‘gg‘: None}}
    :param d:
    :param keys:
    :return:
    ‘‘‘
    r = d
    len_ = len(keys)
    r_same = {}
    for i in range(0, len_, 1):
        k = keys[i]
        # 关键代码

        if k in r:
            # 从入口修改
            if i == 0:
                pass
            # {‘a‘:{‘b‘:12}}
            # {‘a‘:{‘c‘:34}} 如何合并
            r = r[k]
            # if type(r[k]) == dict:
            #     r = r[k]
            # else:
            #     pass
            # pass
        else:
            r[k] = getNestedDic(keys[i + 1:], tail=tail)
            r = r[k]
            break
    return r


def getKeys(d):
    """
    keys单链路
    {‘a‘:{‘b‘:12}} yes
    {‘a‘:12,‘b‘:34} not
    :param d:
    :return:
    """
    ret = []
    while type(d) == dict:
        for k in d.keys():
            ret.append(k)
    return ret

def mergeDics(d0, d1):
    ‘‘‘
    keys单链路
    {‘a‘:{‘b‘:{‘c‘:12}}}
    {‘a‘:{‘b1‘:34}}
    {‘a‘:{‘b‘:{‘c‘:12},‘b1‘:34}}
    :param d0:
    :param d1:
    :return:
    ‘‘‘
    d0Dep, d1Dep = getDepth(d0), getDepth(d1)
    if d0Dep > d1Dep:
        b, s = d0Dep, d1Dep
    else:
        s, b = d0Dep, d1Dep
    r=b
    b_keys,s_keys=getKeys(b),getKeys(s)
    b_len,s_len= len(b_keys),len(s_keys)
    for i in range(0, b_len, 1):
        if i+1<s_len:
            continue
        elif i+1==s_len:
            pass



# 怎么更新一个dic？
# 怎么更新一个dic的某个key链路？
#
‘‘‘
dictionary1={‘level1‘:{‘level2‘:{‘levelA‘:0,‘levelB‘:1}},‘anotherLevel1‘:{‘anotherLevel2‘:{‘anotherLevelA‘:0,‘anotherLevelB‘:1}}}
update={‘anotherLevel1‘:{‘anotherLevel2‘:1014}}
dictionary1.update(update)
print dictionary1
{‘level1‘: {‘level2‘: {‘levelB‘: 10}},‘anotherLevel1‘:{‘anotherLevel2‘:1014}}

‘‘‘

import copy

ret = {}
for i in dics:
    print(i)
    ii = copy.deepcopy(i)
    depth = getDepth(ii)
    keys = []
    for _ in range(0, depth, 1):
        for k in ii:
            keys.append(k)
            ii = ii[k]
    # 此处已经实现了更新
    d = getDicChild(ret, keys, tail=getNestedDicTail(ii, keys))
    print(f‘keys {keys[0]}‘)

    ret[keys[0]] = d
    dd = 9

import pprint

pprint.pprint(inpt)
pprint.pprint(ret)
s = 0
# while True and 4 > 6:
#     rank_num = 0
#     ret = {}
#     for i in dics:
#         depth = getDepth(i)
#         keys = []
#         for _ in range(0, depth, 1):
#             for k in i:
#                 keys.append(k)
#         d = getDicChild(ret, keys)
#         ret[keys[0]] = d

# ret[k]=0
#
# for k in i:
#     if k not in ret:
#         ret[k] = {}
#         idx = dics.index(i)
#         if type(i[k]) == dict:
#             dics[idx] = i[k]
#         else:
#             dics[idx] = None

# d = 9


dd = 0