如何获取三级嵌套字典中各二级键对应的最大value值

我有一个三级嵌套字典，需要找到第三级字典的最大值，并将其映射到所属的二级键。例如在"Loc-1"字典中，有两个二级键为"36"的项，希望将该键映射到值"56"。

原字典如下：

{
    "Loc-1": {
        "A-1": {"36" : {"value" : "34"}},
        "A-2": {"36" : {"value" : "56"}},
        "A-3": {"48" : {"value" : "72"}},
        "A-4": {"100" : {"value" : "77"}},
        "A-5": {"48" : {"value" : "2"}},
        "A-6": {"100" : {"value" : "10"}},
        "A-7": {"44" : {"value": "21"}}
        
    },
    "Loc-2": {
        "A-8": {"44" : {"value" : "52"}},
        "A-9": {"48" : {"value" : "23"}},
        "A-10": {"40" : {"value" : "62"}},
        "A-11": {"153" : {"value" : "43"}},
        "A-12": {"40" : {"value" : "22"}},
        "A-13": {"153" : {"value" : "10"}},
        "A-14": {"36" : {"value": "21"}}
        
    }
}

期望结果：

{ 
    "Loc-1": {   
        "36" : "56",
        "48" : "72",
        "100": "77",
        "44" : "21"
        
    },
    "Loc-2": { 
        "36" : "21",
        "40" : "62",
        "48" : "23",
        "44" : "52",
        "153": "43",
        
    }
}

我难以处理这种嵌套结构下相同键的所有值比较，请问该如何实现？

可以通过嵌套循环结合临时字典来统计每个二级键对应的最大值，注意需要将字符串类型的数值转为整数进行比较，最后再转回字符串以匹配期望格式。

代码示例 #

original_dict = {
    "Loc-1": {
        "A-1": {"36": {"value": "34"}},
        "A-2": {"36": {"value": "56"}},
        "A-3": {"48": {"value": "72"}},
        "A-4": {"100": {"value": "77"}},
        "A-5": {"48": {"value": "2"}},
        "A-6": {"100": {"value": "10"}},
        "A-7": {"44": {"value": "21"}}
    },
    "Loc-2": {
        "A-8": {"44": {"value": "52"}},
        "A-9": {"48": {"value": "23"}},
        "A-10": {"40": {"value": "62"}},
        "A-11": {"153": {"value": "43"}},
        "A-12": {"40": {"value": "22"}},
        "A-13": {"153": {"value": "10"}},
        "A-14": {"36": {"value": "21"}}
    }
}

result = {}

# 遍历每个一级位置（Loc-1、Loc-2）
for loc, a_items in original_dict.items():
    temp = {}
    # 遍历每个位置下的A-*项
    for a_item in a_items.values():
        # 取出二级键和对应的value字典
        for key, value_dict in a_item.items():
            current_val = int(value_dict["value"])
            # 更新临时字典：键不存在则存入，否则保留更大值
            if key not in temp or current_val > temp[key]:
                temp[key] = current_val
    # 将数值转回字符串，匹配期望格式
    result[loc] = {k: str(v) for k, v in temp.items()}

print(result)

逻辑说明 #

1. 外层循环：遍历一级键（如Loc-1），为每个位置初始化临时字典temp，用于存储该位置下各二级键的最大值。
2. 中层循环：遍历每个位置下的所有A-*项，取出每个项对应的字典（仅含一个二级键和value字典）。
3. 内层循环：提取二级键和对应的数值（转成整数方便比较），更新临时字典：若键不存在则直接存入，若已存在则保留较大的数值。
4. 格式转换：将临时字典中的整数转回字符串，存入最终结果字典，确保输出格式与期望一致。

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