Question

我有一个嵌套列表，形式为

 A = [[a,b],[c,d]] or [[[a,b],[c,d]]] or [[[[a,b],[c,d]]]] or [[[[[a,b],[c,d]]]]]

，依此类推。 A的这些形式不会同时出现。

无论嵌套的A多么多，我如何编写代码以剥离列表并只能获取：

[a,b] 
[c,d]

我尝试过：

def Peel_list(Features):
    try:
        for lon,lat in Features:
            print((lon,lat))
    except:
        for Feature in Features:
            for t_list in Feature:
                for A in t_list:
                    for lon,lat in A:
                        print((lon,lat))
    return()

但是它仅适用于有限的A。

Answer 1

通常，当我们要处理任意嵌套对象的问题时，递归是一个不错的起点。在这里，我们希望继续“挖掘”，直到遇到基本情况（在本例中为任何非列表值）。代码看起来像这样

test = [1, [3,4],[[5]], [[[6]]]]
peeled = []

def peel(myList, peeled):
    for val in myList:
        if isinstance(val, list):
            if not isinstance(val[0], list):
                peeled.append(val)
            else:
                peel(val, peeled)
        else:
            peeled.append(val)


peel(test, peeled)
print(peeled)

这将为您提供

[1，[3，4]，[5]，[6]]

Answer 2

对于您提供的情况，一种简单的方法是使用while循环，该循环不断检查列表的大小是否为1，并将列表修改为仅包含单个元素（这将消除最外面的列表）。

GetAverage

当元素嵌套在任意数量的列表中时，通常的方法是Mitchel的答案。

Answer 3

您还可以尝试使用列表中的numpy ravel函数，输出将是一维数组。

Answer 4

这是另一个基于递归的解决方案：

l1 = [[[['a','b'],['c','d'], [[1,2]]]]]
l2 = [[[[['a','b'],['c','d']]]]]

def f(inp):
    # you can skip this if statement if you are sure that there is no empty nested list 
    if not inp:
        return [[]]
    if (all(isinstance(element, list) for element in inp)):
        return [elem for x in inp for elem in f(x)]
    else:
        return [inp]

使用all()，可以检查迭代器的每个元素的条件。结果将是：

f(l1) #[['a', 'b'], ['c', 'd'], [1, 2]]
f(l2) #[['a', 'b'], ['c', 'd'], []]

Answer 5

您可以将递归与生成器一起使用：

def flatten(d):
   if all(not isinstance(i, list) for i in d):
      yield d
   else:
      for i in d:
         yield from flatten(i)

print(list(flatten([[[[['a', 'b'], ['c', 'd']]]]])))

输出：

[['a', 'b'], ['c', 'd']]

遍历嵌套列表的列表

5 个答案: