如何扁平化包含不同嵌套层级的嵌套列表？

针对你提出的嵌套列表扁平化需求，这里提供几种实用的实现方式：

递归实现 #

递归是最直观的方式，遍历列表中的每个元素，如果是嵌套列表就递归处理，否则直接添加到结果中：

def flatten(nested_list):
    result = []
    for item in nested_list:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

# 测试示例
original = [1, [1, 2], [1, [2, 3]], [1, [2, [3, 4]]]]
print(flatten(original))  # 输出: [1, 1, 2, 1, 2, 3, 1, 2, 3, 4]

迭代实现（栈/队列方式） #

如果嵌套层级很深，递归可能触发栈溢出，这时可以用迭代的方式，借助栈或队列来处理：

基于栈的实现 #

def flatten_iterative(nested_list):
    result = []
    stack = list(nested_list)
    
    while stack:
        item = stack.pop()
        if isinstance(item, list):
            # 反转后入栈，保证弹出顺序和原列表一致
            stack.extend(reversed(item))
        else:
            result.append(item)
    
    # 栈是后进先出，最后反转结果恢复顺序
    return result[::-1]

# 测试示例
original = [1, [1, 2], [1, [2, 3]], [1, [2, [3, 4]]]]
print(flatten_iterative(original))

基于队列的实现 #

from collections import deque

def flatten_iterative(nested_list):
    result = []
    queue = deque(nested_list)
    
    while queue:
        item = queue.popleft()
        if isinstance(item, list):
            # 反转后从左侧入队，保证取出顺序和原列表一致
            queue.extendleft(reversed(item))
        else:
            result.append(item)
    
    return result

# 测试示例
original = [1, [1, 2], [1, [2, 3]], [1, [2, [3, 4]]]]
print(flatten_iterative(original))

基于while循环的实现（符合你的思路） #

你提到想用while循环检查是否存在嵌套列表，这种方式可以逐层展开嵌套，直到列表中没有嵌套元素为止：

def flatten_while(nested_list):
    result = list(nested_list)
    
    while True:
        has_nested = False
        temp = []
        for item in result:
            if isinstance(item, list):
                temp.extend(item)
                has_nested = True
            else:
                temp.append(item)
        result = temp
        # 没有嵌套元素时退出循环
        if not has_nested:
            break
    
    return result

# 测试示例
original = [1, [1, 2], [1, [2, 3]], [1, [2, [3, 4]]]]
print(flatten_while(original))

这种方法每次遍历当前列表，将所有嵌套的列表展开一层，重复这个过程直到列表中没有任何嵌套的子列表，最终得到完全扁平化的结果。

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