如何按键对字典进行排序？-IT科技

摘要：问题描述：如何按键对字典进行排序？示例输入：{2:3, 1:89, 4:5, 3:0} 期望输出：{1:89, 2:3, 3:0, 4:5} 解决方案 1：注意：对于 Python 3.7+，请参阅此答案标准 Python 字典是无序的（直到 Python 3.7）。即使您对 (key,value) 对进行了...

问题描述：

如何按键对字典进行排序？

示例输入：

{2:3, 1:89, 4:5, 3:0}

期望输出：

{1:89, 2:3, 3:0, 4:5}

解决方案 1：

注意：对于 Python 3.7+，请参阅此答案

标准 Python 字典是无序的（直到 Python 3.7）。即使您对 (key,value) 对进行了排序，您也无法以dict保留顺序的方式存储它们。

最简单的方法是使用OrderedDict，它会记住元素插入的顺序：

In [1]: import collections

In [2]: d = {2:3, 1:89, 4:5, 3:0}

In [3]: od = collections.OrderedDict(sorted(d.items()))

In [4]: od
Out[4]: OrderedDict([(1, 89), (2, 3), (3, 0), (4, 5)])

od不用担心打印出来的方法；它会按预期工作：

In [11]: od[1]
Out[11]: 89

In [12]: od[3]
Out[12]: 0

In [13]: for k, v in od.iteritems(): print k, v
   ....: 
1 89
2 3
3 0
4 5

Python 3

对于 Python 3 用户，需要使用.items()而不是.iteritems()：

In [13]: for k, v in od.items(): print(k, v)
   ....: 
1 89
2 3
3 0
4 5

解决方案 2：

对于 CPython/PyPy 3.6 以及任何 Python 3.7 或更高版本，可以通过以下方式轻松完成：

>>> d = {2:3, 1:89, 4:5, 3:0}
>>> dict(sorted(d.items()))
{1: 89, 2: 3, 3: 0, 4: 5}

解决方案 3：

字典本身并没有有序的项目，如果您想按照某种顺序打印它们，这里有一些例子：

在 Python 2.4 及更高版本中：

mydict = {'carl':40,
          'alan':2,
          'bob':1,
          'danny':3}

for key in sorted(mydict):
    print "%s: %s" % (key, mydict[key])

给出：

alan: 2
bob: 1
carl: 40
danny: 3

（Python 2.4 以下：）

keylist = mydict.keys()
keylist.sort()
for key in keylist:
    print "%s: %s" % (key, mydict[key])

来源： http: //www.saltycrane.com/blog/2007/09/how-to-sort-python-dictionary-by-keys/

解决方案 4：

来自Python的collections库文档：

>>> from collections import OrderedDict

>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

>>> # dictionary sorted by key -- OrderedDict(sorted(d.items()) also works
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

>>> # dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

解决方案 5：

有许多 Python 模块提供字典实现，可自动保持键的排序顺序。考虑使用sortedcontainers模块，它是纯 Python 和快速的 C 实现。还与其他流行选项进行了性能比较，并相互进行了基准测试。

如果您需要在迭代的同时不断添加和删除键/值对，则使用有序字典是一个不充分的解决方案。

>>> from sortedcontainers import SortedDict
>>> d = {2:3, 1:89, 4:5, 3:0}
>>> s = SortedDict(d)
>>> s.items()
[(1, 89), (2, 3), (3, 0), (4, 5)]

SortedDict 类型还支持索引位置查找和删除，这是内置 dict 类型无法实现的。

>>> s.iloc[-1]
4
>>> del s.iloc[2]
>>> s.keys()
SortedSet([1, 2, 4])

解决方案 6：

简单地：

d = {2:3, 1:89, 4:5, 3:0}
sd = sorted(d.items())

for k,v in sd:
    print k, v

输出：

解决方案 7：

在 Python 3.6 之前，Python 字典是无序的。在 Python 3.6 的 CPython 实现中，字典保持插入顺序。从 Python 3.7 开始，这将成为一种语言特性。

在 Python 3.6 的更新日志中（https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict）：

