Python如何快速获取列表中最深层同级子列表的最小长度？

当然可以用更简洁的方式实现！咱们先来拆解一下需求：要找到所有最深层级的子列表里，长度最短的那个的长度。核心就是要同时跟踪每个列表的「深度」和「长度」，之后再做筛选。

方法1：递归实现（简洁直观） #

我们可以写一个递归生成器，遍历所有嵌套列表，收集每个列表的深度和长度：

def get_depth_length_pairs(lst, current_depth=1):
    # 先记录当前列表的深度和长度
    yield (current_depth, len(lst))
    # 遍历每个元素，如果是子列表就递归进去，深度+1
    for item in lst:
        if isinstance(item, list):
            yield from get_depth_length_pairs(item, current_depth + 1)

# 测试你的示例列表
b = [[1,0,1,2,1,1,1,3111111,[1,1,6,7]],[31,1,4,51,1,1,1],[1,1,6,7,8]]

# 第一步：获取所有列表的(深度, 长度)对
all_pairs = list(get_depth_length_pairs(b))

# 第二步：找到最深的层级
max_depth = max(depth for depth, length in all_pairs)

# 第三步：筛选出最深层级的所有列表，取最小长度
min_length = min(length for depth, length in all_pairs if depth == max_depth)

print(min_length)  # 输出：4

方法2：迭代实现（避免递归栈溢出） #

如果你的嵌套列表特别深（比如超过Python默认的递归深度限制），可以用栈实现迭代遍历，效果和递归完全一致，但更稳定：

def get_depth_length_pairs_iterative(lst):
    stack = [(lst, 1)]  # 栈里存(当前列表, 当前深度)
    while stack:
        current_list, depth = stack.pop()
        yield (depth, len(current_list))
        # 反向遍历子列表，保证顺序和递归一致（不影响结果的话也可以不反向）
        for item in reversed(current_list):
            if isinstance(item, list):
                stack.append((item, depth + 1))

# 同样的调用逻辑
all_pairs = list(get_depth_length_pairs_iterative(b))
max_depth = max(d for d, l in all_pairs)
min_length = min(l for d, l in all_pairs if d == max_depth)

print(min_length)  # 输出：4

为什么这两种方法更简洁？ #

相比手动嵌套循环，递归/迭代的方式可以自适应任意深度的嵌套列表，不管你的列表是2层还是10层，代码都不需要修改。而且逻辑清晰，把“遍历收集”和“筛选计算”拆分开，可读性更强。

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