如何遍历嵌套字典列表并生成三层嵌套结构的defaultdict

解析嵌套字典结构，遍历所有内部值，将每个迭代实例的单个值存入列表，最终生成外层长度为1的三层嵌套列表结构的defaultdict。现有代码输出为扁平列表，无法满足需求。

现有代码 #

import json
import yaml
from collections import defaultdict
from itertools import zip_longest
logic = yaml.safe_dump('{"$or":[{"$and":[{"baseOperator":null,"operator":"equals","operand1":"metrics.6266","operand2":1},{"baseOperator":null,"operator":"is_true","operand1":"flags.6372","operand2":0}]},{"$and":[{"baseOperator":null,"operator":"equals","operand1":"metrics.6266","operand2":1},{"baseOperator":null,"operator":"is_true","operand1":"flags.15112","operand2":0}]}]}')
logic = yaml.safe_load(logic)
logic = json.loads(logic)
logic = [logic, logic]
operators = defaultdict(list)
for lgl in logic:
    for keys, values in lgl.items():
        for values2 in values:
            for keys2, values3 in values2.items():
                for I,values4 in enumerate(values3):
                    V = []
                    K = []
                    for keys3, values5 in values4.items():
                        V.append(keys3)
                        if I % len(values3):
                            K.append(values5)
                        else:
                            K.append(values5)
                        #operators[keys3].append(K)
                    print(V,K)
                    for kys, vls in zip_longest(V, K):
                        if vls is not None:
                            operators[kys].append(vls)
print(operators)

当前输出 #

defaultdict(<class 'list'>, {'operator': ['equals', 'is_true', 'equals', 'is_true', 'equals', 'is_true', 'equals', 'is_true'], 'operand1': ['metrics.6266', 'flags.6372', 'metrics.6266', 'flags.15112', 'metrics.6266', 'flags.6372', 'metrics.6266', 'flags.15112'], 'operand2': [1, 0, 1, 0, 1, 0, 1, 0]})

期望输出 #

defaultdict(<class 'list'>, {'operator': [[['equals', 'is_true', 'equals', 'is_true'], ['equals', 'is_true', 'equals', 'is_true']]], 'operand1': [[['metrics.6266', 'flags.6372', 'metrics.6266', 'flags.15112'], ['metrics.6266', 'flags.6372', 'metrics.6266', 'flags.15112']]], 'operand2': [[[1, 0, 1, 0], [1, 0, 1, 0]]]})

原代码的核心问题是直接将单个值追加到字典列表中，未按层级构建嵌套结构。需要按照外层列表（长度1）→ 中层列表（对应logic中的每个元素）→ 内层列表（对应每个元素的所有值）的层级逻辑重构代码。

修正后代码 #

import json
from collections import defaultdict

# 初始化数据
logic_str = '{"$or":[{"$and":[{"baseOperator":null,"operator":"equals","operand1":"metrics.6266","operand2":1},{"baseOperator":null,"operator":"is_true","operand1":"flags.6372","operand2":0}]},{"$and":[{"baseOperator":null,"operator":"equals","operand1":"metrics.6266","operand2":1},{"baseOperator":null,"operator":"is_true","operand1":"flags.15112","operand2":0}]}]}'
logic = json.loads(logic_str)
logic = [logic, logic]

# 初始化默认字典，直接生成三层嵌套的初始结构
operators = defaultdict(lambda: [[[]]])

for idx, lgl in enumerate(logic):
    # 临时收集当前logic元素下的所有目标字段值
    current_group = defaultdict(list)
    # 遍历嵌套结构，提取所需字段
    for or_items in lgl.values():
        for and_item in or_items:
            for conditions in and_item.values():
                for cond in conditions:
                    for key in ['operator', 'operand1', 'operand2']:
                        current_group[key].append(cond[key])
    # 将当前元素的收集结果注入对应字段的中层列表
    for key in current_group:
        operators[key][0][idx] = current_group[key]

print(operators)

代码说明 #

1. 初始结构构建：通过defaultdict(lambda: [[[]]])直接创建符合要求的三层嵌套初始结构，无需后续手动拼接层级。
2. 分层收集数据：对logic中的每个元素单独收集目标字段值，形成独立的内层列表。
3. 层级注入：将每个元素的收集结果放入对应字段的中层列表位置，最终形成[[[元素1值列表], [元素2值列表]]]的嵌套结构。

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