entityMap|blocks|key|9cii6|text|标准的Python字典(Python3.6之前的版本)没有顺序，也不保证顺序。这正是创建OrderedDict的目的所在。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3agj6|如果你的字典是一个OrderedDict，你可以通过：|4e4er|import+collections

mydict+=+collections.OrderedDict()
mydict['1']+=+'one'
mydict['2']+=+'two'
mydict['3']+=+'three'

collections.OrderedDict(reversed(list(mydict.items())))|code-block|syntax|javascript|erf5d^0|18|B|0|9|B|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@$A|P|B|Q|C|D]]|E|@]|F|$]]|$2|G|4|H|6|7|8|R|9|@$A|S|B|T|C|D]]|E|@]|F|$]]|$2|I|4|J|6|K|8|U|9|@]|E|@]|F|$L|M]]|$2|N|4|-4|6|7|8|V|9|@]|E|@]|F|$]]]]

Standard Python dictionaries (Before Python 3.6) don't have an order and don't guarantee order. This is exactly what the creation of <code>OrderedDict</code> is for.

If your Dictionary was an <code>OrderedDict</code> you could reverse it via:

<pre><code>import collections

mydict = collections.OrderedDict()
mydict['1'] = 'one'
mydict['2'] = 'two'
mydict['3'] = 'three'

collections.OrderedDict(reversed(list(mydict.items())))
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://bugs.python.org/issue33462|1|https://docs.python.org/3/reference/datamodel.html#object.__reversed__|2|https://docs.python.org/3/library/collections.html#collections.OrderedDict|blocks|key|9bd8e|text|从Python+3.8及更高版本开始，items视图是可反向迭代的，因此您可以这样做：|unstyled|depth|inlineStyleRanges|entityRanges|52ev|d+=+dict(reversed(d.items()))|code-block|syntax|javascript|qsfg|在3.7和3.6中，他们还没有在dict和dict视图(issue33462:+reversible+dict)上实现__reversed__，所以使用中间的list或tuple，它们确实支持反向迭代：|offset|length|style|CODE|q84g|d+=+{3:+'three',+2:+'two',+1:+'one'}
d+=+dict(reversed(list(d.items())))|9q82f|Pre-3.6，you'd+need+collections.OrderedDict+(输入和输出)以达到预期的结果。在Python3.6(作为实现细节)和CPython+3.7+(作为语言保证)之前，普通的dicts没有保留任何顺序。|3sq6f^0|0|0|G|4|L|4|1N|C|27|4|2C|5|S|R|0|1N|C|1|0|0|J|N|2W|4|8|Y|2|0^^$0|$1|$2|3|4|5|6|$7|8]]|9|$2|3|4|5|6|$7|A]]|B|$2|3|4|5|6|$7|C]]]|D|@$E|F|G|H|2|I|J|12|K|@]|L|@]|6|$]]|$E|M|G|N|2|O|J|13|K|@]|L|@]|6|$P|Q]]|$E|R|G|S|2|I|J|14|K|@$T|15|U|16|V|W]|$T|17|U|18|V|W]|$T|19|U|1A|V|W]|$T|1B|U|1C|V|W]|$T|1D|U|1E|V|W]]|L|@$T|1F|U|1G|E|1H]|$T|1I|U|1J|E|1K]]|6|$]]|$E|X|G|Y|2|O|J|1L|K|@]|L|@]|6|$P|Q]]|$E|Z|G|10|2|I|J|1M|K|@$T|1N|U|1O|V|W]|$T|1P|U|1Q|V|W]]|L|@$T|1R|U|1S|E|1T]]|6|$]]|$E|11|G|-4|2|I|J|1U|K|@]|L|@]|6|$]]]]

Since Python 3.8 and above, the items view is iterable in reverse, so you can just do:
<pre><code>d = dict(reversed(d.items()))
</code></pre>
On 3.7 and 3.6, they hadn't gotten around to implementing <a href="https://docs.python.org/3/reference/datamodel.html#object.__reversed__" rel="nofollow noreferrer"><code>__reversed__</code></a> on <code>dict</code> and <code>dict</code> views (<a href="https://bugs.python.org/issue33462" rel="nofollow noreferrer">issue33462: reversible dict</a>), so use an intermediate <code>list</code> or <code>tuple</code>, which do support reversed iteration:
<pre><code>d = {3: 'three', 2: 'two', 1: 'one'}
d = dict(reversed(list(d.items())))
</code></pre>
Pre-3.6, <a href="https://docs.python.org/3/library/collections.html#collections.OrderedDict" rel="nofollow noreferrer">you'd need <code>collections.OrderedDict</code></a> (both for the input and the output) to achieve the desired result. Plain <code>dict</code>s did not preserve any order until CPython 3.6 (as an implementation detail) and Python 3.7 (as a language guarantee).

