ฉันมีพจนานุกรมของค่าที่อ่านจากสองฟิลด์ในฐานข้อมูล: ฟิลด์สตริงและฟิลด์ตัวเลข เขตข้อมูลสตริงไม่ซ้ำกันดังนั้นจึงเป็นกุญแจสำคัญของพจนานุกรม

ฉันสามารถเรียงลำดับคีย์ได้ แต่ฉันจะเรียงลำดับตามค่าได้อย่างไร

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

Python 3.6+

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
{k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

Python ที่เก่ากว่า

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

ตัวอย่างเช่น

import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(1))

sorted_xจะเป็นรายการของ tuples เรียงตามองค์ประกอบที่สองในแต่ละ tuple dict(sorted_x) == x.

และสำหรับผู้ที่ต้องการเรียงลำดับกุญแจแทนที่จะเป็นค่า:

import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(0))

ใน Python3 เนื่องจากไม่อนุญาตให้นำของออกจากบรรจุภัณฑ์[1]เราสามารถใช้ได้

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=lambda kv: kv[1])

หากคุณต้องการเอาต์พุตเป็น dict คุณสามารถใช้collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

ง่ายเหมือน: sorted(dict1, key=dict1.get)

จริง ๆ แล้วมันเป็นไปได้ที่จะทำการ "เรียงตามค่าพจนานุกรม" เมื่อเร็ว ๆ นี้ฉันต้องทำเช่นนั้นใน Code Golf (Stack Overflow question code golf: แผนภูมิความถี่ของ Word ) โดยสังเขปปัญหาเป็นของชนิด: รับข้อความนับความถี่ที่แต่ละคำจะพบและแสดงรายการของคำด้านบนเรียงลำดับตามความถี่ลดลง

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

from collections import defaultdict
d = defaultdict(int)
for w in text.split():
    d[w] += 1

จากนั้นคุณจะได้รับรายการคำสั่งตามความถี่ในการใช้งานด้วย sorted(d, key=d.get) - การเรียงลำดับจะทำซ้ำผ่านแป้นพจนานุกรมโดยใช้จำนวนคำที่เกิดขึ้นเป็นคีย์การเรียงลำดับ

for w in sorted(d, key=d.get, reverse=True):
    print(w, d[w])

ฉันกำลังเขียนคำอธิบายโดยละเอียดนี้เพื่อแสดงให้เห็นว่าผู้คนมักจะหมายถึง "ฉันสามารถเรียงลำดับพจนานุกรมตามคีย์ได้อย่างง่ายดาย แต่ฉันจะเรียงลำดับตามค่า" ได้อย่างไร - และฉันคิดว่าโพสต์ต้นฉบับพยายามแก้ไขปัญหาดังกล่าว และการแก้ปัญหาคือการเรียงลำดับรายการคีย์ตามค่าที่แสดงด้านบน

คุณสามารถใช้:

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

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

หากต้องการจัดเรียงตามลำดับจากมากไปน้อยเพียงเพิ่มreverse=True:

sorted(d.items(), key=lambda x: x[1], reverse=True)

การป้อนข้อมูล:

d = {'one':1,'three':3,'five':5,'two':2,'four':4}
a = sorted(d.items(), key=lambda x: x[1])    
print(a)

เอาท์พุท:

