如何在嵌套列表 Python 中连接两个列表？ [复制]答案

【问题标题】：How do I concatenate two lists inside nested list Python? [duplicate]如何在嵌套列表 Python 中连接两个列表？ [复制]
【发布时间】：2020-06-04 21:20:18
【问题描述】：

如何在嵌套列表 Python 中连接两个列表？

我有这份清单

lists_of_lists =[[[1],[2]],[[3],[5]],[[6],[6]]]

而我的预期输出是

lists_of_lists =[[1,2],[3,5],[6,6]]

我试过这个方法

new = []
lists_of_lists =[[[1],[2]],[[3],[5]],[[6],[6]]]
for i in range(len(lists_of_lists)):
    for list in  lists_of_lists[i]:
        for element in list:
            new.append(element)
print(new)

但我得到了

[1, 2, 3, 5, 6, 6]

感谢您的任何建议

【问题讨论】：

相关：How to make a flat list out of list of lists?
欢迎来到 Stack Overflow！查看tour

标签： python nested-lists

【解决方案1】：

您可以使用 operator.concat() 将 2 个单独的列表组合为一个，并使用 itertools.starmap() 迭代主列表并解压缩内部列表：

from operator import concat
from itertools import starmap

result = list(starmap(concat, lists_of_lists))

您也可以使用内置的map() 函数和lambda 表达式在不导入的情况下做到这一点~~（但为什么？）~~：

result = list(map(lambda x: x[0] + x[1], lists_of_lists))

你也可以使用chain.from_iterable():

from itertools import chain

result = list(map(list, map(chain.from_iterable, lists_of_lists)))

但是，如果您想修补您编写的代码以按预期工作：

lists_of_lists =[[[1],[2]],[[3],[5]],[[6],[6]]]
new = []
for sub_list in lists_of_lists:
    new_item = []
    for item in sub_list:
        for element in item:
           new_item.append(element)
    new.append(new_item)

【讨论】：

比所有建议的解决方案快 2 倍。 +1。

【解决方案2】：

[[i for inner in sub_lists for i in inner] for sub_lists in lists_of_lists]

# [[1, 2], [3, 5], [6, 6]]

【讨论】：

这个技术解释here

【解决方案3】：

你可以试试这个。

[sum(i,[]) for i in lists_of_lists]

[[1, 2], [3, 5], [6, 6]]

对建议的解决方案（python 3.7 和 windows 10）的一些timeit 分析

基准测试列表 =[[[1],[2]],[[3],[5]],[[6],[6]]]

In [48]: timeit [sum(i,[]) for i in lists_of_lists]
914 ns ± 103 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [49]: timeit [[i for inner in sub_lists for i in inner] for sub_lists in lists_of_lists]
1.25 µs ± 136 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [64]: timeit list(starmap(concat, lists_of_lists))
639 ns ± 30 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [70]: timeit list(map(list, map(chain.from_iterable, lists_of_lists)))
1.55 µs ± 57 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

基准测试列表 = l=[[[1],[2]],[[3],[5]],[[6],[6]]]*1000000（300 万）。

In [60]: timeit [sum(i,[]) for i in l]
1.06 s ± 68 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [61]: timeit [[i for i in j] for j in l]
1.13 s ± 64.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [65]: timeit list(starmap(concat, l))
595 ms ± 15.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [71]: timeit list(map(list, map(chain.from_iterable, l)))
1.39 s ± 101 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

【讨论】：

这个技术解释here
您能添加我在您的测试中提供的选项吗？
@OlvinRoght 实际上我现在正在运行您的代码；) 将在几分钟内添加它。
@Ch3steR，谢谢，因为我现在没有机会 :)
@Ch3steR，实际上这就是我所期望的，因为 itertools 尽可能地是原生的。

【解决方案4】：

试试numpy:

在：

import numpy as np
lists_of_lists =np.array([[[1],[2]],[[3],[5]],[[6],[6]]])
lists_of_lists.reshape(lists_of_lists.size//2, 2)

输出：

array([[1, 2],
       [3, 5],
       [6, 6]])

【讨论】：

【解决方案5】：

result = []
for subList in lists_of_lists:
    newList = []
    for subSubList in subList:
        newList.extend(subSubList)
    result.append(newList)

而result 包含想要的内容。

【讨论】：

【解决方案6】：

我希望这是可读的

lists_of_lists =[[[1],[2]],[[3],[5]],[[6],[6]]]

def concat_inner(arr):
    return arr[0]+ arr[1]

final_list = list(map(concat_inner, lists_of_lists))

print(final_list)

【讨论】：

【解决方案7】：

您将完全进入低级。只需减少一层深度并将列表展平即可。

lists_of_lists =[[[1],[2]],[[3],[5]],[[6],[6]]]
for i in lists_of_lists:
    flat_list = [item for sublist in i for item in sublist]
    new.append(flat_list)
print(new)

【讨论】：