Python 3.x Python转储树列表项字典

我有一个层次结构/树，我将其转换为列表显示（级别、项目）。 我需要创建一些循环，它将在表示树的级别的项目字典中创建字典，这可能适用于具有不同级别的其他树，项目

转储树结构：

(0, 'Job=XYZ')
    (1, 'Input Options Display')
    (1, 'Abend S=0C7 (DEMO)')
        (2, 'Abending Statement')
            (3, 'Procedure DEMO')
                (4, 'Variables')
            (3, 'Storage')
        (2, 'Program DEMO2')
            (3, 'Storage')
    (1, 'Execution Summary') 

# the input list
my_list = [(0, 'Job=XY2'),
           (1, 'Input Options Display'),
           (1, 'Abend S=0C7 (DEMO)'),
           (2, 'Abending Statement'),
           (3, 'Procedure DEMO'),
           (4, 'Variables'),
           (3, 'Storage'),
           (2, 'Program DEMO2'),
           (3, 'Storage'),
           (1, 'Execution Summary')]

def return_dict(key, current_level, l):
    d = {}
    d[key] = []
    for i, (level, element) in enumerate(l):        
        if level == current_level+1 and i+1 < len(l):
            # not the last one
            if l[i+1][0] == level+1:
                # deeper level exist
                d[key].append(return_dict(element, level, l[i+1:]))
            else:
                if element not in d[key]:
                    d[key].append(element)
        else:
            # last one           
            if level == current_level+1:
                d[key].append(element)
    return d

result = return_dict(my_list[0][1], my_list[0][0], my_list[1:])
print(result)

{'Abending Statement': 
    [
        {'Procedure DEMO': ['Variables']}, 
        'Storage'
    ]
}       


{'Program DEMO2': 
    ['Storage']
}

预期的字典类似于：