[('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]

ไม่สามารถจัดเรียง Dicts ได้ แต่คุณสามารถสร้างรายการที่เรียงลำดับได้

รายการเรียงลำดับของค่า dict:

sorted(d.values())

รายการคู่ (คีย์, ค่า), เรียงลำดับตามค่า:

from operator import itemgetter
sorted(d.items(), key=itemgetter(1))

ใน Python 2.7 ล่าสุดเรามีประเภทOrderedDictใหม่ซึ่งจะจดจำคำสั่งที่เพิ่มรายการ

>>> d = {"third": 3, "first": 1, "fourth": 4, "second": 2}

>>> for k, v in d.items():
...     print "%s: %s" % (k, v)
...
second: 2
fourth: 4
third: 3
first: 1

>>> d
{'second': 2, 'fourth': 4, 'third': 3, 'first': 1}

หากต้องการสร้างพจนานุกรมที่เรียงลำดับใหม่จากต้นฉบับให้เรียงตามค่า:

>>> from collections import OrderedDict
>>> d_sorted_by_value = OrderedDict(sorted(d.items(), key=lambda x: x[1]))

OrderedDict ทำงานเหมือน dict ปกติ:

>>> for k, v in d_sorted_by_value.items():
...     print "%s: %s" % (k, v)
...
first: 1
second: 2
third: 3
fourth: 4

>>> d_sorted_by_value
OrderedDict([('first': 1), ('second': 2), ('third': 3), ('fourth': 4)])

อัปเดต: 5 ธันวาคม 2015 โดยใช้ Python 3.5

ในขณะที่ฉันพบว่าคำตอบที่ได้รับการยอมรับมีประโยชน์ฉันก็ประหลาดใจที่ไม่ได้รับการอัปเดตเพื่ออ้างอิงOrderedDictจากคอลเล็กชันไลบรารีมาตรฐานโมดูลในฐานะทางเลือกที่ทันสมัยและทันสมัย ​​- ออกแบบมาเพื่อแก้ไขปัญหาประเภทนี้

from operator import itemgetter
from collections import OrderedDict

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = OrderedDict(sorted(x.items(), key=itemgetter(1)))
# OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

เอกสารOrderedDictอย่างเป็นทางการนำเสนอตัวอย่างที่คล้ายกันมาก แต่การใช้แลมบ์ดาสำหรับฟังก์ชั่นการเรียงลำดับ:

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

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

ค่อนข้างเหมือนกับคำตอบของแฮงค์เกย์ :

sorted([(value,key) for (key,value) in mydict.items()])

หรือปรับให้เหมาะสมเล็กน้อยตามคำแนะนำของ John Fouhy:

sorted((value,key) for (key,value) in mydict.items())

มันก็มักจะมีประโยชน์มากที่จะใช้namedtuple ตัวอย่างเช่นคุณมีพจนานุกรมชื่อ 'เป็นกุญแจและ' คะแนน 'เป็นค่าและคุณต้องการเรียงลำดับตาม' คะแนน ':

import collections
Player = collections.namedtuple('Player', 'score name')
d = {'John':5, 'Alex':10, 'Richard': 7}

เรียงลำดับด้วยคะแนนต่ำสุดก่อน:

worst = sorted(Player(v,k) for (k,v) in d.items())

เรียงลำดับด้วยคะแนนสูงสุดก่อน:

best = sorted([Player(v,k) for (k,v) in d.items()], reverse=True)

ตอนนี้คุณสามารถได้รับชื่อและคะแนนของสมมติว่าผู้เล่นที่ดีที่สุดอันดับที่สอง (ดัชนี = 1) Pythonically แบบนี้มาก:

player = best[1]
player.name
    'Richard'
player.score
    7

ตั้งแต่Python 3.6คำสั่งในตัวจะได้รับคำสั่ง

ข่าวดีดังนั้นกรณีการใช้งานดั้งเดิมของ OP ของการจับคู่คู่ที่ดึงมาจากฐานข้อมูลที่มีรหัสสตริงที่ไม่ซ้ำกันเป็นคีย์และค่าตัวเลขเป็นค่าใน Python v3.6 + dict ในตัวตอนนี้ควรเคารพคำสั่งแทรก

หากกล่าวว่าเป็นนิพจน์ตารางคอลัมน์ที่เป็นผลลัพธ์สองรายการจากแบบสอบถามฐานข้อมูลเช่น:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

จะถูกเก็บไว้ใน Python tuples สองรายการคือ k_seq และ v_seq (จัดเรียงตามดัชนีตัวเลขและมีความยาวเท่ากันแน่นอน) จากนั้น:

k_seq = ('foo', 'bar', 'baz')
v_seq = (0, 1, 42)
ordered_map = dict(zip(k_seq, v_seq))

อนุญาตให้ส่งออกในภายหลังเป็น:

for k, v in ordered_map.items():
    print(k, v)

ให้ผลในกรณีนี้ (สำหรับ Pict 3.6 บิ ธ ในตัวใหม่!):

foo 0
bar 1
baz 42

ในการเรียงลำดับเดียวกันต่อมูลค่าของ v

ตำแหน่งที่ติดตั้ง Python 3.5 บนเครื่องของฉันมีอยู่ในปัจจุบัน:

bar 1
foo 0
baz 42

รายละเอียด:

ตามที่เสนอในปี 2012 โดย Raymond Hettinger (เทียบกับอีเมลใน python-dev กับหัวเรื่อง"พจนานุกรมขนาดกะทัดรัดที่มีการวนซ้ำเร็วขึ้น" ) และตอนนี้ (ในปี 2559) ประกาศโดย Victor Stinner ไปยัง python-dev กับหัวเรื่อง"Python 3.6 dict กระชับและรับรุ่นส่วนตัวและคำหลักจะกลายเป็นคำสั่ง "เนื่องจากการแก้ไข / การใช้งานของปัญหา 27350 " กะทัดรัดและสั่งการ Dict "ใน Python 3.6 ตอนนี้เราจะสามารถใช้ dict ในตัวเพื่อรักษาคำสั่งแทรก !!

หวังว่าสิ่งนี้จะนำไปสู่การปรับใช้เลเยอร์แบบบางของ OrderedDict เป็นขั้นตอนแรก ตามที่ @ JimFasarakis-Hilliard ระบุว่าบางคนเห็นกรณีการใช้งานสำหรับประเภท OrderedDict ในอนาคต ฉันคิดว่าชุมชน Python ที่มีขนาดใหญ่จะทำการตรวจสอบอย่างรอบคอบหากสิ่งนี้จะพิสูจน์การทดสอบของเวลาและขั้นตอนต่อไปจะเป็นอย่างไร

ถึงเวลาคิดใหม่นิสัยการเขียนโค้ดของเราเพื่อไม่ให้พลาดโอกาสที่จะเกิดขึ้นจากการสั่งซื้อที่มั่นคงของ:

• อาร์กิวเมนต์คำหลักและ
• ที่เก็บข้อมูล dict (ระดับกลาง)

ครั้งแรกเพราะมันช่วยลดความยุ่งยากในการใช้งานฟังก์ชั่นและวิธีการในบางกรณี

ประการที่สองตามที่มันสนับสนุนให้ใช้dictหน่วยความจำกลางในการประมวลผลท่อได้ง่ายขึ้น

Raymond Hettinger กรุณาให้เอกสารอธิบาย " เทคโนโลยีเบื้องหลัง Python 3.6 พจนานุกรม " - จากการนำเสนอกลุ่มการประชุมกลุ่ม Python Meetup ของซานฟรานซิสโก 2016-DEC-08

และบางทีคำถามและคำตอบที่มีการตกแต่งอย่างสูงของ Stack Overflow อาจจะได้รับข้อมูลหลากหลายและคำตอบที่มีคุณภาพจำนวนมากจะต้องมีการอัปเดตต่อรุ่นด้วยเช่นกัน

Caveat Emptor (แต่โปรดดูด้านล่างอัพเดท 2017-12-15):

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

ดังนั้นในขณะที่มนุษย์บางภาษา (เช่นภาษาเยอรมัน), การใช้รูปร่างภาษาและในขณะนี้จะได้รับการประกาศ ... ในwhatsnew36

อัพเดท 2017-12-15:

ในจดหมายไปยังรายการ python-dev , Guido van Rossum ประกาศ:

ทำให้เป็นเช่นนั้น "Dict เก็บคำสั่งแทรก" เป็นคำสั่ง ขอบคุณ!

ดังนั้นรุ่น 3.6 CPython ผลข้างเคียงของการสั่งการใส่ dict ตอนนี้กลายเป็นส่วนหนึ่งของข้อมูลจำเพาะของภาษา เธรดเมลนั้นยังแสดงถึงเป้าหมายการออกแบบที่แตกต่างเพื่อcollections.OrderedDictให้ได้รับการเตือนจาก Raymond Hettinger ระหว่างการสนทนา

ฉันมีปัญหาเดียวกันและฉันแก้ไขมันเช่นนี้:

WantedOutput = sorted(MyDict, key=lambda x : MyDict[x]) 

(คนที่ตอบว่า "มันเป็นไปไม่ได้ที่จะเรียงลำดับ dict" ไม่ได้อ่านคำถาม! อันที่จริง "ฉันสามารถเรียงลำดับบนคีย์ได้ แต่ฉันจะเรียงลำดับตามค่าได้อย่างไร?" อย่างชัดเจนหมายความว่าเขาต้องการรายการ คีย์ที่เรียงลำดับตามค่าของค่า)

โปรดสังเกตว่าคำสั่งนั้นไม่ได้กำหนดไว้อย่างดี (กุญแจที่มีค่าเท่ากันจะอยู่ในลำดับโดยพลการในรายการเอาท์พุท)

หากมีค่าเป็นตัวเลขคุณยังอาจจะใช้Counterจากคอลเลกชัน

from collections import Counter

x = {'hello': 1, 'python': 5, 'world': 3}
c = Counter(x)
print(c.most_common())

>> [('python', 5), ('world', 3), ('hello', 1)]    

ใน Python 2.7 เพียงทำ:

from collections import OrderedDict
# regular unsorted dictionary
d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

# dictionary sorted by key
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)])

