A有一个真正的问题（并且头疼）并且有一个任务......
我在一个入门编程课程中，我必须编写一个函数，给定一个列表，它将返回它所达到的“最大”深度... 例如：[1,2,3]将返回1，[1，[2,3]]将返回2 ...
我写了这段代码（这是我能得到的最好的T_T）
def flat(l):
count=0
for item in l:
if isinstance(item,list):
count+= flat(item)
return count+1
然而，它显然不会像它应该的那样工作，因为如果有列表不计入最大深度，它仍然会提高计数器......
例如：当我使用[1,2，[3,4]，5，[6]，7]的函数时，它应返回2，但它返回3 ......
任何想法或帮助将非常感谢^^非常感谢!!几个星期以来，我一直在为此苦苦挣扎......
答案 0 :(得分：25)
这是编写函数的一种方法
depth = lambda L: isinstance(L, list) and max(map(depth, L))+1
我认为您缺少的想法是使用max()
答案 1 :(得分：10)
让我们先稍微改一下你的要求。
列表的深度比其子列表的最大深度多一个。
现在，这可以直接翻译成代码：
def depth(l):
if isinstance(l, list):
return 1 + max(depth(item) for item in l)
else:
return 0
答案 2 :(得分：5)
使用递归很容易
def flat(l):
depths = []
for item in l:
if isinstance(item, list):
depths.append(flat(item))
if len(depths) > 0:
return 1 + max(depths)
return 1
答案 3 :(得分：5)
广度优先，没有递归，它也适用于其他序列类型：
from collections import Sequence
from itertools import chain, count
def depth(seq):
for level in count():
if not seq:
return level
seq = list(chain.from_iterable(s for s in seq if isinstance(s, Sequence)))
同样的想法，但内存消耗更少：
from collections import Sequence
from itertools import chain, count
def depth(seq):
seq = iter(seq)
try:
for level in count():
seq = chain([next(seq)], seq)
seq = chain.from_iterable(s for s in seq if isinstance(s, Sequence))
except StopIteration:
return level
答案 4 :(得分：2)
在python的一行中完成了：）
享受
def f(g,count=0): return count if not isinstance(g,list) else max([f(x,count+1) for x in g])
答案 5 :(得分：1)
滥用方式：
说你的名单叫mylist
mybrackets = map(lambda x: 1 if x=='[' else -1, [x for x in str(mylist) if x=='[' or x==']'])
maxdepth = max([sum(mybrackets[:i+1]) for i in range(len(mybrackets))])
这会将您的列表转换为开始和结束括号的列表，然后找到在相应的右括号出现之前出现的最大数量的左括号。
答案 6 :(得分：1)
一种不需要任何额外模块且具有相同速度的方式，无论深度如何：
def depth(nested):
instring = False
count = 0
depthlist = []
for char in repr(nested):
if char == '"' or char == "'":
instring = not instring
elif not instring and ( char == "[" or char == ")" ):
count += 1
elif not instring and ( char == "]" or char == ")" ):
count -= 1
depthlist.append(count)
return(max(depthlist))
基本上，这样做是使用repr()将列表转换为字符串。然后，对于此字符串中的每个字符等于“(”或“[”，它会增加变量count。对于右括号，它减少count。然后它返回count已达到的最大值。
答案 7 :(得分：1)
我为每个iterable扩展了hammar's answer（默认情况下禁用了字符串）：
def depth(arg, exclude=None):
if exclude is None:
exclude = (str, )
if isinstance(arg, tuple(exclude)):
return 0
try:
if next(iter(arg)) is arg: # avoid infinite loops
return 1
except TypeError:
return 0
try:
depths_in = map(lambda x: depth(x, exclude), arg.values())
except AttributeError:
try:
depths_in = map(lambda x: depth(x, exclude), arg)
except TypeError:
return 0
try:
depth_in = max(depths_in)
except ValueError:
depth_in = 0
return 1 + depth_in
答案 8 :(得分：1)
如果您正在寻找快速修复
def getDepth(matrix):
try:
len(matrix)
return getDepth(matrix[0]) + 1
except:
return 0
答案 9 :(得分：0)
对所说内容的简短补充，因此它也可以处理空列表：
def list_depth(list_of_lists):
if isinstance(list_of_lists, list):
if(len(list_of_lists) == 0):
depth = 1
else:
depth = 1 + max([list_depth(l) for l in list_of_lists])
else:
depth = 0
return depth
答案 10 :(得分：0)
@ John的解决方案很棒，但要解决空列表案例，例如[]，[[]]，您可能需要做类似的事情
depth = lambda L: isinstance(L, list) and (max(map(depth, L)) + 1) if L else 1
答案 11 :(得分：0)
在 Numpy 中，您可以将数据结构转换为numpy array并使用其库函数。 arr.shape给出每层的长度，因此我们可以len()的形状并获取结构的深度：
import numpy as np
def f( lists )
arr = np.array( lists )
return len(arr.shape)
f( [[[1,2],[3,4]],[[3,4],[5,6]]] ) # results in 3
f( [[1,2],[3,4]] ) # results in 2
f( [1,2] ) # results in 1
f( [] ) # results in 1
答案 12 :(得分：0)
您还可以仅使用python来递归地完成此操作：
def depth(L,d):
max = d
for i in range(len(L)):
if type(L[i])==list :
a = depth(L[i],d+1)
if a>max :
max = a
return(max)
此函数是递归的，它的作用是到达列表的最大深度，计算列表的深度，当列表向上爬升时，仅保留所有嵌套列表中最大的深度。 / p>