Python3中嵌套列表扁平化实现方法咨询（非硬编码）

嘿，这个问题我之前处理嵌套数据的时候经常遇到，给你几个通用的解法，完全不用硬编码，不管嵌套多少层都能搞定：

方法一：递归实现（最直观） #

递归应该是最容易想到的方式，核心逻辑就是遍历每个元素，判断是否为列表，如果是就递归处理子列表，否则直接加入结果：

def flatten(nested_list):
    result = []
    for item in nested_list:
        # 动态判断元素是否为列表，无需硬编码层级
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

# 测试示例
A = [1,2,3,[4,5,[6,7,8]]]
print(flatten(A))  # 输出: [1,2,3,4,5,6,7,8]

这个方法的优势是代码简洁易懂，不管嵌套多少层，都会自动递归处理所有子列表，完全不需要提前知道嵌套深度。

方法二：迭代法（规避递归深度限制） #

如果你的嵌套列表特别深（比如超过Python默认的递归深度限制），递归就会报错，这时候用迭代+栈的方式更稳妥：

def flatten_iterative(nested_list):
    stack = [nested_list]
    result = []
    while stack:
        current = stack.pop()
        # 反向遍历保证元素顺序和原列表一致
        for item in reversed(current):
            if isinstance(item, list):
                stack.append(item)
            else:
                result.append(item)
    return result

# 测试示例
A = [1,2,3,[4,5,[6,7,8]]]
print(flatten_iterative(A))  # 输出: [1,2,3,4,5,6,7,8]

这里用栈来模拟递归的调用栈，每次弹出待处理的列表，逐个处理元素，同样是动态判断是否为子列表，没有硬编码任何层级信息。

方法三：生成器实现（内存友好） #

如果要处理非常大的嵌套列表，不想一次性把所有元素都加载到内存里，用生成器是最优选择：

def flatten_generator(nested_list):
    for item in nested_list:
        if isinstance(item, list):
            # 用yield from递归生成子列表的元素
            yield from flatten_generator(item)
        else:
            yield item

# 测试示例
A = [1,2,3,[4,5,[6,7,8]]]
flat_list = list(flatten_generator(A))
print(flat_list)  # 输出: [1,2,3,4,5,6,7,8]

生成器会逐个返回扁平化后的元素，内存占用极低，而且代码同样简洁，完全不需要硬编码嵌套层级。

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