คัดลอกวางจาก: http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes

สนุก ;-)

นี่คือรหัส:

import operator
origin_list = [
    {"name": "foo", "rank": 0, "rofl": 20000},
    {"name": "Silly", "rank": 15, "rofl": 1000},
    {"name": "Baa", "rank": 300, "rofl": 20},
    {"name": "Zoo", "rank": 10, "rofl": 200},
    {"name": "Penguin", "rank": -1, "rofl": 10000}
]
print ">> Original >>"
for foo in origin_list:
    print foo

print "\n>> Rofl sort >>"
for foo in sorted(origin_list, key=operator.itemgetter("rofl")):
    print foo

print "\n>> Rank sort >>"
for foo in sorted(origin_list, key=operator.itemgetter("rank")):
    print foo

นี่คือผลลัพธ์:

เป็นต้นฉบับ

{'name': 'foo', 'rank': 0, 'rofl': 20000}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Baa', 'rank': 300, 'rofl': 20}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Penguin', 'rank': -1, 'rofl': 10000}

rofl

{'name': 'Baa', 'rank': 300, 'rofl': 20}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Penguin', 'rank': -1, 'rofl': 10000}
{'name': 'foo', 'rank': 0, 'rofl': 20000}

ยศ

{'name': 'Penguin', 'rank': -1, 'rofl': 10000}
{'name': 'foo', 'rank': 0, 'rofl': 20000}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Baa', 'rank': 300, 'rofl': 20}