此新实现的保序方面被视为实现细节，不应依赖（这可能会在未来发生变化，但希望在更改语言规范以强制所有当前和未来的 Python 实现都使用保序语义之前，在该语言的几个版本中拥有这个新的字典实现；这也有助于保持与旧版本的语言的向后兼容性，其中随机迭代顺序仍然有效，例如 Python 3.5）。

在 Python 3.7 的文档中（https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries）：

在字典上执行 list(d)将按插入顺序返回字典中使用的所有键的列表（如果希望对其进行排序，只需使用 sorted(d) 即可）。

因此与以前的版本不同，你可以在 Python 3.6/3.7 之后对字典进行排序。如果你想对包含内部子字典的嵌套字典进行排序，你可以执行以下操作：

test_dict = {'a': 1, 'c': 3, 'b': {'b2': 2, 'b1': 1}}
    
def dict_reorder(item):
    return {k: dict_reorder(v) if isinstance(v, dict) else v for k, v in sorted(item.items())}
    
reordered_dict = dict_reorder(test_dict)

https://gist.github.com/ligyxy/f60f0374defc383aa098d44cfbd318eb

解决方案 8：

找到了另一种方法：

import json
print json.dumps(d, sort_keys = True)

更新：

这也会排序嵌套对象（感谢@DanielF）。2

. python 字典是无序的，因此这仅适用于打印或分配给 str。

解决方案 9：

正如其他人提到的，字典本质上是无序的。但是，如果问题仅仅是以有序的方式显示__str__字典，则可以在字典子类中重写该方法，并使用此字典类而不是内置的字典类dict。例如。

class SortedDisplayDict(dict):
   def __str__(self):
       return "{" + ", ".join("%r: %r" % (key, self[key]) for key in sorted(self)) + "}"


>>> d = SortedDisplayDict({2:3, 1:89, 4:5, 3:0})
>>> d
{1: 89, 2: 3, 3: 0, 4: 5}

请注意，这不会改变键的存储方式、对它们进行迭代时它们返回的顺序等，只会改变它们print在 python 控制台中的显示方式。

解决方案 10：

这里已经有很多答案展示了对 Python 字典进行排序的流行方法。我想为那些从 Google 来这里寻找非标准想法的人添加一些不太明显的方法。

示例词典：d = {2: 'c', 1: 'b', 0: 'a', 3: 'd'}

词典理解

# Converts to list, sorts, re-converts to dict
{k: v for k, v in sorted(list(d.items()))}

使用 Lambda

排序并不总是严格按照升序或降序排列。如需更多条件排序，请结合使用上述方法和 lamdas：

{k: v for k, v in sorted(d.items(), key=lambda v: ord(v[1]))}

解决方案 11：

一个简单的方法：

d = {2:3, 1:89, 4:5, 3:0}

s = {k : d[k] for k in sorted(d)}

s

Out[1]: {1: 89, 2: 3, 3: 0, 4: 5}

解决方案 12：

在 Python 3 中。

>>> D1 = {2:3, 1:89, 4:5, 3:0}
>>> for key in sorted(D1):
    print (key, D1[key])

给出

解决方案 13：

我发现对字典进行排序的一种简单方法是根据要排序的字典的已排序键值项创建一个新字典。如果要排序dict = {}，请使用相关方法检索其所有项目，使用sorted()函数对其进行排序，然后创建新字典。

以下是使用字典理解的代码：

sorted_dict = {k:v for k,v in sorted(dict.items())}

解决方案 14：

您可以根据您的问题，按键对当前词典进行排序来创建新词典。

这是你的字典

d = {2:3, 1:89, 4:5, 3:0}

使用 lambda 函数对 d 进行排序，创建一个新的字典 d1

d1 = dict(sorted(d.items(), key = lambda x:x[0]))

d1 应该是 {1: 89, 2: 3, 3: 0, 4: 5}，根据 d 中的键排序。

解决方案 15：

有一种对字典进行排序的简单方法。

根据您的问题，

解决方案是：

c={2:3, 1:89, 4:5, 3:0}
y=sorted(c.items())
print y

（其中 c 是您的字典名称。）

