对多维列表进行切片答案

【问题标题】：Slicing a multidimensional list对多维列表进行切片
【发布时间】：2016-11-28 20:06:05
【问题描述】：

我有一个可变长度的多维，如下所示：

listD = [[[[53, 54], [129, 130]]], 
     [[[51, 51], [132, 132]]], 
     [[[39, 39], 
       [144, 144]], 
      [[53, 54], 
       [129, 130]]], 
     [[[39, 39], [146, 146]], [[54, 54], [130, 130]]], 
     [[[54, 53], [130, 129]]], 
     [[[52, 52], [132, 132]]]
    ]

我需要在每个最里面的列表中挑选出第一个元素。输出应如下所示：

outlist=[[[[53, 54]]], 
     [[[51, 51]]], 
     [[[39, 39]], 
      [[53, 54]]], 
     [[[39, 39]], 
      [[54, 54]]], 
     [[[54, 53]]], 
     [[[52, 52]]]
    ]

我正在尝试使用 0 和 :s 进行切片，但没有得到正确的列表。如何在python中做到这一点？

我在我的出局列表中犯了一个错误。我已经编辑了列表。对困惑感到抱歉。

【问题讨论】：

请展示你到目前为止做了什么。
如果你想避免列表理解，你可能想看看 numpy...
我想使用列表理解。到目前为止，我在将列表转换为数组后尝试使用outlist = [listD[n][:,0,:] for n in range(8)]。这给了我一个类型错误，我使用元组而不是整数作为索引。这个错误是有道理的，但我不知道如何解决它。
你在使用 numpy 吗？
@RameshRamasubramanian，为什么输出有深层嵌套列表，你不想得到像[[53, 54], [51, 51], ...] 这样的简单列表吗？

标签： python list slice

【解决方案1】：

尝试嵌套列表理解：

[[[x[0]] for x in y] for y in listD]

分步：

查看listD 中的每个嵌套行，看看它与outlist 的对应关系。可以看到每个1-deep列表的第一个元素都包含在outlist中

>>> [x[0] for x in listD[0]] 
[[53, 54]]
>>> [x[0] for x in listD[1]] 
[[51, 51]]
>>> [x[0] for x in listD[2]] 
[[39, 39], [53, 54]]

但在outlist 中，这些列表随后嵌套在另一个单元素列表中，因此将每个列表包装到它自己的列表中，例如下一个元素是：

>>> [[x[0] for x in listD[3]]]
[[[39, 39], [54, 54]]]

然后为listD的每个索引扩展它：

[[[x[0]] for x in listD[i]] for i in range(len(listD))]

然后通过仅将 listD[i] 替换为 listD 的元素来进一步简化：

[[[x[0]] for x in y] for y in listD]

【讨论】：

为什么投反对票？鉴于问题中的listD，这个答案给出了确切的outlist...
不确定谁反对这个，这对我有很大帮助。谢谢

【解决方案2】：

尚不清楚您的列表列表是否具有统一的深度。如果它是可变深度，则最好递归处理。

给定：

>>> listD = [[[[53, 54], [129, 130]]], 
...      [[[51, 51], [132, 132]]], 
...      [[[39, 39], 
...      [144, 144]], 
...     [[53, 54], 
...      [129, 130]]], 
...      [[[39, 39], [146, 146]], [[54, 54], [130, 130]]], 
...      [[[54, 53], [130, 129]]], 
...      [[[52, 52], [132, 132]]]
...     ]
>>> 
>>> outlist=[[[[53, 54]]], 
...      [[[51, 51]]], 
...      [[[39, 39]], 
...     [[53, 54]]], 
...      [[[39, 39]], 
...     [[54, 54]]], 
...      [[[54, 53]]], 
...      [[[52, 52]]]
...     ]

您可以递归遍历列表列表，直到找到第一个元素中没有列表的列表。保持这一点。否则，增加嵌套。

例子：

def trav(x):
    result = []
    for el in x:
        if isinstance(el, list) and any(isinstance(e, list) for e in el[0]):
            result.append(trav(el))
        else:
            result.append([el[0]])
    return result


>>> trav(listD)
[[[[53, 54]]], [[[51, 51]]], [[[39, 39]], [[53, 54]]], [[[39, 39]], 
[[54, 54]]], [[[54, 53]]], [[[52, 52]]]]
>>> trav(listD)==outlist
True

【讨论】：

【解决方案3】：

这是我最近制作的一个扁平化函数，它接受任意数量的维度：

def get_dims(data):
    if not isinstance(data, (list, tuple)):
        return 0
    return get_dims(data[0]) + 1
def flatten(data, depth = 0):
    if get_dims(data) == depth:
        return [data]
    elif get_dims(data) == depth + 1:
        return list(data)
    return sum([flatten(v, depth) for v in data], [])

depth 参数用于在用户愿意的情况下留下一些子列表。这在下面很有用：

print([x[0] for x in flatten(listD, 1)])

【讨论】：

【解决方案4】：

你可以使用：

temp=[item for sublist in listD for item in sublist]
flatten=[item for sublist in temp for item in sublist]    
[flatten[int(i*2)] for i in xrange(int(len(flatten)/2))]

得到：

  [[53, 54],
 [51, 51],
 [39, 39],
 [53, 54],
 [39, 39],
 [54, 54],
 [54, 53],
 [52, 52]]

或：

[[[flatten[int(i*2)]]] for i in xrange(int(len(flatten)/2))]

让它像你写的那样嵌套。

【讨论】：

扁平化列表不起作用，因为我的后续操作必须获取特定项目的索引是内部列表。列表是高度可变的，内部列表可能是 2 或 3 或 5 或 n 长。

【解决方案5】：

试试这个：

res_list = []

for item in listD:
    sub_list = []
    for i in item:
        sub_list.append([i[0]])
    res_list.append(sub_list)

输出：

>>> res_list
[[[[53, 54]]], [[[51, 51]]], [[[39, 39]], [[53, 54]]], [[[39, 39]], [[54, 54]]], [[[54, 53]]], [[[52, 52]]]]

使用列表理解，您可以尝试：

res_list = [[[i[0]] for i in item] for item in listD]

【讨论】：