ลองวิธีต่อไปนี้ ให้เรากำหนดพจนานุกรมชื่อ mydict ด้วยข้อมูลต่อไปนี้:

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

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

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

สิ่งนี้ควรส่งคืนผลลัพธ์ต่อไปนี้:

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

ในทางกลับกันหากใครต้องการเรียงพจนานุกรมตามค่า (ตามที่ถามในคำถาม) ก็สามารถทำได้ดังนี้:

for key, value in sorted(mydict.iteritems(), key=lambda (k,v): (v,k)):
    print "%s: %s" % (key, value)

ผลลัพธ์ของคำสั่งนี้ (เรียงลำดับพจนานุกรมตามค่า) ควรคืนค่าต่อไปนี้:

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

เริ่มจาก Python 3.6 dictตอนนี้วัตถุได้รับคำสั่งจากลำดับการแทรก มันเป็นทางการในสเป็คของ Python 3.7

>>> words = {"python": 2, "blah": 4, "alice": 3}
>>> dict(sorted(words.items(), key=lambda x: x[1]))
{'python': 2, 'alice': 3, 'blah': 4}

OrderedDictก่อนที่คุณจะต้องใช้

เอกสาร Python 3.7พูดว่า:

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

คุณสามารถสร้าง "ดัชนีกลับด้าน" ได้เช่นกัน

