Python-查找；“深度”；递归循环中列表中元素的

我想知道Python中使用递归循环（不是函数）的列表中元素的深度，但它不起作用。我找到了一些关于函数的答案，但这不是重点

在下面的列表中，类似“a”的是深度2，“d”是深度3

这是我的密码：

list1 = [['x','y'], ['z','p'], ['m',['a','b','c',['d','e']]]]

level = 0

def print_list(l):
    for e in l:
        global level
        if type(e) == list:
            print_list(e)
            level +=1
        else:
           print(str(e) + ",", str(level))

print_list(list1)

结果:

x, 0
y, 0
z, 1
p, 1
m, 2
a, 2
b, 2
c, 2
d, 2
e, 2

---

有人有主意了？

一般来说，我建议不要使用全局变量，尤其是在递归中

list1=['x'、'y']、['z'、'p']、['m'、['a'、'b'、'c'、['d'、'e']]
def打印列表（li，级别）：
对于李中的e：
如果类型（e）=列表：
级别+=1
打印列表（e级）
其他：
打印（str（e）+“，”，str（级别））
打印列表（列表1，0）

输出：

x, 1
y, 1
z, 2
p, 2
m, 3
a, 4
b, 4
c, 4
d, 5
e, 5

a, 1
b, 2
c, 3
d, 4
e, 3
f, 2
g, 1

---

一般来说，我建议不要使用全局变量，尤其是在递归中

list1=['x'、'y']、['z'、'p']、['m'、['a'、'b'、'c'、['d'、'e']]
def打印列表（li，级别）：
对于李中的e：
如果类型（e）=列表：
级别+=1
打印列表（e级）
其他：
打印（str（e）+“，”，str（级别））
打印列表（列表1，0）

输出：

x, 1
y, 1
z, 2
p, 2
m, 3
a, 4
b, 4
c, 4
d, 5
e, 5

a, 1
b, 2
c, 3
d, 4
e, 3
f, 2
g, 1

---

更改这两行：

print_list(e)
level +=1

到

---

更改这两行：

print_list(e)
level +=1

到

---

对于这种任务，使用生成器非常方便。它允许您根据需要或作为列表生成值，并使逻辑非常清晰。我将深度从-1开始，因为我希望第一个嵌套元素位于深度1（级别0将是

['a'，['b'，…]中的立即嵌套值，如
a
）

：

list1 = [['x','y'], ['z','p'], ['m',['a','b','c',['d', 'e']]]]

def levels(l, depth = -1):
    if not isinstance(l, list):
        yield (l, depth)
    else:
        for sublist in l:
            yield from levels(sublist, depth + 1)

list(levels(list1))

结果：

[('x', 1),
 ('y', 1),
 ('z', 1),
 ('p', 1),
 ('m', 1),
 ('a', 2),
 ('b', 2),
 ('c', 2),
 ('d', 3),
 ('e', 3)]

---

将其制作为字典或使用各种工具来操作它同样容易。

使用生成器对于这类任务来说非常方便。它允许您根据需要或以列表的形式生成值，并使逻辑非常清晰。我将深度设置为-1，因为我希望第一个嵌套元素位于深度1（零级将是立即嵌套的值，如

['a'，['b'，…]中的
a
）

：

list1 = [['x','y'], ['z','p'], ['m',['a','b','c',['d', 'e']]]]

def levels(l, depth = -1):
    if not isinstance(l, list):
        yield (l, depth)
    else:
        for sublist in l:
            yield from levels(sublist, depth + 1)

list(levels(list1))

结果：

[('x', 1),
 ('y', 1),
 ('z', 1),
 ('p', 1),
 ('m', 1),
 ('a', 2),
 ('b', 2),
 ('c', 2),
 ('d', 3),
 ('e', 3)]

---

将其制作成字典或使用各种工具来操作它同样容易。

生成器是一种方法，因此您不必硬编码元素的使用或显示方式

以下内容还使用了一个内部定义的函数，这样用户就不会意外地传递一个额外的参数，使

级别

：

list1 = ['a',['b',['c',['d'],'e'],'f'],'g']

def enum_list(l):
    def _enum_list(l,level=1):
        for e in l:
            if isinstance(e,list):
                yield from _enum_list(e,level+1)
            else:
               yield e,level
    yield from _enum_list(l)

for item,level in enum_list(list1):
    print(f'{item}, {level}')

输出：

x, 1
y, 1
z, 2
p, 2
m, 3
a, 4
b, 4
c, 4
d, 5
e, 5

a, 1
b, 2
c, 3
d, 4
e, 3
f, 2
g, 1

---

生成器是一种方法，因此您不必硬编码元素的使用或显示方式

以下内容还使用了一个内部定义的函数，这样用户就不会意外地传递一个额外的参数，使

级别

：

list1 = ['a',['b',['c',['d'],'e'],'f'],'g']

def enum_list(l):
    def _enum_list(l,level=1):
        for e in l:
            if isinstance(e,list):
                yield from _enum_list(e,level+1)
            else:
               yield e,level
    yield from _enum_list(l)

for item,level in enum_list(list1):
    print(f'{item}, {level}')

输出：

x, 1
y, 1
z, 2
p, 2
m, 3
a, 4
b, 4
c, 4
d, 5
e, 5

a, 1
b, 2
c, 3
d, 4
e, 3
f, 2
g, 1

---

问题是，您在下降时更新级别，但在上升时从不更改级别以进行补偿。您的最佳选择是将级别作为参数传递，并在本地使用它，这样您就不会覆盖同一段数据。问题是，您在下降时更新级别，但在上升时从不更改级别以进行补偿。您的最佳选择是将级别作为pa传递ram并在本地使用，这样就不会覆盖同一段数据