如何在不同长度的列表列表中删除最内层的嵌套
Posted
技术标签:
【中文标题】如何在不同长度的列表列表中删除最内层的嵌套【英文标题】：How to remove the innermost level of nesting in a list of lists of varying lengths 【发布时间】：2017-05-07 08:54:12 【问题描述】：我正在尝试删除单元素长度列表列表中最内层的嵌套。您是否知道一种相对简单的方法（转换为 NumPy 数组很好）：
[[[1], [2], [3], [4], [5]], [[6], [7], [8]], [[11], [12]]]
这个？：
[[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
此外，我尝试执行此操作的真实列表包含日期时间对象，而不是示例中的整数。并且列表的初始集合将具有不同的长度。
或者，如果原始列表中有 nan 就可以了，这样每个列表的长度都是相同的，只要输出列表中不存在 nan。即
[[[1], [2], [3], [4], [5]],
[[6], [7], [8], [nan], [nan]],
[[11], [12], [nan], [nan], [nan]]]
到这里：
[[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
【问题讨论】：
什么是nans？什么样的物体？ 嵌套总是一致的吗？ 假设你已经有一个多维 numpy 数组，np.squeeze() 不这样做吗？ 在 nan 示例中，我使用了 list extend 方法来均衡列表长度。这使我可以转换为 numpy 数组并对其进行整形以删除最内层的嵌套。 实际数据中这些列表的典型长度是多少？ 【参考方案1】：如果嵌套总是一致的，那么这很简单：
In [2]: import itertools
In [3]: nested = [ [ [1],[2],[3],[4], [5] ], [ [6],[7],[8] ] , [ [11],[12] ] ]
In [4]: unested = [list(itertools.chain(*sub)) for sub in nested]
In [5]: unested
Out[5]: [[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
注意，将add 与列表结合使用的解决方案将为您提供 O(n^2) 性能，其中 n 是每个子列表中合并的子子列表的数量。
【讨论】：
【参考方案2】：>>> from operator import add
>>> lists = [ [ [1],[2],[3],[4], [5] ], [ [6],[7],[8] ] , [ [11],[12] ] ]
>>> [reduce(add, lst) for lst in lists]
[[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
这不是很有效，因为每次调用 add 时它都会重建一个列表。
或者，您可以使用 sum 或简单的列表理解，如其他答案所示。
【讨论】：
【参考方案3】：因为这个问题看起来很有趣！ 我使用了一个递归函数，如果它只有一个值，它会解包一个列表。
def make_singular(l):
try:
if len(l) == 1:
return l[0]
else:
return [make_singular(l_) for l_ in l]
except:
return l
nest = [ [ [1],[2],[3],[4], [5] ], [ [6],[7],[8] ] , [ [11],[12] ] ]
make_singular(nest)
[[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
【讨论】：
【参考方案4】：试试这个：
l = [ [ [1],[2],[3],[4],[5] ],
[ [6],[7],[8], [None],[None]] ,
[ [11],[12],[None],[None],[None]] ]
l = [ [x[0] for x in s if x[0] is not None] for s in l]
【讨论】：
【参考方案5】：np.squeeze怎么样？
从数组的形状中删除一维条目。
arr = [ [ [1],[2],[3],[4], [5] ], [ [6],[7],[8] ] , [ [11],[12] ] ]
>>> arr
[[[1], [2], [3], [4], [5]], [[6], [7], [8]], [[11], [12]]]
>>> [np.squeeze(i) for i in arr]
[array([1, 2, 3, 4, 5]), array([6, 7, 8]), array([11, 12])]
但不一定是最里面的（即独立于多少维度）维度。但是您的问题指定了“列表列表”
【讨论】：
【参考方案6】：与您的情况一样，最里面的对象只有一个元素。您可以根据 index 访问该值，而不是使用一些附加功能。例如：
>>> [[y[0] for y in x] for x in my_list]
[[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
如果您的最内层列表可能包含多个元素，您可以这样做：
>>> [[z for y in x for z in y] for x in my_list]
[[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
【讨论】：
【参考方案7】：如果您知道嵌套级别，那么列表推导式之一很容易。
In [129]: ll=[ [ [1],[2],[3],[4], [5] ], [ [6],[7],[8] ] , [ [11],[12] ] ]
In [130]: [[j[0] for j in i] for i in ll] # simplest
Out[130]: [[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
如果条件只是去除嵌套的内层，不管它有多深，代码都需要更多的思考。我可能会尝试将其编写为递归函数。
np.nan（或None）填充对列表版本没有帮助
In [131]: lln=[ [ [1],[2],[3],[4],[5] ], [ [6],[7],[8],[nan],[nan]] , [ [11],[12],[nan],[nan],[nan] ] ]
In [132]: [[j[0] for j in i if j[0] is not np.nan] for i in lln]
Out[132]: [[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
填充确实让我们可以创建一个 3d 数组，然后可以轻松地对其进行压缩：
In [135]: arr = np.array(lln)
In [136]: arr.shape
Out[136]: (3, 5, 1)
In [137]: arr = arr[:,:,0]
In [138]: arr
Out[138]:
array([[ 1., 2., 3., 4., 5.],
[ 6., 7., 8., nan, nan],
[ 11., 12., nan, nan, nan]])
但问题是如何删除那些nan 并创建参差不齐的子列表。
掩码数组可能让您使用二维数组而不会被这些nan 困扰：
In [141]: M = np.ma.masked_invalid(arr)
In [142]: M
Out[142]:
masked_array(data =
[[1.0 2.0 3.0 4.0 5.0]
[6.0 7.0 8.0 -- --]
[11.0 12.0 -- -- --]],
mask =
[[False False False False False]
[False False False True True]
[False False True True True]],
fill_value = 1e+20)
In [144]: M.sum(axis=1) # e.g. sublist sums
Out[144]:
masked_array(data = [15.0 21.0 23.0],
mask = [False False False],
fill_value = 1e+20)
从arr 中删除nan 可能是使用列表理解最简单的方法。这些值是浮动的，因为 np.nan 是浮动的。
In [153]: [[i for i in row if ~np.isnan(i)] for row in arr]
Out[153]: [[1.0, 2.0, 3.0, 4.0, 5.0], [6.0, 7.0, 8.0], [11.0, 12.0]]
所以填充没有帮助。
如果填充是None，那么数组将是object dtype，它更接近于字符中的嵌套列表。
In [163]: lln
Out[163]:
[[[1], [2], [3], [4], [5]],
[[6], [7], [8], [None], [None]],
[[11], [12], [None], [None], [None]]]
In [164]: arr=np.array(lln)[:,:,0]
In [165]: arr
Out[165]:
array([[1, 2, 3, 4, 5],
[6, 7, 8, None, None],
[11, 12, None, None, None]], dtype=object)
In [166]: [[i for i in row if i is not None] for row in arr]
Out[166]: [[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
另一种数组方法是计算第 2 级的有效元素个数；把整个东西压平，然后split。
递归函数：
def foo(alist):
if len(alist)==1:
return alist[0]
else:
return [foo(i) for i in alist if foo(i) is not None]
In [200]: ll=[ [ [1],[2],[3],[4], [5] ], [ [6],[7],[8] ] , [11], [[[12],[13]]]]
In [201]: foo(ll)
Out[201]: [[1, 2, 3, 4, 5], [6, 7, 8], 11, [[12], [13]]]
In [202]: lln=[ [ [1],[2],[3],[4],[5] ], [ [6],[7],[8],[None],[None]] , [ [11],[12],[None],[None],[None] ] ]
In [203]: foo(lln)
Out[203]: [[1, 2, 3, 4, 5], [6, 7, 8], [11, 12]]
它递归到列表长度为 1 的级别。它仍然很脆弱，并且如果嵌套级别不同，则会出现异常行为。从概念上讲，它与@piRSquared's 答案非常相似。
【讨论】：
以上是关于如何在不同长度的列表列表中删除最内层的嵌套的主要内容，如果未能解决你的问题，请参考以下文章
p2·python中嵌套列表list元素输出·模块封装·发布上传(pigeon详细说)