如何基于文件名从文件列表构建嵌套字典？

我有一个装满文件的文件夹，需要加载这些文件并重构嵌套字典，文件名包含字典的层级结构。例如文件vz_ERA_Neural_Water_Forecast.npy中，vz是原字典名，ERA为第一层键，Neural为第二层键，部分文件嵌套3层，部分可达5层。

尝试的代码 #

# Get list of all the files to load
files = os.listdir(Path(fc.selected,'vz_save'))
# remove from list name of file that contains files we care about and hidden files
files.remove('fileNamesAndTypes.txt')
for file in files:
    if file.startswith('.'):
        files.remove(file)


# creat an empty dictionary in which to eventually allocate the loaded files
vz_check = {}

for file in files: 
    #print(file)
    ext = Path(file).suffix
    fileNoExt = Path(file).stem # remove the file extension (file type)
    keys = fileNoExt.split('_')
    keys.remove('vz')
        
    # find matching fileNoExt to value in fileNamesAndTypes[key]
    reloadedType = fileNamesAndTypes_check[fileNoExt]
        
        
    # load the file?
    if reloadedType == str:
        #print(f"type=str; reloadedType={reloadedType}")
        reload = open(Path(fc.selected,'vz_save',file),'rb')
        contents = reload.read()
        print(contents)
        for key in reversed(keys):
            vz_check = {key: vz_check}
    elif reloadedType == xr.core.dataset.Dataset:
        #print(f"type=xr.core.dataset.Dataset; reloadedType={reloadedType}")
    elif reloadedType == xr.core.dataarray.DataArray:
        #print(f"type=xr.core.dataarray.DataArray; reloadedType={reloadedType}")
    elif reloadedType == int:
        #print(f"type=int; reloadedType={reloadedType}")
    elif reloadedType == list:
        #print(f"type=list; reloadedType={reloadedType}")
    elif reloadedType == np.ndarray:
        #print(f"type=np.ndarray; reloadedType={reloadedType}")

遇到的问题 #

运行上述代码后，得到的是每层仅含单个键的过度嵌套结构，无法实现每层包含多个键的正确嵌套，预期结构需匹配原字典层级。

临时解决方案（繁琐） #

def buildDict(keyss,contentss,theDict):
    if len(keyss) == 1:
        theDict = {keyss: contentss}
    elif len(keyss) == 2:
        theDict = {keyss[0] : { keyss[1] : contentss } }
    elif len(keyss) == 3: 
        theDict = {keyss[0] : {keyss[1] : {keyss[2] : contentss } } }
    elif len(keyss) == 4: 
        theDict = {keyss[0] : {keyss[1] : {keyss[2] : {keyss[3] : contentss } } } }
    elif len(keyss) == 5: 
        theDict = {keyss[0] : {keyss[1] : {keyss[2] : {keyss[3] : {keyss[4] : contentss } } } } }

优化方案 #

可以用迭代方式逐层构建嵌套字典，无需硬编码层级数量，同时保证同一层级的键能被正确合并：

def build_nested_dict(keys, content, root_dict):
    current_level = root_dict
    # 遍历到倒数第二层，确保父级字典存在
    for key in keys[:-1]:
        if key not in current_level:
            current_level[key] = {}
        current_level = current_level[key]
    # 将内容赋值给最后一级键
    current_level[keys[-1]] = content

使用方式 #

在加载文件的循环中，替换原有的嵌套逻辑，调用上述函数即可：

if reloadedType == str:
    with open(Path(fc.selected,'vz_save',file),'rb') as reload:  # 用with自动关闭文件
        contents = reload.read()
    build_nested_dict(keys, contents, vz_check)
# 其他数据类型的加载逻辑同理，加载完成后调用build_nested_dict

这个方法支持任意层级的嵌套，且同一父键下的多个子键会被正确添加到对应字典中，不会覆盖已有结构。

内容的提问来源于stack exchange，提问作者Kas Knicely