基于嵌套字典检查创建新嵌套字典的Python实现问题

输入数据 #

两个字典定义如下：

dict1={'A': ['K', 'J'], 'C': ['A'], 'D': ['B', 'C']}
dict2={'D': {'D': '0.20','B': '0.20','C': '0.00','A': '0.06','K': '0.00','J': '0.02'},'A': {'A': '0.21', 'K': '0.00', 'J': '0.08'}}

需求说明 #

针对dict2第一层级的每个键（如D、A），结合dict1的关联规则，生成包含连接关系的嵌套字典：

• 若dict1中某键的关联元素在dict2中对应值非零，生成三元组(起始键, 目标元素, [])（中间节点为空）
• 若该元素值为0，则递归查找该元素在dict1中的关联列表，直到找到dict2中值非零的元素，生成三元组(起始键, 最终非零元素, [所有中间节点])
• 最终结果结构为：键对应dict2第一层级的键，值为所有符合条件的三元组集合

期望输出：

result={'D': {('D','B',[]), ('D','A',['C']), ('A','J',[])}, 'A': {('A','K',[]), ('A','J',[])}}

现有代码问题 #

用户编写的代码无法正确处理多层递归场景，且输出格式不符合预期：

keysList = list(dict1.keys())
ex_dict2={'D': {'D': '0.20', 'B': '0.20', 'C': '0.00', 'A': '0.06', 'K': '0.00', 'J': '0.02'}}
output = []
test_dict = {}
for target in ex_dict2:
    print(ex_dict2)
    for key in dict1:
        for i in dict1[key]:
            t=(key,i)
            if ex_dict2[target][key]!='0.00' and ex_dict2[target][i]!='0.00':
                output.append(t)
            else:
                if ex_dict2[target][i]=='0.00' and i in keysList :
                    print(t)
                    tt=(t,[i])
                    output.append(tt)
        test_dict[target]=output

当前输出：

{'D': [('A', 'J'), ('D', 'B'), (('D', 'C'), ['C'])]}

解决方案 #

核心思路是用递归函数追踪起始节点、当前节点和中间路径，直到找到dict2中值非零的节点，再生成符合要求的三元组。

完整代码：

dict1={'A': ['K', 'J'], 'C': ['A'], 'D': ['B', 'C']}
dict2={'D': {'D': '0.20','B': '0.20','C': '0.00','A': '0.06','K': '0.00','J': '0.02'},'A': {'A': '0.21', 'K': '0.00', 'J': '0.08'}}

def find_valid_path(start_node, current_node, intermediate, target_dict):
    # 检查当前节点在目标字典中的值是否非零
    if target_dict[current_node] != '0.00':
        return (start_node, current_node, intermediate.copy())
    # 如果当前节点在dict1中有关联，继续递归查找
    if current_node in dict1:
        for next_node in dict1[current_node]:
            intermediate.append(current_node)
            result = find_valid_path(start_node, next_node, intermediate, target_dict)
            if result:
                return result
            intermediate.pop()  # 回溯
    # 若没有找到有效节点（题目假设存在有效节点）
    return None

def build_result(dict1, dict2):
    result = {}
    for top_key in dict2:
        target_dict = dict2[top_key]
        connections = set()
        for start_node in dict1:
            # 起始节点本身值非零才处理其关联
            if target_dict[start_node] == '0.00':
                continue
            for initial_node in dict1[start_node]:
                path = find_valid_path(start_node, initial_node, [], target_dict)
                if path:
                    connections.add(path)
        result[top_key] = connections
    return result

# 生成结果
final_result = build_result(dict1, dict2)
print(final_result)

代码说明 #

1. find_valid_path：递归函数，从起始节点出发，追踪当前节点和中间路径，直到找到dict2中值非零的节点，返回三元组
2. build_result：遍历dict2的每个顶层键，对dict1中的每个起始节点，调用递归函数查找所有有效路径，将结果存入集合（避免重复）
3. 代码支持多层递归的零值场景，输出结构与预期一致

运行输出：

{'D': {('A', 'J', []), ('D', 'B', []), ('D', 'A', ['C'])}, 'A': {('A', 'K', []), ('A', 'J', [])}}

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