from collections import defaultdict
inverse= defaultdict( list )
for k, v in originalDict.items():
    inverse[v].append( k )

ตอนนี้สิ่งที่ตรงกันข้ามของคุณมีค่า; แต่ละค่ามีรายการของคีย์ที่ใช้งานได้

for k in sorted(inverse):
    print k, inverse[k]

คุณสามารถใช้collections.Counter หมายเหตุสิ่งนี้จะใช้ได้ทั้งกับตัวเลขและไม่ใช่ตัวเลข

>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> from collections import Counter
>>> #To sort in reverse order
>>> Counter(x).most_common()
[(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)]
>>> #To sort in ascending order
>>> Counter(x).most_common()[::-1]
[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]
>>> #To get a dictionary sorted by values
>>> from collections import OrderedDict
>>> OrderedDict(Counter(x).most_common()[::-1])
OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

คุณสามารถใช้Dict เฮี๊ยบซึ่งเป็นพจนานุกรมที่เรียงอย่างถาวรโดยค่า

>>> data = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
>>> SkipDict(data)
{0: 0.0, 2: 1.0, 1: 2.0, 4: 3.0, 3: 4.0}

ถ้าคุณใช้keys(), values()หรือitems()แล้วคุณจะย้ำในเรียงลำดับตามตัวอักษร

มันดำเนินการโดยใช้รายการเฮี๊ยบ datastructure

คุณยังสามารถใช้ฟังก์ชั่นที่กำหนดเองที่สามารถส่งผ่านไปยังคีย์

def dict_val(x):
    return x[1]
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=dict_val)

from django.utils.datastructures import SortedDict

def sortedDictByKey(self,data):
    """Sorted dictionary order by key"""
    sortedDict = SortedDict()
    if data:
        if isinstance(data, dict):
            sortedKey = sorted(data.keys())
            for k in sortedKey:
                sortedDict[k] = data[k]
    return sortedDict

ตามที่ Dilettant ชี้ไปตอนนี้ Python 3.6 จะรักษาความสงบเรียบร้อยเอาไว้ ! ฉันคิดว่าฉันจะแบ่งปันฟังก์ชั่นที่ฉันเขียนซึ่งทำให้การเรียงลำดับของ iterable ง่ายขึ้น (tuple, list, dict) ในกรณีหลังคุณสามารถเรียงลำดับบนคีย์หรือค่าและสามารถนำมาเปรียบเทียบเป็นตัวเลข เฉพาะสำหรับ> = 3.6!

เมื่อคุณลองใช้ sort บน iterable ที่เก็บไว้เช่นสตริงและ ints การเรียง () จะล้มเหลว แน่นอนคุณสามารถบังคับให้เปรียบเทียบสตริงกับ str () อย่างไรก็ตามในบางกรณีคุณต้องการเปรียบเทียบตัวเลขจริงที่12มีขนาดเล็กกว่า20(ซึ่งไม่ใช่กรณีในการเปรียบเทียบสตริง) ดังนั้นฉันจึงมาพร้อมกับสิ่งต่อไปนี้ เมื่อคุณต้องการเปรียบเทียบตัวเลขอย่างชัดเจนคุณสามารถใช้การตั้งค่าสถานะnum_as_numซึ่งจะพยายามทำการเรียงลำดับตัวเลขอย่างชัดเจนโดยพยายามแปลงค่าทั้งหมดเป็นลอย หากประสบความสำเร็จมันจะทำการเรียงลำดับตัวเลขมิฉะนั้นจะใช้การเปรียบเทียบสตริง

