Question

我有这样的数据结构（列表的实际列表非常长并且深度不同）。我事先知道他们的深度。

 a=( [1,2], [2,3,[4,5]] )
 b=( [[1,2],[2,3]] )

想要遍历每个列表。如何最好地做到这一点？

我不想最终做这样的事情：

for l in a:
    if instance(l, list):
        for ll in l:
            if instance(ll, list): 
                ...

Answer 1

由于你没有定义目的，我正在编写一个对所有元素求和的函数：

def rec_sum(lst):
    if not lst:
        return 0
    el = lst.pop()
    if isinstance(el, list):
        return rec_sum(el) + rec_sum(lst)
    else:
        return el + rec_sum(lst)

即使您事先知道深度，使用递归也更容易解决。

请记住，Python限制堆叠1000个堆栈帧。因此，如果您的列表包含超过1000个项目，则应该获得例外。

如果您认为可以有超过1000个项目，那么这是一个混合解决方案，它使用递归和循环。它被限制在1000个级别，而不是1000个项目：

def rec_for_sum(lst):
    if not lst:
        return 0
    count = 0
    for el in lst:
        if not isinstance(el, list):
            count += el
        else:
            count += rec_for_sum(el)
    return count

Answer 2

您可以检查某个对象是否为列表，然后再进行更深入的处理：

另见How to check if an object is a list or tuple (but not string)?

def myprint(list):
    for i in list:
        if isinstance(i, list):
            myprint(i)
        else:
            print i

Answer 3

您可以使用递归和生成器的组合：

def flatten_list(list_in):
    if isinstance(list_in,list):
        for l in list_in:
                for y in flatten_list(l):
                        yield y
    else:
        yield list_in


my_compound_list = [[1,2,3],[4,5,6],[7,8,9,[10,11,12,[13,14,15]]]]

print [f for f in flatten_list(my_compound_list)]

Answer 4

迭代解决方案的简单形式（基础不完整）：

   for item in your_list:
        if isinstance(item,list):
           ...........
        else:
        ...................

这是你应该去的方式。这应该足以让你入门。

回归解决方案：

def list_flatten(my_list):
    for item in my_list:
        if(isinstance(item,list)):
            list_flatten(item)
        else:
            print(item)

这是针对您的问题的递归解决方案。但要注意内存问题和递归深度。

Python：如何循环不同深度的列表列表？

4 个答案: