blocks|key|2089199|text|那麽：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2089200|newlist+=+sorted(Times,+key=lambda+k:+k.values()[0])|code-block|syntax|javascript|2089201|它关闭字典的.values()的第一个(仅)|offset|length|style|CODE|2089202|entityMap^0|0|0|6|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

What about:

<pre><code>newlist = sorted(Times, key=lambda k: k.values()[0])
</code></pre>

It keys off the first (only) of the dictionary's <code>.values()</code>

blocks|key|2089228|text|times+=+[{"Bob":14.05},{"Tim":15.09},{"Tim":17.01},{"Bob":16.81},{"Sarah":15.08}]
print+sorted(times,+key=lambda+k:+k.values())|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2089229|输出|unstyled|offset|length|style|BOLD|2089230|[{'Bob':+14.05},{'Sarah':+15.08},+{'Tim':+15.09},+{'Bob':+16.81},+{'Tim':+17.01}]|2089231|如果values列表中有多个值，并且希望只考虑特定索引上的元素，则可以这样做。|CODE|2089232|print+sorted(times,+key=lambda+k:+k.values()[0])|2089233|entityMap^0|0|0|2|0|0|2|6|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|U|8|@$G|V|H|W|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|X|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|Y|8|@$G|Z|H|10|I|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|11|8|@]|9|@]|A|$B|C]]|$1|R|3|-4|5|F|7|12|8|@]|9|@]|A|$]]]|S|$]]

<pre><code>times = [{"Bob":14.05},{"Tim":15.09},{"Tim":17.01},{"Bob":16.81},{"Sarah":15.08}]
print sorted(times, key=lambda k: k.values())
</code></pre>

Output

<pre><code>[{'Bob': 14.05},{'Sarah': 15.08}, {'Tim': 15.09}, {'Bob': 16.81}, {'Tim': 17.01}]
</code></pre>

If there are multiple values in the <code>values</code> list and if you want to consider only the elements at particular index, then you can do

<pre><code>print sorted(times, key=lambda k: k.values()[0])
</code></pre>

blocks|key|3710371|text|@第四位--你的回答很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3710372|想要强调一个微妙的，海事组织的有趣的事情，为人们新的python。考虑一下第四位回答的这一点：|3710373|times+=+[{"Bob":14.05},{"Tim":15.09},{"Tim":17.01},{"Bob":16.81},{"Sarah":15.08}]
print+sorted(times,+key=lambda+k:+k.itervalues().next())|code-block|syntax|javascript|3710374|其结果是相同的：|3710375|[{'Bob':+14.05},+{'Sarah':+15.08},+{'Tim':+15.09},+{'Bob':+16.81},+{'Tim':+17.01}]|3710376|这种调整避免了中间数组和不必要数组的创建。通过使用迭代器“itervalue()”，然后只获得第一个值(通过.next())，排序方法只是比较原始值，而不是数组。|3710377|让我们来看看性能：|3710378|test_cases+=+[
++++[],
++++[{"Bob":14.05}],
++++[{"Bob":14.05},{"Tim":15.09},{"Tim":17.01},{"Bob":16.81},{"Sarah":15.08}],
++++[dict(zip((str(x)+for+x+in+xrange(50)),+random.sample(xrange(1000),+50)))]++++++#+50+dict's+in+a+list
]
print+"perf+test"
for+test_case+in+test_cases:
++++print+test_case

++++print+"k.values()+++++++++++:",+timeit.repeat(
++++++++"sorted(test_case,+key=lambda+k:+k.values())",
++++++++"from+__main__+import+test_case",
++++)
++++print+"k.itervalues().next():",+timeit.repeat(
++++++++"sorted(test_case,+key=lambda+k:+k.itervalues().next())",
++++++++"from+__main__+import+test_case",
++++)
++++print|3710379|结果：|3710380|[]
k.values()+++++++++++:+[0.7124178409576416,+0.7222259044647217,+0.7217190265655518]
k.itervalues().next():+[0.7274281978607178,+0.7140758037567139,+0.7135159969329834]

[{'Bob':+14.05}]
k.values()+++++++++++:+[1.3001079559326172,+1.395097017288208,+1.314589023590088]
k.itervalues().next():+[1.2579071521759033,+1.2594029903411865,+1.2587871551513672]

[{'Bob':+14.05},+{'Tim':+15.09},+{'Tim':+17.01},+{'Bob':+16.81},+{'Sarah':+15.08}]
k.values()+++++++++++:+[3.1186227798461914,+3.107577085494995,+3.1108040809631348]
k.itervalues().next():+[2.8267030715942383,+2.9143049716949463,+2.8211638927459717]

[{'42':+771,+'48':+129,+'43':+619,+'49':+450,+---+SNIP+---+,+'33':+162,+'32':+764}]
k.values()+++++++++++:+[1.5659689903259277,+1.6058270931243896,+1.5724899768829346]
k.itervalues().next():+[1.29836106300354,+1.2615361213684082,+1.267350196838379]|3710381|请注意，perf通常并不重要，但是考虑到这两种解决方案在可读性、表现性方面是相似的，我认为理解后一种解决方案并在这些术语中建立习惯是很好的。|3710382|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

@thefourtheye - your answer is quite nice.

Want to highlight a subtle and IMO interesting thing for folks new to python. Consider this tweak to thefourtheye's answer:

<pre><code>times = [{"Bob":14.05},{"Tim":15.09},{"Tim":17.01},{"Bob":16.81},{"Sarah":15.08}]
print sorted(times, key=lambda k: k.itervalues().next())
</code></pre>

Which yields the same result:

<pre><code>[{'Bob': 14.05}, {'Sarah': 15.08}, {'Tim': 15.09}, {'Bob': 16.81}, {'Tim': 17.01}]
</code></pre>

The tweak avoids the creation of an intermediate and unnecessary array. By using the iterator "itervalues()" and then getting just the first value (via .next()) the sort method just compares the raw value, without the array.

Let's look at performance:

<pre><code>test_cases = [
 [],
 [{"Bob":14.05}],
 [{"Bob":14.05},{"Tim":15.09},{"Tim":17.01},{"Bob":16.81},{"Sarah":15.08}],
 [dict(zip((str(x) for x in xrange(50)), random.sample(xrange(1000), 50)))] # 50 dict's in a list
]
print "perf test"
for test_case in test_cases:
 print test_case

 print "k.values() :", timeit.repeat(
 "sorted(test_case, key=lambda k: k.values())",
 "from __main__ import test_case",
 )
 print "k.itervalues().next():", timeit.repeat(
 "sorted(test_case, key=lambda k: k.itervalues().next())",
 "from __main__ import test_case",
 )
 print
</code></pre>

results:

<pre><code>[]
k.values() : [0.7124178409576416, 0.7222259044647217, 0.7217190265655518]
k.itervalues().next(): [0.7274281978607178, 0.7140758037567139, 0.7135159969329834]

[{'Bob': 14.05}]
k.values() : [1.3001079559326172, 1.395097017288208, 1.314589023590088]
k.itervalues().next(): [1.2579071521759033, 1.2594029903411865, 1.2587871551513672]

[{'Bob': 14.05}, {'Tim': 15.09}, {'Tim': 17.01}, {'Bob': 16.81}, {'Sarah': 15.08}]
k.values() : [3.1186227798461914, 3.107577085494995, 3.1108040809631348]
k.itervalues().next(): [2.8267030715942383, 2.9143049716949463, 2.8211638927459717]

[{'42': 771, '48': 129, '43': 619, '49': 450, --- SNIP --- , '33': 162, '32': 764}]
k.values() : [1.5659689903259277, 1.6058270931243896, 1.5724899768829346]
k.itervalues().next(): [1.29836106300354, 1.2615361213684082, 1.267350196838379]
</code></pre>

Mind you, perf will often not matter, but given that the 2 solutions are similar in terms of readabilty, expressiveness, I think it's good to understand the later solution, and build habits in those terms.

I have a list of single entry dictionaries. Each dictionary has only 1 key and 1 value. I'd like to sort the list of dictionaries by these values REGARDLESS of the keyname! The key names are both the same and different from dictionary to dictionary.

All of the online examples I have seen assume the same key name across dictionaries. These type of examples have not worked for me because they assume the same key value:

<pre><code>newlist = sorted(list_to_be_sorted, key=lambda k: k['name'])
</code></pre>

In my example, I need to compare the values regardless of whether the key is bob or sarah; and order the list of dictionaries. Here's an example list of dictionaries:

<pre><code>Times = [{"Bob":14.05}, {"Tim":15.09}, {"Tim":17.01}, {"Bob":16.81}, {"Sarah":15.08}]
</code></pre>

desired output:

<pre><code>[{"Bob":14.05}, {"Sarah":15.08}, {"Tim":15.09}, {"Bob":16.81}, {"Tim":1701}]
</code></pre>

Sort list of dictionaries by value, regardless of keyname in python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一份单目词典的清单。每个字典只有一个键和一个值。我想按这些值对字典列表进行排序，而不考虑键名！每个词典的关键字名称都是相同的，也是不同的。我在网上看到的所有例子都在字典中使用了相同的键名。这些类型的示例不适用于我，因为它们具有相同的键值：newlist = sorted(list_to_be_sorted, key...

问按值对字典列表进行排序，而不考虑python中的键名
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按值对字典列表进行排序，而不考虑python中的键名EN