如何更高效地获取Python多层嵌套列表中字符串的最大长度？

给定多层嵌套列表：

big_list = [[['asdf','ad'],['aqwe','rt']],['lkjyui','op'],['dfgh','hjk']]

目标是找出整个big_list中字符串的最大长度。

本人的实现方法 #

big_list = [[['asdf','ad'],['aqwe','rt']],['lkjyui','op'],['dfgh','hjk']]

listdf= pd.concat(pd.DataFrame(item).T for item in big_list ).reset_index(drop=True)
# 生成的DataFrame如下：
#        0     1
# 0    asdf  aqwe
# 1      ad      
# 2  lkjyui    op
# 3    dfgh   hjk

print(listdf.astype(str).applymap(lambda x: len(x)).max().max())
# 输出：6

更优的实现方式 #

你的方法依赖pandas库，属于“大材小用”——毕竟只是处理嵌套列表找字符串长度，用纯Python标准库就能更高效、轻量化地完成，以下是几种更优方案：

方案1：递归遍历扁平化列表 #

通过递归把所有嵌套的字符串提取出来，再计算最大长度：

big_list = [[['asdf','ad'],['aqwe','rt']],['lkjyui','op'],['dfgh','hjk']]

def flatten(nested_list):
    for element in nested_list:
        if isinstance(element, list):
            yield from flatten(element)
        else:
            yield element

max_len = max(len(s) for s in flatten(big_list))
print(max_len)  # 输出：6

方案2：迭代式扁平化（避免递归深度限制） #

如果嵌套层级极深，递归可能触发栈溢出，用迭代的方式更稳妥：

big_list = [[['asdf','ad'],['aqwe','rt']],['lkjyui','op'],['dfgh','hjk']]

stack = list(big_list)
max_len = 0

while stack:
    item = stack.pop()
    if isinstance(item, list):
        stack.extend(item)
    else:
        current_len = len(item)
        if current_len > max_len:
            max_len = current_len

print(max_len)  # 输出：6

方案3：结合itertools.chain的简洁写法 #

用itertools.chain配合生成器，代码更紧凑：

import itertools

big_list = [[['asdf','ad'],['aqwe','rt']],['lkjyui','op'],['dfgh','hjk']]

def flatten(nested_list):
    return itertools.chain.from_iterable(
        flatten(elem) if isinstance(elem, list) else [elem] for elem in nested_list
    )

max_len = max(len(s) for s in flatten(big_list))
print(max_len)  # 输出：6

这些方案无需额外安装库，运行时开销远小于DataFrame转换的方式，更适合这类简单的嵌套数据处理场景。

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