该程序给出以下输出：

[(1, 89), (2, 3), (3, 0), (4, 5)]

就像你想要的那样。

另一个例子是：

d={"John":36,"Lucy":24,"Albert":32,"Peter":18,"Bill":41}
x=sorted(d.keys())
print x

给出输出：['Albert', 'Bill', 'John', 'Lucy', 'Peter']

y=sorted(d.values())
print y

给出输出：[18, 24, 32, 36, 41]

z=sorted(d.items())
print z

给出输出：

[('Albert', 32), ('Bill', 41), ('John', 36), ('Lucy', 24), ('Peter', 18)]

因此，通过将其更改为键、值和项目，您可以按照需要进行打印。希望这会有所帮助！

解决方案 16：

在这里，我找到了一些最简单的解决方案，使用 . 例如按键对 python 字典进行排序pprint。

>>> x = {'a': 10, 'cd': 20, 'b': 30, 'az': 99} 
>>> print x
{'a': 10, 'b': 30, 'az': 99, 'cd': 20}

但使用 pprint 时它将返回已排序的字典

>>> import pprint 
>>> pprint.pprint(x)
{'a': 10, 'az': 99, 'b': 30, 'cd': 20}

解决方案 17：

以下是建议解决方案的表现：

from collections import OrderedDict
from sortedcontainers import SortedDict
import json

keys = np.random.rand(100000)
vals = np.random.rand(100000)

d = dict(zip(keys, vals))

timeit SortedDict(d)
#45.8 ms ± 780 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit sorted(d.items())
#91.9 ms ± 707 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit OrderedDict(sorted(d.items(), key=lambda x: x[0]))
#93.7 ms ± 1.52 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit dict(sorted(dic.items()))
#113 ms ± 824 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit OrderedDict(sorted(dic.items()))
#122 ms ± 2.65 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit json.dumps(d, sort_keys=True)
#259 ms ± 9.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

如我们所见，Grant Jenks 的解决方案是迄今为止最快的。

解决方案 18：

将生成您想要的内容：

 D1 = {2:3, 1:89, 4:5, 3:0}

 sort_dic = {}

 for i in sorted(D1):
     sort_dic.update({i:D1[i]})
 print sort_dic


{1: 89, 2: 3, 3: 0, 4: 5}

但这不是正确的做法，因为，不同的字典可能会表现出不同的行为，这是我最近才知道的。因此，Tim 在我的查询回复中提出了完美的方法，我在这里分享。

from collections import OrderedDict
sorted_dict = OrderedDict(sorted(D1.items(), key=lambda t: t[0]))

解决方案 19：

从 Python 3.7 开始，字典排序变得更加容易。

要根据字典的键对其进行排序，只需执行

dict(sorted(my_dict.items(), key=lambda x: x[0]))

要根据字典的值对其进行排序，只需执行

dict(sorted(my_dict.items(), key=lambda x: x[1]))

上述两个命令都将返回一本字典。

解决方案 20：

我认为最简单的方法是按键对字典进行排序，然后将排序后的键：值对保存在新的字典中。

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be neccessary
        dict2[key] = dict1[key]

为了更清楚起见：

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted     values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be  neccessary
        value = dict1[key]
        dict2[key] = value

解决方案 21：

我想出了单行字典排序。

>> a = {2:3, 1:89, 4:5, 3:0}
>> c = {i:a[i] for i in sorted(a.keys())}
>> print(c)
{1: 89, 2: 3, 3: 0, 4: 5}
[Finished in 0.4s]

希望这会有所帮助。

解决方案 22：

Python 字典是无序的。通常，这不是问题，因为最常见的用例是进行查找。

实现您想要的操作的最简单方法是创建一个collections.OrderedDict按排序顺序插入元素。

ordered_dict = collections.OrderedDict([(k, d[k]) for k in sorted(d.keys())])

如果需要迭代，正如上面其他人所建议的那样，最简单的方法就是迭代已排序的键。示例-

打印按键排序的值：

# create the dict
d = {k1:v1, k2:v2,...}
# iterate by keys in sorted order
for k in sorted(d.keys()):
    value = d[k]
    # do something with k, value like print
    print k, value

