替代嵌套for循环实现嵌套数据结构扁平化的Pythonic方案

针对多层嵌套字典（包含列表形式的字典集合）的扁平化需求，我们可以用生成器+递归/迭代的方式实现，既符合Pythonic风格，又能在大数据量场景下保证内存效率和性能，避免嵌套for循环的繁琐与性能瓶颈。

核心思路 #

通过遍历所有层级，记录当前路径，当遇到最内层的平字典（值均为非嵌套类型）时，将路径与字典的键值对交替拼接成一行结果；遇到列表时，逐个处理列表内的元素，保持当前路径不变。生成器的惰性求值特性，避免一次性加载所有结果到内存，大幅降低内存占用。

实现方案 #

1. 递归生成器实现（简洁易读）

def is_flat_dict(d):
    """判断是否为平字典（值均非dict/list类型）"""
    return isinstance(d, dict) and not any(isinstance(v, (dict, list)) for v in d.values())

def flatten_data_recursive(data, path=()):
    if isinstance(data, list):
        for item in data:
            yield from flatten_data_recursive(item, path)
    elif isinstance(data, dict):
        if is_flat_dict(data):
            flat_items = []
            for k, v in data.items():
                flat_items.extend([k, v])
            yield list(path) + flat_items
        else:
            for k, v in data.items():
                yield from flatten_data_recursive(v, path + (k,))
    else:
        # 处理单个键对应非嵌套值的场景，如{'L1': {'L2': 5}}
        yield list(path) + [data]

2. 迭代式实现（避免递归深度限制，性能更优）

如果嵌套层级极深（超过Python默认递归深度1000），可以用栈模拟递归过程：

def is_flat_dict(d):
    return isinstance(d, dict) and not any(isinstance(v, (dict, list)) for v in d.values())

def flatten_data_iterative(data):
    stack = [(data, ())]
    while stack:
        current, path = stack.pop()
        if isinstance(current, list):
            # 逆序入栈保证遍历顺序与原列表一致
            for item in reversed(current):
                stack.append((item, path))
        elif isinstance(current, dict):
            if is_flat_dict(current):
                flat_items = []
                for k, v in current.items():
                    flat_items.extend([k, v])
                yield list(path) + flat_items
            else:
                # 逆序入栈保证键的遍历顺序与原字典一致（Python 3.7+字典有序）
                for k, v in reversed(current.items()):
                    stack.append((v, path + (k,)))
        else:
            yield list(path) + [data]

使用示例 #

# 测试数据
sample_data = {
    'L1': {
        'L2': {
            'L3': [{'a': 1, 'b': 2}, {'c': 1, 'd': 2}]
        }
    }
}

# 输出逗号分隔的结果行
for line in flatten_data_iterative(sample_data):
    print(','.join(map(str, line)))

输出结果：

L1,L2,L3,a,1,b,2
L1,L2,L3,c,1,d,2

优势说明 #

• 内存高效：生成器惰性返回结果，无需一次性存储所有扁平化数据，适合处理大规模数据集。
• 通用性强：支持任意深度的嵌套结构，无需提前固定层级数量。
• 代码简洁：相比多层嵌套for循环，递归/迭代写法更易读、易维护，符合Pythonic风格。

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