如何将Python嵌套字典展示为树形结构？现有方案失效求更佳方法

针对你的嵌套字典结构，这里提供几个实用的实现方案，解决你之前用networkx和树状图失效的问题：

1. 纯文本树形打印（无需额外依赖） #

直接通过递归遍历字典，生成文本格式的树形结构，适合快速查看：

def print_tree(data, indent=0, prefix=""):
    if isinstance(data, dict):
        for i, (key, value) in enumerate(data.items()):
            is_last = i == len(data) - 1
            # 打印当前节点
            print(f"{'    ' * indent}{prefix}{'└── ' if is_last else '├── '}{key}")
            # 为子节点设置前缀，保证树形对齐
            new_prefix = "│   " if not is_last else "    "
            print_tree(value, indent + 1, new_prefix)
    else:
        # 处理叶子节点（非字典类型）
        print(f"{'    ' * indent}{prefix}└── {data}")

# 你的原始数据
data = {"L1" : 
            {"sub L1" : 
                "sub sub L1"}, 
        "L2" :
            "sub L2", 
        "L3" :
            {"sub L3" :
                {"sub sub L3" :
                    "sub sub sub L3"}}}

print_tree(data)

运行后输出：

├── L1
│   └── sub L1
│       └── sub sub L1
├── L2
│   └── sub L2
└── L3
    └── sub L3
        └── sub sub L3
            └── sub sub sub L3

2. 使用treelib库生成结构化树 #

treelib是专门用于树形结构处理的第三方库，支持更丰富的树形操作和输出：

首先安装库：

pip install treelib

然后编写代码：

from treelib import Tree

def dict_to_tree(data, tree, parent_node=None, node_id=0):
    if isinstance(data, dict):
        for key, value in data.items():
            current_id = f"node_{node_id}"
            tree.create_node(key, current_id, parent=parent_node)
            node_id += 1
            # 递归处理子节点
            node_id = dict_to_tree(value, tree, current_id, node_id)
    else:
        # 叶子节点直接创建
        current_id = f"node_{node_id}"
        tree.create_node(data, current_id, parent=parent_node)
        node_id += 1
    return node_id

data = {"L1" : 
            {"sub L1" : 
                "sub sub L1"}, 
        "L2" :
            "sub L2", 
        "L3" :
            {"sub L3" :
                {"sub sub L3" :
                    "sub sub sub L3"}}}

# 初始化树并创建根节点
tree = Tree()
tree.create_node("Root", "root")
dict_to_tree(data, tree, "root")

# 打印树形结构
tree.show()

输出效果更规整，还支持将树保存为JSON、图片等格式，适合需要结构化处理的场景。

3. 用matplotlib绘制可视化树形图 #

如果需要图形化的树形展示，可以手动将嵌套字典转换为父子边列表，再用matplotlib绘制：

import matplotlib.pyplot as plt
from matplotlib.pylab import rcParams

# 设置画布大小
rcParams['figure.figsize'] = 12, 8

def build_edges(data, parent="Root", edges=None):
    if edges is None:
        edges = []
    if isinstance(data, dict):
        for key, value in data.items():
            edges.append((parent, key))
            # 递归生成子节点的边
            build_edges(value, key, edges)
    else:
        edges.append((parent, data))
    return edges

def draw_tree(edges):
    # 构建节点的坐标位置（层级布局）
    node_pos = {}
    level = 0
    current_level_nodes = ["Root"]
    node_pos["Root"] = (0, 0)
    
    while current_level_nodes:
        next_level_nodes = []
        x_offset = -len(current_level_nodes)/2 + 0.5
        for node in current_level_nodes:
            node_pos[node] = (x_offset, -level)
            # 获取当前节点的所有子节点
            children = [child for parent, child in edges if parent == node]
            next_level_nodes.extend(children)
            x_offset += 1
        level += 1
        current_level_nodes = next_level_nodes
    
    # 绘制节点间的边
    for parent, child in edges:
        plt.plot([node_pos[parent][0], node_pos[child][0]], 
                 [node_pos[parent][1], node_pos[child][1]], 
                 'k-')
    # 绘制节点和标签
    for node, (x, y) in node_pos.items():
        plt.scatter(x, y, s=1000, c='white', edgecolors='black')
        plt.text(x, y, node, ha='center', va='center', fontsize=10)
    
    plt.axis('off')
    plt.show()

data = {"L1" : 
            {"sub L1" : 
                "sub sub L1"}, 
        "L2" :
            "sub L2", 
        "L3" :
            {"sub L3" :
                {"sub sub L3" :
                    "sub sub sub L3"}}}

# 生成边列表
edges = build_edges(data)
# 绘制树形图
draw_tree(edges)

这个方法会生成直观的可视化树形图，避免了networkx处理嵌套字典时的结构适配问题，直接通过边列表构建图形。

内容的提问来源于stack exchange，提问作者Kruti Deepan Panda