具有深度值的镜像列表，到嵌套列表~ Python

Question

我将继续自动化我的操纵过程，并试图构建一个C4D Python脚本。我试图将基于深度值的列表镜像为嵌套列表。

假设我们有一个具有深度值的列表，

depth_list = [[0,'Hips'],[1,'Spine'],[2,'Spine1'],[3,'Spine2'],[4,'Neck'],[5,'Head'],[6,'HeadTop_End'],[4,'LeftShoulder']]

我们希望这个成为基于深度值的嵌套联合列表：

joint_list = [['Hips',['Spine',['Spine1',['Spine2',['Neck',['Head',['HeadTop_End']]],['LefShoulder']]]]]]

我已经走了这么远：

for joint in depth_list:
    this_depth = joint[0]
    try:
        joint_list.append(0)
    except IndexError:
        pass

这是我从C4D树导出脚本获得的原始数据。

0  Hips
1      Spine
2          Spine1
3              Spine2
4                  Neck
5                      Head
6                          HeadTop_End
4                  LeftShoulder

下面是一幅图片：

和一个快乐的一千万人！

Answer 1

您可以递归地这样做，如下所示：

depth_list = [[0,'Hips'],[1,'Spine'],[2,'Spine1'],[3,'Spine2'],[4,'Neck'],[5,'Head'],[6,'HeadTop_End'],[4,'LeftShoulder']]

def construct(depth_list, current_level=0):
    output = []
    while len(depth_list) > 0:
        new_level, new_name = depth_list[0]

        if new_level == current_level:
            output.append([new_name])
            depth_list.pop(0)
        elif new_level > current_level:
            child = construct(depth_list, new_level)
            output[-1].extend(child)
        else:
            return output

  return output

print(construct(depth_list))

基本思想是递归遍历输入列表。每次遇到一个元素时，您都会做三件事中的一件：

1. 如果连接在同一级别，则从depth_list中删除连接并将其添加到输出(其中包含当前级别的所有连接)。
2. 如果连接是一个更深的层次，那么不要修改depth_list，而是递归获取子树。然后，将该树添加到输出列表中的最后一个元素，即当前连接。(递归调用还将从depth_list中删除正确的元素数)。
3. 如果它处于较浅的级别，则放弃并返回，让父服务器继续对depth_list的其余部分进行循环。

请注意，这个函数是破坏性的--一旦函数完成，它将使depth_list完全为空。如果要保存它，请在调用函数之前复制列表：

copy = list(depth_list)
print(construct(copy))

Answer 2

您可以尝试以下代码：

depth_list = [[0,'Hips'],[1,'Spine'],[2,'Spine1'],[3,'Spine2'],[4,'Neck'],[5,'Head'],[6,'HeadTop_End'],[4,'LeftShoulder']]

result = []

current_list = None
current_item = []
current_level = 0

level_dict = {}

for depth, value in depth_list:
    if depth == 0:
        if current_list:
            result.append(current_list)
            current_list = None
        current_list = current_item
        current_item.append(value)
        level_dict[0] = current_list
    elif depth == current_level:
        current_item.append(value)
    elif depth == current_level + 1:
        append_item = []
        level_dict[depth] = current_item
        current_item.append(append_item)
        append_item.append(value)
        current_item = append_item
        current_level += 1
    else:
        level_dict[depth].append(value)

if current_list:
    result.append(current_list)

print result

这样做的目的是跟踪之前的水平。我还在字典中保存了所有级别的安全，以便在以前检查的级别上插入项。例如，当您处于第6级时，您正在等待第7级项，但出现了第4级项，因此您必须相应地更新列表。

更新

我认为这个解决办法比另一个更清楚。它会变慢，因为它会对输入进行排序，但是如果您没有像10.000项或更多的输入，那么它不会产生很大的影响，您的代码也会变得清晰。而且，这种方法总是将项目放在级别之前。此函数假定每个级别至少提供一项。因此，鉴于这些事实，以下是解决办法：

from itertools import groupby

depth_list = [[0, 'Hips'], [1, 'Spine'], [2, 'Spine1'], [3, 'Spine2'], [4, 'Neck'], [5, 'Head'], [6, 'HeadTop_End'], [4, 'LeftShoulder'], [5, 'LeftArm'], [6, 'LeftForeArm'], [7, 'LeftHand']]

result = []
current_level = result

get_level_number = lambda item_info: item_info[0]

sorted_by_level = sorted(depth_list, key=get_level_number)
grouped_by_level = groupby(sorted_by_level, key=get_level_number)

for level_number, grouped_items in grouped_by_level:
    level = [tag for level, tag in grouped_items]
    print level_number, level
    current_level.append(level)
    current_level = level

print result