三重嵌套列表Python

我有一段代码，它给了我一个列表，其中包含一些三重嵌套列表：

my_list = [[['item1','item2']], [['item3', 'item4']]]

我想说：

my_list = [['item1','item2'], ['item3', 'item4']]

有什么建议吗？

请执行以下操作：

my_list = [j for i in my_list for j in i ]

---

如果你想快速解决问题，就这么简单-

for i in range(len(my_list)):
    my_list[i]=my_list[i][0]

my_list=list（映射（lambda x:x[0]，my_list））

带有

列表理解的一行代码

my_list = [sub[0] for sub in my_list]

您还可以将

my_列表

更改到位：

my_list = [[['item1','item2']],[['item3', 'item4']]]

for i, sub in enumerate(my_list):
    my_list[i] = sub[0]

>>> my_list
[['item1', 'item2'], ['item3', 'item4']]
>>> 

---

使用列表从每个子列表中选择单个子列表：

>>> my_list = [item[0] for item in my_list]
[['item1', 'item2'], ['item3', 'item4']]

也可以使用

sum

来降低嵌套级别，但这是一个即将发生的性能灾难，因为它具有二次运行时：

In [5]: my_list = [[[i, i+1]] for i in range(0, 10000, 2)]

In [6]: %timeit sum(my_list, [])
78.6 ms ± 2.15 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [7]: %timeit [x[0] for x in my_list]
187 µs ± 3.05 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [8]: 78600/187
Out[8]: 420.32085561497325

---

对于5000个长度的

my_list

，这是一个420x的减速，它根本不是一个很长的列表。对于较长的列表，情况更糟。

一种简单但有效的方法是使用以下工具展平三重嵌套列表：

---

对于大小为

n

的列表，它具有

O（n）

复杂性

带有

映射

和

操作符。itemgetter

：

map(operator.itemgetter(0), my_list)

在Python 3中，返回一个生成器。如果需要

列表

请将生成器包装在

列表（…）

调用中。

python3

[[x], [y]] = my_list
print([x , y])

[['item1', 'item2'], ['item3', 'item4']]

---

一个快速修复方法，如果您有类似的嵌套列表结构，下面的递归函数（或其他情况下的类似函数）可以处理任何级别的嵌套。没有衡量性能，但与其他解决方案相比，性能会更低。使用前请仔细测试。在Python2.7中

def f(x):
    if hasattr(x[0], '__iter__'):
        return f(x[0])
    else:
        return x

>>> my_list = [[['item1','item2']], [['item3', 'item4']]]
>>> [f(elem) for elem in my_list]
[['item1', 'item2'], ['item3', 'item4']]
>>> my_list = [[[['item1','item2']]], [['item3', 'item4']],[[[['item5', 'item6']]]]]
>>> [f(elem) for elem in my_list]
[['item1', 'item2'], ['item3', 'item4'], ['item5', 'item6']]

---

hasattr（）检查将跳过python 2中的字符串。其他测试（如Itter（））可以将字符串视为可迭代的< /p> <代码> MyObList=列表（Map（lambda x:x（0），MyOLLIST））< /代码>当我在Python中编写时，有时会想念露比：[代码[>] [ITEM1'，'ITEM2'] ]，[[ ITEM3，'ITEM4′] ] .FLUTEN（1）。公平地说，这是双向的。您研究了什么，为什么其中的解决方案对您的案例不起作用？如果最外层列表中有多个项目，您希望发生什么情况？可以使用一个

for loop

：

[i[0]for i in my_list]

@srig:双重列表理解更清晰。如果

i

有多个元素，它也不会删除数据，如果

i

为空，它也不会引发错误。@EricDuminil，我也这么认为，但后来我使用了OP的输入

列表

：）我也喜欢它的外观，但你不应该只使用很少的元素：绝对，由于OP的列表元素很少，我们可以使用此解决方案。而且我还尝试发布交替解决方案无需对极小的输入执行timeits，它几乎从不表示bigO性能。如果

项

包含多个元素，则第二种方法会删除数据，如果

项

为空，则会引发错误。

求和

方法非常糟糕，因为没有好的理由它需要二次时间。没有分号当然，但是为什么要删除列呢？虽然这个代码片段可以解决这个问题，但确实有助于提高您的文章质量。请记住，您将在将来回答读者的问题，这些人可能不知道您的代码建议的原因。

[[x], [y]] = my_list
print([x , y])

[['item1', 'item2'], ['item3', 'item4']]

def f(x):
    if hasattr(x[0], '__iter__'):
        return f(x[0])
    else:
        return x

>>> my_list = [[['item1','item2']], [['item3', 'item4']]]
>>> [f(elem) for elem in my_list]
[['item1', 'item2'], ['item3', 'item4']]
>>> my_list = [[[['item1','item2']]], [['item3', 'item4']],[[[['item5', 'item6']]]]]
>>> [f(elem) for elem in my_list]
[['item1', 'item2'], ['item3', 'item4'], ['item5', 'item6']]