ฉันจะเรียงลำดับพจนานุกรมตามคีย์ได้อย่างไร

สิ่งที่จะเป็นวิธีที่ดีที่จะไปจาก{2:3, 1:89, 4:5, 3:0}ไป{1:89, 2:3, 3:0, 4:5}?
ฉันตรวจสอบบางโพสต์ แต่พวกเขาทั้งหมดใช้ตัวดำเนินการ "เรียงลำดับ" ที่ส่งคืนทูเปิล

พจนานุกรม Python มาตรฐานไม่มีการเรียงลำดับ แม้ว่าคุณจะเรียงลำดับคู่ (คีย์, ค่า) คุณจะไม่สามารถเก็บพวกเขาใน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

พจนานุกรมไม่มีคำสั่งซื้อสินค้าเช่นนี้หากคุณต้องการพิมพ์ ฯลฯ ในบางคำสั่งต่อไปนี้เป็นตัวอย่าง:

ใน 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/

จากเอกสารห้องสมุดของ Pythoncollections :

>>> 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)])

สำหรับ 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}

มีโมดูล Python จำนวนหนึ่งที่ให้การปรับใช้พจนานุกรมที่ดูแลรักษาคีย์โดยอัตโนมัติตามลำดับที่เรียงลำดับ พิจารณาโมดูลsortcontainersซึ่งเป็น pure-Python และ fast-as-C นอกจากนี้ยังมีการเปรียบเทียบประสิทธิภาพกับตัวเลือกยอดนิยมอื่น ๆเปรียบเทียบกับตัวเลือกอื่น

การใช้ dict ที่สั่งซื้อเป็นวิธีการแก้ปัญหาที่ไม่เพียงพอหากคุณต้องการเพิ่มและลบคู่ของคีย์ / ค่าอย่างต่อเนื่องขณะเดียวกัน

>>> 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])

เพียง:

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

for k,v in sd:
    print k, v

เอาท์พุท:

1 89
2 3
3 0
4 5

อย่างที่คนอื่นพูดถึง อย่างไรก็ตามหากปัญหาเพียงแสดงพจนานุกรมตามลำดับที่สั่งซื้อคุณสามารถแทนที่__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

พบวิธีอื่น:

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

upd:
1. สิ่งนี้จะเรียงลำดับวัตถุที่ซ้อนกัน (ขอบคุณ @DanielF)
2. พจนานุกรมภาษาไพ ธ อนไม่ได้เรียงลำดับดังนั้นนี่จึงเป็นที่น่าเชื่อถือสำหรับการพิมพ์หรือมอบหมายให้กับ STR เท่านั้น

ใน Python 3

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

จะช่วยให้

1 89
2 3
3 0
4 5

พจนานุกรม Python ไม่ได้เรียงลำดับก่อน Python 3.6 ในการใช้งาน CPython ของ Python 3.6 พจนานุกรมจะเก็บลำดับการแทรกไว้ จาก Python 3.7 สิ่งนี้จะกลายเป็นคุณสมบัติภาษา

ในการเปลี่ยนแปลงของ Python 3.6 ( https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict ):

ด้านการรักษาลำดับของการใช้งานใหม่นี้ถือว่าเป็นรายละเอียดการใช้งานและไม่ควรพึ่งพา (อาจเปลี่ยนแปลงได้ในอนาคต แต่เป็นที่ต้องการที่จะมีการใช้งาน dict ใหม่นี้ในภาษาสำหรับรุ่นไม่กี่ก่อนที่จะเปลี่ยนข้อมูลจำเพาะภาษา เพื่อมอบอำนาจความหมายเพื่อรักษาคำสั่งซื้อสำหรับการใช้งาน Python ปัจจุบันและอนาคตทั้งหมดนี้ยังช่วยรักษาความเข้ากันได้ย้อนหลังกับภาษารุ่นเก่าที่คำสั่งการสุ่มซ้ำยังคงมีผลเช่น Python 3.5)

ในเอกสารของ Python 3.7 ( https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries ):

การแสดงรายการ (d) ในพจนานุกรมจะส่งคืนรายการของคีย์ทั้งหมดที่ใช้ในพจนานุกรมตามลำดับการแทรก (หากคุณต้องการให้เรียงเพียงใช้ sort (d) แทน)

ซึ่งแตกต่างจากเวอร์ชั่นก่อนหน้านี้คุณสามารถจัดเรียง dict หลังจาก Python 3.6 / 3.7 หากคุณต้องการเรียงลำดับ dict ซ้อนกันรวมถึง sub-dict ภายในคุณสามารถทำได้:

test_dict = {'a': 1, 'c': 3, 'b': {'b2': 2, 'b1': 1}}

def dict_reorder(item):
    return {k: sort_dict(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

ที่นี่ผมพบว่าบางวิธีที่ง่ายที่สุดในการจัดเรียง Dict 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}

มีวิธีที่ง่ายในการจัดเรียงพจนานุกรม

ตามคำถามของคุณ

ทางออกคือ:

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)]

