Python &引用；“困难的”；某些条件下的排序
好的。这可能很难，但我已经挣扎了相当长一段时间，没有很大的进步，所以我想知道你们的想法 假设我有以下对象列表：Python &引用；“困难的”；某些条件下的排序,python,list,sorting,object,Python,List,Sorting,Object,好的。这可能很难，但我已经挣扎了相当长一段时间，没有很大的进步，所以我想知道你们的想法 假设我有以下对象列表： objects = [ {'id': '1', 'w': 0.20}, {'id': '1.1', 'w': 0.80}, {'id': '1.2', 'w': 0.20}, {'id': '1.3', 'w': 0.30}, {'id': '1.1.1', 'w': 0.60}, {'
objects = [
{'id': '1', 'w': 0.20},
{'id': '1.1', 'w': 0.80},
{'id': '1.2', 'w': 0.20},
{'id': '1.3', 'w': 0.30},
{'id': '1.1.1', 'w': 0.60},
{'id': '1.1.2', 'w': 0.70},
{'id': '1.1.3', 'w': 0.40},
{'id': '1.2.1', 'w': 0.30},
]
“1”、“1.1”、“1.1.1”、“1.1.2”、“1.1.3”、“1.2”、“1.2.1”、“1.3”[ [ {'w': 0.2, 'id': '1'} ], [ {'w': 0.8, 'id': '1.1'}, {'w': 0.3, 'id': '1.3'},
{'w': 0.2, 'id': '1.2'} ], [ {'w': 0.7, 'id': '1.1.2'}, {'w': 0.6, 'id': '1.1.1'},
{'w': 0.4, 'id': '1.1.3'} ], [ {'w': 0.3, 'id': '1.2.1'} ] ]
[{'w'：0.8，'id'：'1.1'}，{'w'：0.3，'id'：'1.3'}，{'w'：0.2，'id'：'1.2'}][{'w'：0.2，'id'：'1'}]的所有子元素。此外，每个嵌套列表按“w”排序
最终结果应该是这样的（假设链接所有内部列表-list（itertools.chain（*b））
：
基本上，首先是父元素，然后是它的子元素（按“w”排序），每个元素都是如此（如果它有子元素，当然-这里{'id'：'1.3'，'w'：0.30}
没有子元素，所以我们不需要对它做任何事情）
我试过几件事（太复杂了，不值得解释）。我最终得到了很多条件和一个丑陋的代码
如何完成此排序
提前感谢。使用比较器进行排序。也就是说，您编写的方法如下所示
def comparator(x, y):
## some code that sets value to -1 if x is "less than" y
## or 1 if x is "greater than or equal to" y.
return value
然后调用objects.sort（comparator）
，您应该被设置
这样，您一次只需比较两个项目。只要保持一致，就不会有问题。使用比较器排序。也就是说，您编写的方法如下所示
def comparator(x, y):
## some code that sets value to -1 if x is "less than" y
## or 1 if x is "greater than or equal to" y.
return value
然后调用objects.sort（comparator）
，您应该被设置
这样，您一次只需比较两个项目。只要你是一致的，就不会有问题。简单的排序不会解决你的问题，因为不可能比较任何两个元素并立即知道一个元素在另一个元素之前出现（父元素的权重可能会改变排序）
您需要将列表处理为树状结构，然后按顺序提取：
tree = {}
for d in objects:
ids = d['id'].split('.')
w = d['w']
# walk into the tree, creating nodes as necessary
subtree = [0,tree]
for n in ids:
if n not in subtree[1]:
subtree[1][n] = [0,{}] # w, list of nodes
subtree = subtree[1][n] # recurse
# subtree is now the relevant node, set w
subtree[0] = w
## now we have a tree:
## >>> pprint.pprint(tree, width=10)
## {'1': [0.2,
## {'1': [0.8,
## {'1': [0.6,
## {}],
## '2': [0.7,
## {}],
## '3': [0.4,
## {}]}],
## '2': [0.2,
## {'1': [0.3,
## {}]}],
## '3': [0.3,
## {}]}]}
# now walk the tree and extract the nodes:
result = []
def walk_subtree(subtree, path=[]):
keyweights = [(subtree[key][0], key) for key in subtree]
# walk through nodes at this level, outputting.
for weight, key in sorted(keyweights, reverse=True):
result.append(('.'.join(path + [key]), weight))
walk_subtree(subtree[key][1], path=path+[key])
walk_subtree(tree)
##>>> pprint.pprint(result)
##[('1', 0.2),
## ('1.1', 0.8),
## ('1.1.2', 0.7),
## ('1.1.1', 0.6),
## ('1.1.3', 0.4),
## ('1.3', 0.3),
## ('1.2', 0.2),
## ('1.2.1', 0.3)]
简单的排序无法解决您的问题，因为无法比较任何两个元素并立即知道其中一个元素何时出现在另一个元素之前（父元素的权重可能会改变排序）
您需要将列表处理为树状结构，然后按顺序提取：
tree = {}
for d in objects:
ids = d['id'].split('.')
w = d['w']
# walk into the tree, creating nodes as necessary
subtree = [0,tree]
for n in ids:
if n not in subtree[1]:
subtree[1][n] = [0,{}] # w, list of nodes
subtree = subtree[1][n] # recurse
# subtree is now the relevant node, set w
subtree[0] = w
## now we have a tree:
## >>> pprint.pprint(tree, width=10)
## {'1': [0.2,
## {'1': [0.8,
## {'1': [0.6,
## {}],
## '2': [0.7,
## {}],
## '3': [0.4,
## {}]}],
## '2': [0.2,
## {'1': [0.3,
## {}]}],
## '3': [0.3,
## {}]}]}
# now walk the tree and extract the nodes:
result = []
def walk_subtree(subtree, path=[]):
keyweights = [(subtree[key][0], key) for key in subtree]
# walk through nodes at this level, outputting.
for weight, key in sorted(keyweights, reverse=True):
result.append(('.'.join(path + [key]), weight))
walk_subtree(subtree[key][1], path=path+[key])
walk_subtree(tree)
##>>> pprint.pprint(result)
##[('1', 0.2),
## ('1.1', 0.8),
## ('1.1.2', 0.7),
## ('1.1.1', 0.6),
## ('1.1.3', 0.4),
## ('1.3', 0.3),
## ('1.2', 0.2),
## ('1.2.1', 0.3)]
作为所需结果发布的示例未按照您的描述进行排序<例如，code>1.1.21.1.1w1.1.1w