使用Python删除嵌套字典重复值，仅保留连续相同值的首尾项

实现逻辑 #

你的需求核心是对每个子字典中连续相同值的键值对，仅保留每组的首尾项，由于子字典的键本身是按数字递增排列的，我们可以按以下步骤实现：

1. 遍历外层嵌套字典的每一个子字典
2. 将子字典的键值对按键的大小排序，兼容非插入有序的Python版本，避免键顺序混乱导致的分组错误
3. 对排序后的键值对按值进行连续分组，相同值的连续项归为同一组
4. 每组仅保留第一个和最后一个键值对，拼接成新的子字典

完整可运行代码 #

版本1：使用itertools实现（代码简洁）

from itertools import groupby

# 原始嵌套字典
original_dict = {
    "sphere": {
        1: "False",
        2: "False",
        3: "False",
        4: "True",
        5: "True",
        6: "False",
        7: "False",
        8: "False",
        9: "False",
    },
    "cube": {
        1: "True",
        2: "True",
        3: "False",
        4: "False",
        5: "False",
        6: "True",
        7: "True",
        8: "False",
        9: "False",
    },
    "torus": {
        1: "True",
        2: "True",
        3: "True",
        4: "False",
        5: "False",
        6: "False",
        7: "False",
        8: "True",
        9: "True",
    },
}

def process_sub_dict(sub_dict):
    # 按键升序排列子字典的键值对
    sorted_items = sorted(sub_dict.items(), key=lambda x: x[0])
    new_sub = {}
    # 按值连续分组
    for val, group in groupby(sorted_items, key=lambda x: x[1]):
        group_list = list(group)
        # 加入每组第一个元素
        first_k, first_v = group_list[0]
        new_sub[first_k] = first_v
        # 如果组长度大于1，再加入最后一个元素
        if len(group_list) > 1:
            last_k, last_v = group_list[-1]
            new_sub[last_k] = last_v
    return new_sub

# 处理整个嵌套字典
result_dict = {k: process_sub_dict(v) for k, v in original_dict.items()}

# 打印验证结果
import json
print(json.dumps(result_dict, indent=4))

版本2：手动遍历实现（无需导入第三方库）

如果不想依赖itertools，可以用原生遍历实现相同效果，替换上面的process_sub_dict函数即可：

def process_sub_dict(sub_dict):
    sorted_items = sorted(sub_dict.items(), key=lambda x: x[0])
    if not sorted_items:
        return {}
    new_sub = {}
    # 初始化当前组的首项和当前值
    current_val = sorted_items[0][1]
    group_start = sorted_items[0]
    prev_item = sorted_items[0]
    
    for item in sorted_items[1:]:
        k, v = item
        if v != current_val:
            # 值变化，结束上一组
            new_sub[group_start[0]] = group_start[1]
            # 上一组长度大于1的话加尾项
            if group_start != prev_item:
                new_sub[prev_item[0]] = prev_item[1]
            # 重置当前组
            current_val = v
            group_start = item
        prev_item = item
    # 处理最后一组
    new_sub[group_start[0]] = group_start[1]
    if group_start != prev_item:
        new_sub[prev_item[0]] = prev_item[1]
    return new_sub

运行上述代码输出的结果和你给出的期望结构完全一致。

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