获取按键排序的值列表：

values = [d[k] for k in sorted(d.keys())]

解决方案 23：

此函数将按其键递归地对任何字典进行排序。也就是说，如果字典中的任何值也是字典，它也将按其键排序。如果您在 CPython 3.6 或更高版本上运行，则可以进行简单的更改以使用 adict而不是 an 。OrderedDict

from collections import OrderedDict

def sort_dict(d):
    items = [[k, v] for k, v in sorted(d.items(), key=lambda x: x[0])]
    for item in items:
        if isinstance(item[1], dict):
            item[1] = sort_dict(item[1])
    return OrderedDict(items)
    #return dict(items)

解决方案 24：

最简单的解决方案是，你应该获取一个按排序顺序排列的字典列表，然后对字典进行迭代。例如

a1 = {'a':1, 'b':13, 'd':4, 'c':2, 'e':30}
a1_sorted_keys = sorted(a1, key=a1.get, reverse=True)
for r in a1_sorted_keys:
    print r, a1[r]

以下是输出（降序）

e 30
b 13
d 4
c 2
a 1

解决方案 25：

你们把事情搞复杂了...其实很简单

from pprint import pprint
Dict={'B':1,'A':2,'C':3}
pprint(Dict)

输出为：

{'A':2,'B':1,'C':3}

解决方案 26：

对于问题的表述方式，这里的大多数答案都回答正确。

然而，考虑到事情应该如何真正完成，考虑到几十年的计算机科学，我完全惊讶地发现这里实际上只有一个答案（来自GrantJ用户）建议使用排序关联容器（sortedcontainers）它根据插入点的键对元素进行排序。

这样可以避免每次调用对性能造成巨大sort(...)影响（至少O(N*log(N))，其中N元素数量为（逻辑上，这适用于所有建议使用的解决方案sort(...)）。考虑到对于所有此类解决方案，每次需要在通过添加/删除元素修改集合后sort(...)以排序形式访问集合时，都需要调用...

解决方案 27：

from operator import itemgetter
# if you would like to play with multiple dictionaries then here you go:
# Three dictionaries that are composed of first name and last name.
user = [
    {'fname': 'Mo', 'lname': 'Mahjoub'},
    {'fname': 'Abdo', 'lname': 'Al-hebashi'},
    {'fname': 'Ali', 'lname': 'Muhammad'}
]
#  This loop will sort by the first and the last names.
# notice that in a dictionary order doesn't matter. So it could put the first name first or the last name first. 
for k in sorted (user, key=itemgetter ('fname', 'lname')):
    print (k)

# This one will sort by the first name only.
for x in sorted (user, key=itemgetter ('fname')):
    print (x)

解决方案 28：

dictionary = {1:[2],2:[],5:[4,5],4:[5],3:[1]}

temp=sorted(dictionary)
sorted_dict = dict([(k,dictionary[k]) for i,k in enumerate(temp)])

sorted_dict:
         {1: [2], 2: [], 3: [1], 4: [5], 5: [4, 5]}

解决方案 29：

2.7 中的两种方法的时间比较表明它们实际上是相同的：

>>> setup_string = "a = sorted(dict({2:3, 1:89, 4:5, 3:0}).items())"
>>> timeit.timeit(stmt="[(k, val) for k, val in a]", setup=setup_string, number=10000)
0.003599141953657181

>>> setup_string = "from collections import OrderedDict
"
>>> setup_string += "a = OrderedDict({1:89, 2:3, 3:0, 4:5})
"
>>> setup_string += "b = a.items()"
>>> timeit.timeit(stmt="[(k, val) for k, val in b]", setup=setup_string, number=10000)
0.003581275490432745

解决方案 30：

或者使用pandas，

演示：

>>> d={'B':1,'A':2,'C':3}
>>> df=pd.DataFrame(d,index=[0]).sort_index(axis=1)
   A  B  C
0  2  1  3
>>> df.to_dict('int')[0]
{'A': 2, 'B': 1, 'C': 3}
>>>

看：

此文档
大熊猫全记录