ความคิดเห็นในการปรับปรุงหรือการร้องขอการผลักดันการต้อนรับ

def sort_iterable(iterable, sort_on=None, reverse=False, num_as_num=False):
    def _sort(i):
      # sort by 0 = keys, 1 values, None for lists and tuples
      try:
        if num_as_num:
          if i is None:
            _sorted = sorted(iterable, key=lambda v: float(v), reverse=reverse)
          else:
            _sorted = dict(sorted(iterable.items(), key=lambda v: float(v[i]), reverse=reverse))
        else:
          raise TypeError
      except (TypeError, ValueError):
        if i is None:
          _sorted = sorted(iterable, key=lambda v: str(v), reverse=reverse)
        else:
          _sorted = dict(sorted(iterable.items(), key=lambda v: str(v[i]), reverse=reverse))

      return _sorted

    if isinstance(iterable, list):
      sorted_list = _sort(None)
      return sorted_list
    elif isinstance(iterable, tuple):
      sorted_list = tuple(_sort(None))
      return sorted_list
    elif isinstance(iterable, dict):
      if sort_on == 'keys':
        sorted_dict = _sort(0)
        return sorted_dict
      elif sort_on == 'values':
        sorted_dict = _sort(1)
        return sorted_dict
      elif sort_on is not None:
        raise ValueError(f"Unexpected value {sort_on} for sort_on. When sorting a dict, use key or values")
    else:
      raise TypeError(f"Unexpected type {type(iterable)} for iterable. Expected a list, tuple, or dict")

นี่คือวิธีการแก้ปัญหาโดยใช้ซิปบนและd.values() d.keys()มีลิงก์ไม่กี่บรรทัดที่ลิงก์นี้ (ในวัตถุมุมมองพจนานุกรม) คือ:

สิ่งนี้อนุญาตให้สร้างคู่ (ค่า, คีย์) โดยใช้ zip (): pairs = zip (d.values ​​(), d.keys ())

ดังนั้นเราสามารถทำสิ่งต่อไปนี้:

d = {'key1': 874.7, 'key2': 5, 'key3': 8.1}

d_sorted = sorted(zip(d.values(), d.keys()))

print d_sorted 
# prints: [(5, 'key2'), (8.1, 'key3'), (874.7, 'key1')]

แน่นอนจำไว้ว่าคุณต้องใช้OrderedDictเพราะพจนานุกรม Python ทั่วไปไม่รักษาลำดับเดิม

from collections import OrderedDict
a = OrderedDict(sorted(originalDict.items(), key=lambda x: x[1]))

หากคุณไม่มี Python 2.7 หรือสูงกว่าสิ่งที่ดีที่สุดที่คุณสามารถทำได้คือวนซ้ำค่าในฟังก์ชันตัวสร้าง (มีOrderedDict2.4 และ 2.6 ตรง นี้ , แต่

a) ฉันไม่รู้ว่ามันทำงานได้ดีแค่ไหน

และ

b) คุณต้องดาวน์โหลดและติดตั้งแน่นอน หากคุณไม่มีสิทธิ์การเข้าถึงระดับผู้ดูแลระบบฉันเกรงว่าจะมีตัวเลือกไม่เพียงพอ)

def gen(originalDict):
    for x, y in sorted(zip(originalDict.keys(), originalDict.values()), key=lambda z: z[1]):
        yield (x, y)
    #Yields as a tuple with (key, value). You can iterate with conditional clauses to get what you want. 

for bleh, meh in gen(myDict):
    if bleh == "foo":
        print(myDict[bleh])

คุณยังสามารถพิมพ์ทุกค่า

for bleh, meh in gen(myDict):
    print(bleh, meh)

โปรดอย่าลืมลบวงเล็บหลังจากพิมพ์หากไม่ได้ใช้ Python 3.0 หรือสูงกว่า

ใช้ValueSortedDictจากdicts :

