如何订购词典的词典基于内部字典的价值

Question

我有Python中的字典具有字典中的值是这样的：

{'q1': {'d1': 1.2 , 'd5': 5.2}, 
'q2': {'d4': 3.23, 'd7': 3.9 , 'd8': 4.1}, 
'q3': {'d3': 0.5}} 

我想排名本字典和展示的基础上减少值d变量与他们关联的浮点数 。

的结果应该是这样的：

['d5', 'd8', 'd7', 'd4', 'd1', 'd3'] 

这是我写的，以填补我的字典代码的一部分：

if q not in result.keys(): 
    result[q] = {id:rsv[id]} 
elif id not in result[q]: 
    result[q][id]=rsv[id] 

我想表明这是排序的id rsv值。 有没有办法做到这一点？或者有没有其他解决方案可以根据一系列值对字典进行排序？

Answer 1

我的目标是提高代码清晰度，并认为在这种情况下最好使用更多的代码来实现代码。请注意，使用的缩进是为了更好地显示结构。

此答案包含经常需要的中间结果，以我的经验。它将它们保留为字典，直到只需要密钥的那一端。

首先，Python的2.x版，只是因为：

d = {'q1': {'d1': 1.2 , 'd5': 5.2}, 
    'q2': {'d4': 3.23, 'd7': 3.9 , 'd8': 4.1}, 
    'q3': {'d3': 0.5}} 

# First, flatten to a list of one key-value pair dictionaries 
inner_dicts = [ 
    dict([(k,v)]) 
    for inner_d in d.values() 
     for (k, v) in inner_d.items()] 

# Second, sort that list based on the value in each dict 
dictlist_sorted = sorted(
    inner_dicts, 
    key=lambda temp_d: temp_d.values()[0], 
    reverse=True) 

# Third, extract the key of each dict 
keys_sorted = [temp_d.keys()[0] for temp_d in dictlist_sorted] 

print keys_sorted 

二，Python 3的版本：

d = {'q1': {'d1': 1.2 , 'd5': 5.2}, 
    'q2': {'d4': 3.23, 'd7': 3.9 , 'd8': 4.1}, 
    'q3': {'d3': 0.5}} 

# First, flatten to a list of one key-value pair dictionaries 
inner_dicts = [ 
    dict([(k,v)]) 
    for inner_d in d.values() 
     for (k, v) in inner_d.items()] 

# Second, sort that list based on the value in each dict 
dictlist_sorted = sorted(
    inner_dicts, 
    key=lambda temp_d: list(temp_d.values())[0], 
    reverse=True) 

# Third, extract the key of each dict 
keys_sorted = [list(temp_d.keys())[0] for temp_d in dictlist_sorted] 

print(keys_sorted) 

Answer 2

排序的值，提取到的值和关键元组（按该顺序），并随后提取关键：

[key for value, key in sorted(
    (item[::-1] for d in outer.values() for item in d.items()), 
    reverse=True)] 

的(item[::-1] for d in outer.values() for item in d.items())表达提取从每个嵌套字典值的(key, value)双，扭转了关键以及便于分类的价值。

排序然后取第一个值，相反，之后外列表理解再次提取关键字。

演示：排序，然后显示：

>>> d = {'q1': {'d1': 1.2 , 'd5':5.2}, 'q2': {'d4': 3.23, 'd7':3.9 , 'd8':4.1}, 'q3': {'d3': 0.5}} 
>>> outer = {'q1': {'d1': 1.2 , 'd5':5.2}, 'q2': {'d4': 3.23, 'd7':3.9 , 'd8':4.1}, 'q3': {'d3': 0.5}} 
>>> sorted((item[::-1] for d in outer.values() for item in d.items()), reverse=True) 
[(5.2, 'd5'), (4.1, 'd8'), (3.9, 'd7'), (3.23, 'd4'), (1.2, 'd1'), (0.5, 'd3')] 
>>> [key for value, key in sorted(
...  (item[::-1] for d in outer.values() for item in d.items()), 
...  reverse=True)] 
['d5', 'd8', 'd7', 'd4', 'd1', 'd3'] 

Answer 3

我会分两步处理这个。对于排序，使用一键功能：

d_sorted = sorted(d.items(), reverse=True, key=lambda x: list(x[1].values())[0]) 

然后，显示数据：

print(', '.join(list(x[1].keys())[0] for x in d_sorted)) 

一般来说，这是一个好主意，因为你可能想重用完全排序的数据。

Answer 4

由于运改变了规范，以在多个键值对内心的话，我想我会展示一个解决方案，它吸取了@ jarno-lamberg的一些想法。这里的关键是，由于外部映射似乎不相关，我首先获取所有的字典并将它们压缩成元组列表。

d = {'q1': {'d1': 1.2 , 'd5': 5.2}, 
     'q2': {'d4': 3.23, 'd7': 3.9 , 'd8': 4.1}, 
     'q3': {'d3': 0.5}} 
d_flattened = [(k,v) for temp_d in d.values() for k,v in temp_d.items()] 
d_sorted = sorted(d_flattened, key=lambda i: i[1], reverse=True) 
print(', '.join(k for k,v in d_sorted))