Question

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

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

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

require([
  'dojo/query',
  'dojo/dom-construct'
  ], function(
    query,
    domConstruct,
  ){
  var parent = query('.someClass')[0];
  var child = domConstruct.create('div', { innerHTML: '<p>helloWorld</p>'});
  domConstruct.place(child, parent, 'position');
});

我正在尝试使用0和：s切片，我没有得到正确的列表。如何在python中执行此操作？

我在我的列表中出错了。我已经编辑了这份清单。对困惑感到抱歉。

Answer 1

尝试嵌套列表理解：

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

分步骤：

查看listD中的每个嵌套行，看看它与outlist的对应关系。您可以看到每个1深列表的第一个元素都包含在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中，这些列表然后嵌套在另一个1元素列表中，因此将其中的每一个列入其自己的列表中，例如下一个元素将是：

>>> [[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]

Answer 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

Answer 3

你可以使用：

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))]

让它像你写的那样嵌套。

Answer 4

试试这个：

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]

切片多维列表

4 个答案: