在python中使用列表对嵌套字典进行排序

我正在给一本包含列表的词典排序。例如，如果我有这本词典：

a = {'q': {3: [4, 2, 7]}, 'a': {1: [5, 45, 11]}, 'e': {23: [11, 45, 2]}}

我希望排序后的输出为：

[(e, {23:[11,45,2}]), (a, {1:[5,45,11]}), (q,{3,[4,2,7]})] 

我实际上是在反向排序，使用列表中的第一项作为排序键

如果两个列表的前几项相同（如上所述），我将按字母顺序对与列表（主键）关联的字符串进行排序

我不确定是否可以得到包含字典的元组的输出，因为我正在对字典中的列表进行排序

我尝试过以下代码：

sorted((x,b.items(), key=lambda x:[1][2]) for x,b in a.items())

---

它引发了一个无效语法错误，我无法找出错误所在。

至少在交互式解释器中，完整的错误消息应该显示错误发生的确切位置：

>>> sorted((x,b.items(), key=lambda x:[1][2]) for x,b in a.items())
  File "<stdin>", line 1
    sorted((x,b.items(), key=lambda x:[1][2]) for x,b in a.items())
                            ^
SyntaxError: invalid syntax

这是一个元组，它的第三个成员是

key=lambda x:[1][2]

。但这不是一个有效的表达式。你把括号放错地方了。或者，您将

键

参数添加到了错误的位置。我想你的意思是：

sorted(((x,b.items()) for x,b in a.items()), key=lambda x:[1][2])

---

没有语法错误。看起来以后会出现一个

索引器，但您可以在到达后处理该问题。
至少在交互式解释器中，完整的错误消息应该显示错误发生的确切位置：

>>> sorted((x,b.items(), key=lambda x:[1][2]) for x,b in a.items())
  File "<stdin>", line 1
    sorted((x,b.items(), key=lambda x:[1][2]) for x,b in a.items())
                            ^
SyntaxError: invalid syntax

这是一个元组，它的第三个成员是
key=lambda x:[1][2]
。但这不是一个有效的表达式。你把括号放错地方了。或者，您将
键
参数添加到了错误的位置。我想你的意思是：

sorted(((x,b.items()) for x,b in a.items()), key=lambda x:[1][2])

没有语法错误。看起来以后会有一个
索引器
，但你可以在那里处理。
我不是100%确定，但你最终会这样做吗

>>> a = {'q': {3: [4, 2, 7]}, 'a': {1: [5, 3, 11]}, 'e': {23: [11, 45, 2]}}
>>> new_order = sorted(a, key=lambda L: a[L].values(), reverse=True)
>>> zip(new_order, map(a.get, new_order))
[('e', {23: [11, 45, 2]}), ('a', {1: [5, 3, 11]}), ('q', {3: [4, 2, 7]})]

我不是百分之百确定，但你最终会追求吗

>>> a = {'q': {3: [4, 2, 7]}, 'a': {1: [5, 3, 11]}, 'e': {23: [11, 45, 2]}}
>>> new_order = sorted(a, key=lambda L: a[L].values(), reverse=True)
>>> zip(new_order, map(a.get, new_order))
[('e', {23: [11, 45, 2]}), ('a', {1: [5, 3, 11]}), ('q', {3: [4, 2, 7]})]

让我们把这个问题分成几个部分。确实要对列表进行排序
a.items（）
。因此：

>>> to_sort = a.items()
>>> to_sort
[('q', {3: [4, 2, 7]}), ('a', {1: [5, 3, 11]}), ('e', {23: [11, 45, 2]})]

现在，对于列表中的每个元素，都有一个值的元组（
'q'
等）和一个字典。假设每个字典只包含一个键，您希望使用每个字典值的index-1元素作为主键。因此，第一个元素的键应该是：
to_sort[0][1]。values（）[0][1]
：
to_sort[0][1]
为您提供字典
{3:[4,2,7]}
，
.values（）
为您提供列表
[[4,2,7]
，以及
[0][1]
为您提供
。第二个排序键只是
到\u sort[0]

因此，我们得到：

>>> sorted(to_sort, key=lambda x: (x[1].values()[0][1], x[0]))
[('q', {3: [4, 2, 7]}), ('a', {1: [5, 3, 11]}), ('e', {23: [11, 45, 2]})]

我们快到了。现在您只需要告诉sort您想要反向输出：

>>> sorted(to_sort, key=lambda x: (x[1].values()[0][1], x[0]), reverse=True)
[('e', {23: [11, 45, 2]}), ('a', {1: [5, 3, 11]}), ('q', {3: [4, 2, 7]})]

这是你想要的吗

如果您想要单班轮，可以执行以下操作：

>>> sorted(a.items(), key=lambda x: (x[1].values()[0][1], x[0]), reverse=True)

让我们把这个问题分成几个部分。确实要对列表进行排序
a.items（）
。因此：

>>> to_sort = a.items()
>>> to_sort
[('q', {3: [4, 2, 7]}), ('a', {1: [5, 3, 11]}), ('e', {23: [11, 45, 2]})]

现在，对于列表中的每个元素，都有一个值的元组（
'q'
等）和一个字典。假设每个字典只包含一个键，您希望使用每个字典值的index-1元素作为主键。因此，第一个元素的键应该是：
to_sort[0][1]。values（）[0][1]
：
to_sort[0][1]
为您提供字典
{3:[4,2,7]}
，
.values（）
为您提供列表
[[4,2,7]
，以及
[0][1]
为您提供
。第二个排序键只是
到\u sort[0]

因此，我们得到：

>>> sorted(to_sort, key=lambda x: (x[1].values()[0][1], x[0]))
[('q', {3: [4, 2, 7]}), ('a', {1: [5, 3, 11]}), ('e', {23: [11, 45, 2]})]

我们快到了。现在您只需要告诉sort您想要反向输出：

>>> sorted(to_sort, key=lambda x: (x[1].values()[0][1], x[0]), reverse=True)
[('e', {23: [11, 45, 2]}), ('a', {1: [5, 3, 11]}), ('q', {3: [4, 2, 7]})]

这是你想要的吗

如果您想要单班轮，可以执行以下操作：

>>> sorted(a.items(), key=lambda x: (x[1].values()[0][1], x[0]), reverse=True)

语法错误是怎么说的？@user1988876在原始帖子中，您说您想使用
list.index[1]
中的项作为排序键。您是指每个列表中的第一项（即列表[0]）还是第二项？语法错误是怎么说的？@user1988876在最初的帖子中，您说您想使用
list.index[1]
处的项作为排序键。你是指第一项（即列表[0]），还是每个列表中的第二项？精彩的逐步解释。精彩的逐步解释。