entityMap|blocks|key|2tmr3|text|另一个简单的解决方案，保证适用于Python+v3.7及更高版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fvp6r|d+=+{'A':'a',+'B':'b',+'C':'c',+'D':'d'}
dr+=+{k:+d[k]+for+k+in+reversed(d)}

print(dr)|code-block|syntax|javascript|a90s6|输出：|35t7k|{'D':+'d',+'C':+'c',+'B':+'b',+'A':+'a'}|d4ipm|请注意，颠倒的字典仍然被认为与其未颠倒的原始字典相等，即：|13s4j|(d+==+dr)+==+True|e3r2k|为了回应有人对这条评论的支持，我很好奇到底哪种解决方案更快。|eohd0|像往常一样，这要视情况而定。使用对条目使用list和reversed的解决方案，对10,000个条目字典进行10,000次反向查询会更快。但是，将100万个条目的词典倒排100次(即总倒排词典中相同数量的条目，只是更大的起始词典)，理解起来会更快--它留给读者来找到翻转的确切位置。如果您处理的是大型字典，如果性能很重要，您可能希望进行基准测试：|offset|length|style|CODE|9dhvd|from+random+import+randint
from+timeit+import+timeit


def+f1(d):
++++return+dict(reversed(list(d.items())))


def+f2(d):
++++return+{k:+d[k]+for+k+in+reversed(d)}


def+compare(n):
++++d+=+{i:+randint(1,+100)+for+i+in+range(n)}
++++print(timeit(lambda:+f1(d),+number=100000000+//+n))
++++print(timeit(lambda:+f2(d),+number=100000000+//+n))


compare(10000)
compare(1000000)|cd8mn|结果(一次运行，典型结果)：|eqp73|4.1554735
4.7047593
8.750093200000002
6.7306311|a502t^0|0|0|0|0|0|0|0|L|4|Q|8|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|14|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|15|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|16|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|17|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|18|9|@]|A|@]|B|$]]|$2|N|4|O|6|E|8|19|9|@]|A|@]|B|$F|G]]|$2|P|4|Q|6|7|8|1A|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|1B|9|@$T|1C|U|1D|V|W]|$T|1E|U|1F|V|W]]|A|@]|B|$]]|$2|X|4|Y|6|E|8|1G|9|@]|A|@]|B|$F|G]]|$2|Z|4|10|6|7|8|1H|9|@]|A|@]|B|$]]|$2|11|4|12|6|E|8|1I|9|@]|A|@]|B|$F|G]]|$2|13|4|-4|6|7|8|1J|9|@]|A|@]|B|$]]]]

Another straightforward solution, which is guaranteed to work for Python v3.7 and over:
<pre><code>d = {'A':'a', 'B':'b', 'C':'c', 'D':'d'}
dr = {k: d[k] for k in reversed(d)}

print(dr)
</code></pre>
Output:
<pre><code>{'D': 'd', 'C': 'c', 'B': 'b', 'A': 'a'}
</code></pre>
Note that reversed dictionaries are still considered equal to their unreversed originals, i.e.:
<pre><code>(d == dr) == True
</code></pre>
In response to someone upvoting this comment, I was curious to see which solution is actually faster.
As usual, it depends. Reversing a 10,000 item dictionary 10,000 times is faster with the solution using <code>list</code> and <code>reversed</code> on the items. But reversing a 1,000,000 item dictionary 100 times (i.e. the same number of items in total reversed dictionaries, just a bigger starting dictionary) is faster with the comprehension - it's left up to the reader to find the exact point where it flips. If you deal with large dictionaries, you may want to benchmark either if performance matters:
<pre><code>from random import randint
from timeit import timeit


def f1(d):
 return dict(reversed(list(d.items())))


def f2(d):
 return {k: d[k] for k in reversed(d)}


def compare(n):
 d = {i: randint(1, 100) for i in range(n)}
 print(timeit(lambda: f1(d), number=100000000 // n))
 print(timeit(lambda: f2(d), number=100000000 // n))


compare(10000)
compare(1000000)
</code></pre>
Results (one run, typical results):
<pre><code>4.1554735
4.7047593
8.750093200000002
6.7306311
</code></pre>

Assume I have a dictionary:

<pre><code>d = {3: 'three', 2: 'two', 1: 'one'}
</code></pre>

I want to rearrange the order of this dictionary so that the dictionary is:

<pre><code>d = {1: 'one', 2: 'two', 3: 'three'}
</code></pre>

I was thinking something like the <code>reverse()</code> function for lists, but that did not work. Thanks in advance for your answers!

Python reverse dictionary items order

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

 假设我有一本字典： d = {3: 'three', 2: 'two', 1: 'one'} 我想重新排列这个字典的顺序，这样字典就是： d = {1: 'one', 2: 'two', 3: 'three'} 我在考虑类似于列表的reverse()函数，但这并不起作用。提前感谢你的回答！ 

问Python反向字典项顺序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python反向字典项顺序EN