字典递归遍历缩进格式化问题求助：两处逻辑缺陷待解决

问题描述 #

我编写了一段Python代码，用于遍历字典并生成按嵌套层级缩进的文本，目前存在两个问题：

1. 针对raw_list的初始判断逻辑较为牵强，暂无更优实现思路；
2. level变量无法正确反映当前嵌套层级。

原代码 #

a = {
    "raw_list" : [1,2,3],
    "a" : 1,
    "b" : 2,
    "mydict": {
        "c":3,
        "d":4
    },
    "mydict2": {
        "c":5,
        "d":6
    },
    "list1": [
        {
            "e1":7, 
            "e2":8
        },
        {
            "e3":9, 
            "e4":10
        }
    ],
    "list2": [
        {
            "f1":11, 
            "f2":12
        }
    ]
}

def process_data(data,level):

    if not isinstance(data,list) and not isinstance(data,dict) :
        print("\t"*level + str(data))
        return

    for element, val in data.items():
        if isinstance(val, dict):
            print("\t"*level + "DICT:" + element)
            level+=1
            process_data(val,level)
        elif isinstance(val, list):
            print("\t"*level + "LIST:" + element)
            level += 1
            for i, item in enumerate(val):
                process_data(item,level)
        else:
            print("\t"*level+element + ":" + str(val))

    level-=1

process_data(a,1)

当前输出（存在层级错误） #

LIST:raw_list
    1
    2
    3
    a:1
    b:2
    DICT:mydict
        c:3
        d:4
        DICT:mydict2
            c:5
            d:6
            LIST:list1
                e1:7
                e2:8
                e3:9
                e4:10
                LIST:list2
                    f1:11
                    f2:12

期望输出 #

LIST:raw_list
    1
    2
    3
a:1
b:2
DICT:mydict
    c:3
    d:4
DICT:mydict2
    c:5
    d:6
LIST:list1
    e1:7
    e2:8
    e3:9
    e4:10
LIST:list2
    f1:11
    f2:12

问题分析与修复方案 #

1. level变量错误原因：原代码在循环中直接修改level变量，导致同一层级的后续元素被错误累加层级。Python整数是不可变类型，递归时应传入level + 1而非修改原变量，避免污染当前层级的level值。
2. 列表遍历逻辑错误：原代码未处理列表类型的遍历，当传入列表时调用data.items()会触发AttributeError，需单独处理列表的遍历逻辑。
3. raw_list特殊判断问题：无需针对raw_list做特殊处理，统一容器类型（字典/列表）的嵌套逻辑即可。

修复后代码 #

a = {
    "raw_list" : [1,2,3],
    "a" : 1,
    "b" : 2,
    "mydict": {
        "c":3,
        "d":4
    },
    "mydict2": {
        "c":5,
        "d":6
    },
    "list1": [
        {
            "e1":7, 
            "e2":8
        },
        {
            "e3":9, 
            "e4":10
        }
    ],
    "list2": [
        {
            "f1":11, 
            "f2":12
        }
    ]
}

def process_data(data, level):
    # 处理非容器类型（数字、字符串等）
    if not isinstance(data, (list, dict)):
        print("\t" * level + str(data))
        return

    # 处理字典类型：遍历键值对
    if isinstance(data, dict):
        for key, val in data.items():
            if isinstance(val, dict):
                print("\t" * level + f"DICT:{key}")
                process_data(val, level + 1)
            elif isinstance(val, list):
                print("\t" * level + f"LIST:{key}")
                process_data(val, level + 1)
            else:
                print("\t" * level + f"{key}:{str(val)}")
    # 处理列表类型：遍历每个元素
    elif isinstance(data, list):
        for item in data:
            process_data(item, level)

# 初始层级传入0即可得到期望输出
process_data(a, 0)

修复后输出 #

LIST:raw_list
    1
    2
    3
a:1
b:2
DICT:mydict
    c:3
    d:4
DICT:mydict2
    c:5
    d:6
LIST:list1
    e1:7
    e2:8
    e3:9
    e4:10
LIST:list2
    f1:11
    f2:12

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