{Job=XYZ: 'Input Options Display', 'Abend S=0C7 (DEMO)':{'Abending Statement': 'Procedure DEMO' ... # and so on

---

我不知道如何使用字典来处理分层数据，但我找到了一个分层列表：

src = [(0, 'Job=XYZ'),
    (1, 'Input Options Display'),
    (1, 'Abend S=0C7 (DEMO)'),
        (2, 'Abending Statement'),
            (3, 'Procedure DEMO'),
                (4, 'Variables'),
            (3, 'Storage'),
        (2, 'Program DEMO2'),
            (3, 'Storage'),
    (1, 'Execution Summary') ]

print(src)

top = []
current = top
current_level = 0
next = None

stack = [current]

for level,item in src:
    if level is not current_level:
        while len(stack) <= level:
            stack.append(None)
        if level > current_level:
            stack[current_level] = current
            current = next
        if level < current_level:
            current = stack[level]
    next = []
    current.append((item,next))
    current_level = level

print(top)

src

将原始数据转换为元组列表。 输出首先显示

src

，然后显示转换后的数据

---

输出数据结构是一个元组列表，其中每个元组是来自源的字符串和一个子列表。当然，每个子列表都是具有相同格式的元组列表。（空的子列表表示叶项）。

这里是一个以字典作为输出的示例，但它的结构相当复杂：

(0, 'Job=XYZ')
    (1, 'Input Options Display')
    (1, 'Abend S=0C7 (DEMO)')
        (2, 'Abending Statement')
            (3, 'Procedure DEMO')
                (4, 'Variables')
            (3, 'Storage')
        (2, 'Program DEMO2')
            (3, 'Storage')
    (1, 'Execution Summary') 

# the input list
my_list = [(0, 'Job=XY2'),
           (1, 'Input Options Display'),
           (1, 'Abend S=0C7 (DEMO)'),
           (2, 'Abending Statement'),
           (3, 'Procedure DEMO'),
           (4, 'Variables'),
           (3, 'Storage'),
           (2, 'Program DEMO2'),
           (3, 'Storage'),
           (1, 'Execution Summary')]

def return_dict(key, current_level, l):
    d = {}
    d[key] = []
    for i, (level, element) in enumerate(l):        
        if level == current_level+1 and i+1 < len(l):
            # not the last one
            if l[i+1][0] == level+1:
                # deeper level exist
                d[key].append(return_dict(element, level, l[i+1:]))
            else:
                if element not in d[key]:
                    d[key].append(element)
        else:
            # last one           
            if level == current_level+1:
                d[key].append(element)
    return d

result = return_dict(my_list[0][1], my_list[0][0], my_list[1:])
print(result)

{'Abending Statement': 
    [
        {'Procedure DEMO': ['Variables']}, 
        'Storage'
    ]
}       


{'Program DEMO2': 
    ['Storage']
}

您可以查看级别1，它是一个包含3个元素的列表，其中第一个和最后一个元素是字符串，第二个元素是字典

{'Job=XY2': 
    [
        'Input Options Display', 
        {'Abend S=0C7 (DEMO)': [{'Abending Statement': [{'Procedure DEMO': ['Variables']}, 'Storage']}, {'Program DEMO2': ['Storage']}]}, 
        'Execution Summary'
    ]
}

如果分解级别1的dictionary元素2，则会得到以下结构，即一个以2元素列表为值的字典，其中包含字典：

{'Abend S=0C7 (DEMO)': 
    [
        {'Abending Statement': [{'Procedure DEMO': ['Variables']}, 'Storage']}, 
        {'Program DEMO2': ['Storage']}
    ]
}

进一步细分此级别，您将得到以下结构：

(0, 'Job=XYZ')
    (1, 'Input Options Display')
    (1, 'Abend S=0C7 (DEMO)')
        (2, 'Abending Statement')
            (3, 'Procedure DEMO')
                (4, 'Variables')
            (3, 'Storage')
        (2, 'Program DEMO2')
            (3, 'Storage')
    (1, 'Execution Summary') 

# the input list
my_list = [(0, 'Job=XY2'),
           (1, 'Input Options Display'),
           (1, 'Abend S=0C7 (DEMO)'),
           (2, 'Abending Statement'),
           (3, 'Procedure DEMO'),
           (4, 'Variables'),
           (3, 'Storage'),
           (2, 'Program DEMO2'),
           (3, 'Storage'),
           (1, 'Execution Summary')]

def return_dict(key, current_level, l):
    d = {}
    d[key] = []
    for i, (level, element) in enumerate(l):        
        if level == current_level+1 and i+1 < len(l):
            # not the last one
            if l[i+1][0] == level+1:
                # deeper level exist
                d[key].append(return_dict(element, level, l[i+1:]))
            else:
                if element not in d[key]:
                    d[key].append(element)
        else:
            # last one           
            if level == current_level+1:
                d[key].append(element)
    return d

result = return_dict(my_list[0][1], my_list[0][0], my_list[1:])
print(result)

{'Abending Statement': 
    [
        {'Procedure DEMO': ['Variables']}, 
        'Storage'
    ]
}       


{'Program DEMO2': 
    ['Storage']
}

要检索任何值，请执行以下操作：

• （1） 调用顶层的键，并将其作为结果列出
• （2） 枚举列表或索引列表
  • （a） 如果list的元素是string，则这是值
  • （b） 如果元素是dictionary，则重复（1）

例如，要获取“过程演示”值：

输出：

{'Job=XY2': ['Input Options Display', {'Abend S=0C7 (DEMO)': [{'Abending Statement': [{'Procedure DEMO': ['Variables']}, 'Storage']}, {'Program DEMO2': ['Storage']}]}, 'Execution Summary']}

Variables

---

“转储树”是什么意思？转储树=转储（程序）的层次结构。（0，'Job=XYZ'）=（树级，'item'）您的预期输出有点混乱，因为一方面，

0

level item'Job'变为键，但

1

level item'Input'变为值。另一方面，下一个

1

级别的项“Abend”是一个键。老实说，我甚至不确定输出字典应该是什么样子。。。我的目标是拥有一个字典，它将根据级别反映树的结构，级别将从输出字典中省略。级别（数字）仅表示层次结构。所以“Job=XYZ”是一个父项，有子项的“输入选项显示”，“Abend S=0C7（演示）”，可能有子项，也可能没有子项。。。非常感谢你！只需对脚本进行一些小的更改，就可以生成字典。