from dicts.sorteddict import ValueSortedDict
d = {1: 2, 3: 4, 4:3, 2:1, 0:0}
sorted_dict = ValueSortedDict(d)
print sorted_dict.items() 

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

ใช้งานได้ใน 3.1.x:

import operator
slovar_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=True)
print(slovar_sorted)

เพิ่งได้เรียนรู้ทักษะที่เกี่ยวข้องจากงูใหญ่สำหรับทุกคน

คุณอาจใช้รายการชั่วคราวเพื่อช่วยคุณเรียงลำดับพจนานุกรม:

#Assume dictionary to be:
d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0}

# create a temporary list
tmp = []

# iterate through the dictionary and append each tuple into the temporary list 
for key, value in d.items():
    tmptuple = (value, key)
    tmp.append(tmptuple)

# sort the list in ascending order
tmp = sorted(tmp)

print (tmp)

หากคุณต้องการเรียงลำดับรายการจากมากไปน้อยเพียงเปลี่ยนบรรทัดการเรียงลำดับเดิมเป็น:

tmp = sorted(tmp, reverse=True)

การใช้ความเข้าใจในรายการซับหนึ่งจะเป็น:

#Assuming the dictionary looks like
d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0}
#One liner for sorting in ascending order
print (sorted([(v, k) for k, v in d.items()]))
#One liner for sorting in descending order
print (sorted([(v, k) for k, v in d.items()], reverse=True))

ตัวอย่างผลลัพธ์:

#Asending order
[(1.0, 'orange'), (500.1, 'apple'), (789.0, 'pineapple'), (1500.2, 'banana')]
#Descending order
[(1500.2, 'banana'), (789.0, 'pineapple'), (500.1, 'apple'), (1.0, 'orange')]

วนซ้ำผ่านพจน์และเรียงตามค่าในลำดับจากมากไปน้อย:

$ python --version
Python 3.2.2

$ cat sort_dict_by_val_desc.py 
dictionary = dict(siis = 1, sana = 2, joka = 3, tuli = 4, aina = 5)
for word in sorted(dictionary, key=dictionary.get, reverse=True):
  print(word, dictionary[word])

$ python sort_dict_by_val_desc.py 
aina 5
tuli 4
joka 3
sana 2
siis 1

หากค่าของคุณเป็นจำนวนเต็มและคุณใช้ Python 2.7 หรือใหม่กว่าคุณสามารถใช้แทนcollections.Counter วิธีการที่จะทำให้คุณรายการทั้งหมดเรียงตามมูลค่าdictmost_common

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

>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> x_items = x.items()
>>> heapq.heapify(x_items)
>>> #To sort in reverse order
>>> heapq.nlargest(len(x_items),x_items, operator.itemgetter(1))
[(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)]
>>> #To sort in ascending order
>>> heapq.nsmallest(len(x_items),x_items, operator.itemgetter(1))
[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]

เนื่องจากข้อกำหนดในการรักษาความเข้ากันได้ย้อนหลังกับPythonรุ่นเก่าฉันคิดว่าโซลูชัน OrderedDict นั้นไม่ฉลาดมาก คุณต้องการบางสิ่งที่ใช้งานได้กับ Python 2.7 และรุ่นที่เก่ากว่า

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

ฉันไม่เห็นด้วยกับตัวเลือกอันดับหนึ่งที่นำเสนอในคำตอบอื่นเพราะมันทิ้งกุญแจ

ฉันใช้วิธีแก้ปัญหาที่กล่าวถึงข้างต้น (รหัสที่แสดงด้านล่าง) และการเข้าถึงคีย์และค่าต่าง ๆ และในกรณีของฉันการสั่งซื้ออยู่ในค่า แต่ความสำคัญคือการสั่งซื้อคีย์หลังจากสั่งซื้อค่า

from collections import Counter

x = {'hello':1, 'python':5, 'world':3}
c=Counter(x)
print c.most_common()


>> [('python', 5), ('world', 3), ('hello', 1)]