![](/img/trans.png)
[英]How to generate enumerated tuples from a dictionary with a list comprehension in Python?
[英]Python - Generate a dictionary(tree) from a list of tuples
我有以下列表: -
a = [(1, 1), (2, 1), (3, 1), (4, 3), (5, 3), (6, 3), (7, 7), (8, 7), (9, 7)]
这是一个元组列表。 元组内的元素具有格式(Id, ParentId)
只要Id == ParentId
(Id, ParentId)
它就是根节点。 列表可以是元组的任何顺序。
我想使用上面的元组列表生成以下字典,
output = [{
'id': 1,
'children': [{
{
'id': 3,
'children': [{
{
'id': 5
},
{
'id': 4
},
{
'id': 6
}
}]
},
{
'id': 2
}
}]
}, {
'id': 7,
'children': [{
{
'id': 9
},
{
'id': 8
}
}]
}]
即(就图表而言 - 阿甘)
1 7
/ \ / \
2 3 8 9
/|\
4 5 6
我的最终输出应该是上面给出的字典。
我尝试了以下方法: -
我尝试过的解决方案如下: -
# set the value of nested dictionary.
def set_nested(d, path, value):
reduce(lambda d, k: d.setdefault(k, {}), path[:-1], d)[path[-1]] = value
return d
# returns the path of any node in list format
def return_parent(list, child):
for tuple in list:
id, parent_id = tuple
if parent_id == id == child:
return [parent_id]
elif id == child:
return [child] + return_parent(list, parent_id)
paths = []
temp = {}
for i in a:
id, parent_id = i
temp[id] = {'id': id}
path = return_parent(a, id)[::-1]
paths.append(path) # List of path is created
d = {}
for path in paths:
for n, id in enumerate(path):
set_nested(d, path[:n + 1], temp[id]) # setting the value of nested dictionary.
print d
我得到的输出是
{
'1': {
'3': {
'6': {
'id': '6'
},
'5': {
'id': '5'
},
'id': '3',
'4': {
'10': {
'id': '10'
},
'id': '4'
}
},
'2': {
'id': '2'
},
'id': '1'
},
'7': {
'9': {
'id': '9'
},
'8': {
'id': '8'
},
'id': '7'
}
}
我接近它,但无法得到确切的输出。 此外,还有更好的解决方案吗?
这是一种更简单的方法。 (编辑我从托马斯回答可以按任何顺序给出节点):Pass 1创建节点(即将它们添加到节点字典中),而Pass 2则创建父< - > children结构。
做出以下假设:没有周期(不清楚在这种情况下预期的输出是什么,Garret R指出),没有缺失的边缘,没有遗漏的树根。
a = [(1, 1), (2, 1), (3, 1), (4, 3), (5, 3), (6, 3), (7, 7), (8, 7), (9, 7)]
# pass 1: create nodes dictionary
nodes = {}
for i in a:
id, parent_id = i
nodes[id] = { 'id': id }
# pass 2: create trees and parent-child relations
forest = []
for i in a:
id, parent_id = i
node = nodes[id]
# either make the node a new tree or link it to its parent
if id == parent_id:
# start a new tree in the forest
forest.append(node)
else:
# add new_node as child to parent
parent = nodes[parent_id]
if not 'children' in parent:
# ensure parent has a 'children' field
parent['children'] = []
children = parent['children']
children.append(node)
print forest
编辑:为什么你的解决方案不能按预期工作?
以下是关于顶级的提示:您要获取的输出是树列表 。 但是,您正在处理的变量(d)需要是字典,因为在函数set_nested中,您将setdefaults方法应用于它。
为了使这更容易,让我们定义一个简单的关系对象:
class Node(dict):
def __init__(self, uid):
self._parent = None # pointer to parent Node
self['id'] = uid # keep reference to id #
self['children'] = [] # collection of pointers to child Nodes
@property
def parent(self):
return self._parent # simply return the object at the _parent pointer
@parent.setter
def parent(self, node):
self._parent = node
# add this node to parent's list of children
node['children'].append(self)
接下来定义如何将节点集合相互关联。 我们将使用dict来保存指向每个节点的指针:
def build(idPairs):
lookup = {}
for uid, pUID in idPairs:
# check if was node already added, else add now:
this = lookup.get(uid)
if this is None:
this = Node(uid) # create new Node
lookup[uid] = this # add this to the lookup, using id as key
if uid != pUID:
# set this.parent pointer to where the parent is
parent = lookup[pUID]
if not parent:
# create parent, if missing
parent = Node(pUID)
lookup[pUID] = parent
this.parent = parent
return lookup
现在,获取输入数据并将其关联起来:
a = [(1, 1), (2, 1), (3, 1), (4, 3), (5, 3), (6, 3), (7, 7), (8, 7), (9, 7)]
lookup = build(a) # can look at any node from here.
for uid in [1, 3, 4]:
parent = lookup[uid].parent
if parent:
parent = parent['id']
print "%s's parent is: %s" % (uid, parent)
最后,得到输出:你很有可能想要将数据作为一个独特的树列表而不是字典 - 但你可以选择你喜欢的。
roots = [x for x in lookup.values() if x.parent is None]
# and for nice visualization:
import json
print json.dumps(roots, indent=4)
收益:
[
{
"id": 1,
"children": [
{
"id": 2,
"children": []
},
{
"id": 3,
"children": [
{
"id": 4,
"children": []
},
{
"id": 5,
"children": []
},
{
"id": 6,
"children": []
}
]
}
]
},
{
"id": 7,
"children": [
{
"id": 8,
"children": []
},
{
"id": 9,
"children": []
}
]
} ]
根据需要,无论节点的顺序如何,此解决方案都可以工作。
a = [(1, 1), (2, 1), (3, 1), (4, 3), (5, 3), (6, 3), (7, 7), (8, 7), (9, 7)]
b = [(8, 7), (5, 3), (2, 1), (1, 1), (3, 1), (7, 7), (4, 3), (6, 3), (9, 7)]
def build_forest( nodelist ):
forest = []
nodes = {}
id = 'id'
children = 'children'
for node_id, parent_id in nodelist:
#create current node if necessary
if not node_id in nodes:
node = { id : node_id }
nodes[node_id] = node
else:
node = nodes[node_id]
if node_id == parent_id:
#add node to forrest
forest.append( node )
else:
#create parent node if necessary
if not parent_id in nodes:
parent = { id : parent_id }
nodes[parent_id] = parent
else:
parent = nodes[parent_id]
#create children if necessary
if not children in parent:
parent[children] = []
#add node to children of parent
parent[children].append( node )
return forest
print( build_forest( a ) )
print( build_forest( b ) )
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.