如何优化Python嵌套字典中的多层for循环以提升代码效率？

原始嵌套字典 #

flag_dict = {
    'modl1': {
        'slide1': {
            'screens': {
                'screen1': {
                    'mp4_1': 1,
                    'mp4_2': 0,
                    'mp4_3': 1
                }
            }
        },
        'slide2': {
            'screens': {
                'screen1': {
                    'mp4_1': 0,
                    'mp4_2': 1,
                    'mp4_3': 0
                },
                'screen2': {
                    'mp4_1': 1,
                    'mp4_2': 0,
                    'mp4_3': 1
                }
            }
        }
    },
    'modl2': {
        'slide1': {
            'screens': {
                'screen1': {
                    'mp4_1': 1,
                    'mp4_2': 1,
                    'mp4_3': 0
                }
            }
        },
        'slide2': {
            'screens': {
                'screen1': {
                    'mp4_1': 0,
                    'mp4_2': 1,
                    'mp4_3': 1
                },
                'screen2': {
                    'mp4_1': 1,
                    'mp4_2': 0,
                    'mp4_3': 1
                }
            }
        }
    }
}

原始遍历统计代码 #

count = []
for modl1, mv in flag_dict.items():
    if isinstance(mv, dict):
        for slide1, sv in mv.items():

            for screen1, scv in sv['screens'].items():

                key_lis = []
                for key, val in scv.items():

                    if 'mp4' in key:
                        key_lis.append(key)
                for i in key_lis:
                    if scv[i] == 1:
                        count.append(scv[i])
print(count)

优化方案 #

方案1：简化循环层级，直接计数 #

原始代码存在冗余循环（先收集mp4键再遍历判断），且用列表存储1间接统计数量，可直接合并逻辑并使用计数器：

count = 0
# 遍历所有模块
for modl in flag_dict.values():
    # 遍历模块下的所有幻灯片
    for slide in modl.values():
        # 遍历幻灯片下的所有屏幕
        for screen in slide['screens'].values():
            # 直接统计当前屏幕中值为1的mp4键数量
            count += sum(val for key, val in screen.items() if 'mp4' in key and val == 1)
print(count)  # 输出：11

优势：层级清晰，逻辑直接，去掉了不必要的中间列表和循环，效率提升明显。

方案2：用生成器表达式扁平化统计 #

利用Python生成器表达式将多层循环扁平化，直接通过sum计算总数，代码最简洁：

count = sum(
    val
    for modl in flag_dict.values()
    for slide in modl.values()
    for screen in slide['screens'].values()
    for key, val in screen.items()
    if 'mp4' in key and val == 1
)
print(count)  # 输出：11

优势：一行核心逻辑完成统计，可读性强，生成器的内存效率更高（无需存储中间结果）。

方案3：递归适配可变嵌套结构 #

如果字典嵌套层级可能发生变化（比如新增更多层级），可以用递归函数遍历所有节点：

def count_mp4_ones(data):
    total = 0
    if isinstance(data, dict):
        for key, value in data.items():
            # 匹配mp4键且值为1的情况
            if 'mp4' in key and value == 1:
                total += 1
            # 递归遍历子字典
            else:
                total += count_mp4_ones(value)
    return total

count = count_mp4_ones(flag_dict)
print(count)  # 输出：11

优势：无需硬编码嵌套层级，适配结构变化的场景，扩展性更强。

原始代码的问题总结 #

1. 循环变量名冗余（如modl1、slide1），实际是遍历所有模块/幻灯片，用通用名称更清晰；
2. 先收集mp4键再遍历判断，多了一层不必要的循环；
3. 用列表存储1再通过len(count)统计数量，不如直接用计数器变量高效。

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