Python 按它对词典进行排序'；s嵌套字典值

这是我的输入数据：

Mydict={
红色：{'Pesho'：1250000，'Chicho'：101}，
蓝色：{'Pesho'：10000，'Gosho'：10000，'Jecho'：260000}，
白色：{'Bobo'：10，'Bebo'：10，'Bibo'：100，'Bubo'：10}
}

我想先按嵌套字典的值，然后按其长度对输出进行排序。怎么做

输出应如下所示：

(Red) Pesho <-> 1250000
(Blue) Jecho <-> 260000
(Blue) Pesho <-> 10000
(Blue) Gosho <-> 10000
(Red) Chicho <-> 101
(White) Bibo <-> 100
(White) Bobo <-> 10
(White) Bebo <-> 10
(White) Bubo <-> 10

（红色）比索1250000
（蓝色）杰乔260000
（蓝色）比索10000
（蓝色）Gosho 10000
（红色）奇科101
（白色）碧波100
（白色）波波10
（白色）贝博10
（白色）布波10号

在进一步挖掘之后，我得出了以下结论：

sorted_Mydict = dict(sorted(Mydict.items(), key=lambda x: -len(x[1].values()))) #Making a new order by the count of the nested dictionarie values
pairs = [(color, name, power) for color, inner in sorted_Mydict.items() for name, power in inner.items()] #Then creating list of pairs, as suggested in the comments
[print(f"({color}) {name} <-> {power}") for color, name, power in sorted(pairs, key=lambda x: -x[2])] #Finally printing in the desired format, ordered by the int values

sorted_Mydict=dict（sorted（Mydict.items（），key=lambda x:-len（x[1].values（）））#通过嵌套字典值的计数进行新的排序
pairs=[（颜色、名称、功率）表示颜色，内部为已排序的_Mydict.items（）表示名称，功率为内部为.items（）。#然后按照注释中的建议创建对列表
[print（f“（{color}）{name}{power}”）用于颜色、名称、功率的排序（成对，key=lambda x:-x[2]）#最后以所需格式打印，按int值排序

---

谢谢大家的帮助

这不是排序，您得到的值比输入的值多。另外，您不应该使用“dict”作为dict的名称，因为它是一种python方法。 不过，这里有一个可行的答案：）

---

首先需要创建一个包含3个元素的元组列表的结构

颜色、名称、值

，然后使用您的标准对其进行排序

values = {
    'Red': {'Pesho': 1250000, 'Chicho': 101},
    'Blue': {'Pesho': 10000, 'Gosho': 10000, 'Jecho': 260000},
    'White': {'Bobo': 10, 'Bebo': 10, 'Bibo': 100, 'Bubo': 10}
}

pairs = [(outer_key, inner_key, value) for outer_key, inner in values.items() 
                                       for inner_key, value in inner.items()]

pairs.sort(key=lambda x: (-x[2], len(x[1])))
print(pairs[:3])  # [('Red', 'Pesho', 1250000), ('Blue', 'Jecho', 260000), ('Blue', 'Pesho', 10000)]

---

将字典值合并到元组列表中。使用适当的键函数对列表进行排序。然后可以根据需要格式化打印输出

myDict = {
'Red': {'Pesho': 1250000, 'Chicho': 101},
'Blue': {'Pesho': 10000, 'Gosho': 10000, 'Jecho': 260000},
'White': {'Bobo': 10, 'Bebo': 10, 'Bibo': 100, 'Bubo': 10}
}

r = [(C,K,n) for C,d in myDict.items() for K,n in d.items()]
r.sort(key=lambda ckn:ckn[-1], reverse=True)

for C,K,n in r: print(f"({C}) {K},<-> {n}")

(Red) Pesho,<-> 1250000
(Blue) Jecho,<-> 260000
(Blue) Pesho,<-> 10000
(Blue) Gosho,<-> 10000
(Red) Chicho,<-> 101
(White) Bibo,<-> 100
(White) Bobo,<-> 10
(White) Bebo,<-> 10
(White) Bubo,<-> 10

myDict={
红色：{'Pesho'：1250000，'Chicho'：101}，
蓝色：{'Pesho'：10000，'Gosho'：10000，'Jecho'：260000}，
白色：{'Bobo'：10，'Bebo'：10，'Bibo'：100，'Bubo'：10}
}
r=[（C，K，n）表示myDict.items（）中的C，d表示K，n表示d.items（）]
r、 排序（key=lambda ckn:ckn[-1]，reverse=True）
对于r中的C，K，n:print（f“（{C}{K}，{n}”）
（红色）比索，1250000
（蓝色）杰乔，260000
（蓝色）比索，10000
（蓝色）Gosho，10000
（红色）Chicho，101
（白色）碧波，100
（白色）波波，10岁
（白色）贝博，10岁
（白色）布波，10岁

“然后按其长度”-谁的长度？欢迎来到堆栈溢出！请拿起，阅读，和，并提供一个。“为我实现此功能”是本网站的主题。你必须做一个诚实的尝试，然后问一个关于你的算法或技术的具体问题。是的，正在研究答案，应该等一下，我下次会问：）

myDict = {
'Red': {'Pesho': 1250000, 'Chicho': 101},
'Blue': {'Pesho': 10000, 'Gosho': 10000, 'Jecho': 260000},
'White': {'Bobo': 10, 'Bebo': 10, 'Bibo': 100, 'Bubo': 10}
}

r = [(C,K,n) for C,d in myDict.items() for K,n in d.items()]
r.sort(key=lambda ckn:ckn[-1], reverse=True)

for C,K,n in r: print(f"({C}) {K},<-> {n}")

(Red) Pesho,<-> 1250000
(Blue) Jecho,<-> 260000
(Blue) Pesho,<-> 10000
(Blue) Gosho,<-> 10000
(Red) Chicho,<-> 101
(White) Bibo,<-> 100
(White) Bobo,<-> 10
(White) Bebo,<-> 10
(White) Bubo,<-> 10