ดังนั้นโดยการเปลี่ยนเป็นคีย์ค่าและรายการคุณสามารถพิมพ์เหมือนสิ่งที่คุณต้องการความช่วยเหลือนี้!

จะสร้างสิ่งที่คุณต้องการ:

 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}

แต่นี่ไม่ใช่วิธีที่ถูกต้องในการทำเช่นนี้เพราะมันสามารถแสดงพฤติกรรมที่แตกต่างกับพจนานุกรมต่าง ๆ ซึ่งฉันได้เรียนรู้เมื่อเร็ว ๆ นี้ ดังนั้นวิธีที่สมบูรณ์แบบได้รับการแนะนำโดยทิมในการตอบสนองของแบบสอบถามของฉันซึ่งฉันกำลังแบ่งปันที่นี่

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

ฉันคิดว่าสิ่งที่ง่ายที่สุดคือการจัดเรียง dict ตามคีย์และบันทึกคีย์ที่เรียง: คู่ค่าใน dict ใหม่

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

คุณสามารถสร้างพจนานุกรมใหม่ได้โดยเรียงลำดับพจนานุกรมปัจจุบันตามรหัสตามคำถามของคุณ

นี่คือพจนานุกรมของคุณ

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

สร้างพจนานุกรมใหม่ d1 โดยจัดเรียง d นี้โดยใช้ฟังก์ชั่นแลมบ์ดา

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

d1 ควรเป็น {1: 89, 2: 3, 3: 0, 4: 5}, เรียงลำดับตามคีย์ใน d

Pic dicts นั้นไม่ได้ทำการสั่งซื้อ โดยทั่วไปแล้วนี่ไม่ใช่ปัญหาเนื่องจากกรณีการใช้งานที่พบบ่อยที่สุดคือทำการค้นหา

วิธีที่ง่ายที่สุดในการทำสิ่งที่คุณต้องการคือการสร้าง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())]

ฉันมาพร้อมกับการเรียงลำดับบรรทัดเดียว

>> 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]

หวังว่านี่จะเป็นประโยชน์

ฟังก์ชั่นนี้จะเรียงลำดับพจนานุกรมใด ๆซ้ำโดยคีย์ นั่นคือถ้าค่าใด ๆ ในพจนานุกรมเป็นพจนานุกรมด้วยก็จะถูกจัดเรียงตามคีย์ หากคุณกำลังทำงานอยู่บน CPython 3.6 หรือสูงกว่าการเปลี่ยนแปลงง่ายที่จะใช้dictมากกว่า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)

พวกคุณกำลังทำสิ่งที่ซับซ้อน ... มันง่ายมาก

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

ผลลัพธ์คือ:

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

วิธีที่ง่ายที่สุดคือคุณควรจะได้รับรายการของคีย์ dict เรียงลำดับแล้ววนซ้ำ dict ตัวอย่างเช่น

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

วิธีง่ายๆในการทำสิ่งนี้:

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} 

การเปรียบเทียบเวลาของทั้งสองวิธีใน 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\n"
>>> setup_string += "a = OrderedDict({1:89, 2:3, 3:0, 4:5})\n"
>>> setup_string += "b = a.items()"
>>> timeit.timeit(stmt="[(k, val) for k, val in b]", setup=setup_string, number=10000)
0.003581275490432745 

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)

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]}

หรือการใช้งาน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}
>>> 

ดู:

เอกสารนี้

เอกสารของแพนด้าทั้งหมด

ข้อเสนอแนะของฉันคือสิ่งนี้เพราะมันช่วยให้คุณสามารถเรียงลำดับจากคำสั่งหรือเก็บเรียงตามคำบอกในขณะที่คุณกำลังเพิ่มรายการและอาจจำเป็นต้องเพิ่มรายการในอนาคต:

สร้างdictจากขั้นตอนที่คุณไป มีโครงสร้างข้อมูลที่สองรายการพร้อมกับรายการคีย์ของคุณ แพคเกจ bisect มีฟังก์ชั่น insort ซึ่งช่วยให้สามารถแทรกลงในรายการเรียงลำดับหรือเรียงลำดับรายการของคุณหลังจากเติม dict ของคุณอย่างสมบูรณ์ ตอนนี้เมื่อคุณวนซ้ำ dict ของคุณคุณจะวนซ้ำรายการเพื่อเข้าถึงแต่ละคีย์ตามลำดับโดยไม่ต้องกังวลกับการแสดงโครงสร้าง dict (ซึ่งไม่ได้ทำการเรียงลำดับ)

l = dict.keys()
l2 = l
l2.append(0)
l3 = []
for repeater in range(0, len(l)):
    smallnum = float("inf")
    for listitem in l2:
        if listitem < smallnum:
            smallnum = listitem
    l2.remove(smallnum)
    l3.append(smallnum)
l3.remove(0)
l = l3

for listitem in l:
    print(listitem)