如何保留Python嵌套字典中各子键的最大值并清理冗余？

给定如下嵌套结构的Python字典dict4：

dict4 =  {
    234: [{'apple': 87}, {'fan': 88}, {'jackal': 89}],
    345: [{'bat': 98}, {'car': 84}, {'ice': 80}],
    456: [{'car': 86}, {'apple': 82}, {'goat': 80}],
    567: [{'dog': 81}, {'cat': 80}, {'eagle': 90}],
    678: [{'eagle': 98}, {'hawk': 89}, {'dog': 79}],
    789: [{'fan': 89}, {'goat': 84}, {'car': 81}],
    890: [{'hawk': 90}, {'ice': 85}, {'cat': 78}],
    901: [{'goat': 85}, {'jackal': 90}, {'apple': 80}],
    123: [{'ice': 87}, {'bat': 94}, {'bat': 92}],
    546: [{'jackal': 91}, {'eagle': 93}, {'fan': 85}]
}

要求：每个子键（如apple）会在不同位置多次出现，需保留每个子键对应值最大的条目，删除其余冗余条目，最终得到如下结果：

dict4 =  {
    234: [{'apple': 87}],
    345: [{'bat': 98}],
    456: [{'car': 86}],
    567: [{'dog': 81}, {'cat': 80}],
    678: [{'eagle': 98}],
    789: [{'fan': 89}],
    890: [{'hawk': 90}],
    901: [{'goat': 85}],
    123: [{'ice': 87}],
    546: [{'jackal': 91}]
}

步骤1：统计所有子键的最大值 #

先遍历整个字典，用临时字典记录每个子键对应的最大数值，比如apple的最大值是87、bat的最大值是98，这一步是后续筛选的依据。

步骤2：构建目标字典 #

再次遍历原字典的每个键值对，对每个列表里的小字典，只保留子键值等于最大值的条目，同时确保每个子键仅保留一次（因为最大值唯一）。

完整代码 #

# 原字典
dict4 =  {
    234: [{'apple': 87}, {'fan': 88}, {'jackal': 89}],
    345: [{'bat': 98}, {'car': 84}, {'ice': 80}],
    456: [{'car': 86}, {'apple': 82}, {'goat': 80}],
    567: [{'dog': 81}, {'cat': 80}, {'eagle': 90}],
    678: [{'eagle': 98}, {'hawk': 89}, {'dog': 79}],
    789: [{'fan': 89}, {'goat': 84}, {'car': 81}],
    890: [{'hawk': 90}, {'ice': 85}, {'cat': 78}],
    901: [{'goat': 85}, {'jackal': 90}, {'apple': 80}],
    123: [{'ice': 87}, {'bat': 94}, {'bat': 92}],
    546: [{'jackal': 91}, {'eagle': 93}, {'fan': 85}]
}

# 统计每个子键的最大值
max_values = {}
for sub_list in dict4.values():
    for item in sub_list:
        key = next(iter(item.keys()))
        val = item[key]
        if key not in max_values or val > max_values[key]:
            max_values[key] = val

# 构建结果字典，确保每个子键只保留一次
result = {}
used_keys = set()

for parent_key, sub_list in dict4.items():
    for item in sub_list:
        key = next(iter(item.keys()))
        val = item[key]
        if val == max_values[key] and key not in used_keys:
            used_keys.add(key)
            if parent_key not in result:
                result[parent_key] = []
            result[parent_key].append(item)

# 按原字典键的顺序整理结果（可选，匹配示例输出结构）
sorted_result = {k: result[k] for k in dict4.keys() if k in result}

# 输出最终结果
print("dict4 = ", sorted_result)

代码说明 #

• 第一步通过遍历所有子条目，用max_values存储每个子键的峰值，为后续筛选提供判断标准。
• 第二步遍历原字典时，用used_keys集合记录已保留的子键，避免同一子键被多次添加。
• 最后按原字典的键顺序排序，让输出结构和示例完全一致（不需要顺序的话可跳过此步骤）。

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