Saya memiliki kamus nilai yang dibaca dari dua bidang dalam database: bidang string dan bidang numerik. Bidang string unik, jadi itulah kunci kamus.

Saya bisa mengurutkan pada tombol, tetapi bagaimana saya bisa mengurutkan berdasarkan nilai-nilai?

Catatan: Saya telah membaca pertanyaan Stack Overflow di sini. Bagaimana cara saya mengurutkan daftar kamus berdasarkan nilai kamus? dan mungkin dapat mengubah kode saya untuk memiliki daftar kamus, tetapi karena saya tidak benar-benar membutuhkan daftar kamus saya ingin tahu apakah ada solusi yang lebih sederhana untuk mengurutkan baik dalam urutan naik atau turun.

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 yang lebih lama

Kamus tidak mungkin diurutkan, hanya untuk mendapatkan representasi kamus yang diurutkan. Kamus pada dasarnya tidak berurutan, tetapi jenis lain, seperti daftar dan tupel, tidak. Jadi, Anda memerlukan tipe data yang diurutkan untuk mewakili nilai yang diurutkan, yang akan menjadi daftar — mungkin daftar tupel.

Contohnya,

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

sorted_xakan menjadi daftar tupel yang diurutkan berdasarkan elemen kedua di setiap tupel. dict(sorted_x) == x.

Dan bagi mereka yang ingin mengurutkan pada kunci, bukan nilai:

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

Dalam Python3 karena membongkar tidak diperbolehkan [1] bisa kita gunakan

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

Jika Anda ingin output sebagai dict, Anda dapat menggunakan collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Sesederhana: sorted(dict1, key=dict1.get)

Yah, sebenarnya mungkin untuk melakukan "urutkan berdasarkan nilai kamus". Baru-baru ini saya harus melakukan itu dalam Code Golf (Stack Overflow question Code golf: Word frequency chart ). Ringkasnya, masalahnya adalah dari jenis: diberi teks, menghitung seberapa sering setiap kata ditemui dan menampilkan daftar kata-kata teratas, diurutkan berdasarkan frekuensi yang menurun.

Jika Anda membuat kamus dengan kata-kata sebagai kunci dan jumlah kemunculan setiap kata sebagai nilai, disederhanakan di sini sebagai:

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

maka Anda bisa mendapatkan daftar kata-kata, diurutkan berdasarkan frekuensi penggunaan dengan sorted(d, key=d.get)- pengurutan yang dilakukan di atas tombol kamus, menggunakan jumlah kemunculan kata sebagai kunci pengurutan.

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

Saya menulis penjelasan terperinci ini untuk mengilustrasikan apa yang sering orang maksud dengan "Saya dapat dengan mudah mengurutkan kamus berdasarkan kunci, tetapi bagaimana cara saya mengurutkan berdasarkan nilai" - dan saya pikir posting asli sedang mencoba untuk mengatasi masalah seperti itu. Dan solusinya adalah melakukan semacam daftar kunci, berdasarkan nilai-nilai, seperti yang ditunjukkan di atas.

Anda bisa menggunakan:

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

Ini akan mengurutkan kamus berdasarkan nilai setiap entri dalam kamus dari yang terkecil hingga yang terbesar.

Untuk mengurutkannya dalam urutan menurun, tambahkan saja reverse=True:

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

Memasukkan:

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

Keluaran:

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

Diktik tidak dapat disortir, tetapi Anda dapat membuat daftar diurutkan dari mereka.

Daftar nilai dict yang diurutkan:

sorted(d.values())

Daftar pasangan (kunci, nilai), diurutkan berdasarkan nilai:

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

Dalam Python 2.7 baru-baru ini, kami memiliki tipe OrderedDict baru , yang mengingat urutan item ditambahkan.

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

Untuk membuat kamus berurutan baru dari yang asli, urutkan berdasarkan nilainya:

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

The OrderedDict berperilaku seperti dict normal:

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

UPDATE: 5 DESEMBER 2015 menggunakan Python 3.5

Sementara saya menemukan jawaban yang diterima bermanfaat, saya juga terkejut bahwa itu belum diperbarui untuk merujuk OrderedDict dari modul koleksi perpustakaan standar sebagai alternatif yang layak, modern - dirancang untuk memecahkan jenis masalah yang tepat.

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

Dokumentasi resmi OrderedDict menawarkan contoh yang sangat mirip juga, tetapi menggunakan lambda untuk fungsi sortir:

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

Hampir sama dengan jawaban Hank Gay :

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

Atau sedikit dioptimalkan seperti yang disarankan oleh John Fouhy:

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

Seringkali bisa sangat berguna untuk menggunakan namesuple . Misalnya, Anda memiliki kamus 'nama' sebagai kunci dan 'skor' sebagai nilai dan Anda ingin menyortir 'skor':

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

pengurutan dengan skor terendah terlebih dahulu:

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

pengurutan dengan skor tertinggi pertama:

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

Sekarang Anda bisa mendapatkan nama dan skor, katakanlah pemain terbaik kedua (indeks = 1) dengan sangat Pythonically seperti ini:

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

Pada Python 3.6 , built-in dict akan dipesan

Kabar baik, sehingga kasus penggunaan asli OP pasangan pemetaan diambil dari database dengan id string unik sebagai kunci dan nilai numerik sebagai nilai ke dalam dict Python v3.6 + built-in, sekarang harus menghormati urutan memasukkan.

Jika mengatakan dua ekspresi tabel kolom yang dihasilkan dari permintaan database seperti:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

akan disimpan dalam dua Python tuple, k_seq dan v_seq (disejajarkan dengan indeks numerik dan dengan panjang yang sama tentu saja), kemudian:

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

Izinkan untuk keluaran nanti sebagai:

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

menghasilkan dalam hal ini (untuk Python 3.6+ built-in dict baru!):

foo 0
bar 1
baz 42

dalam pemesanan yang sama per nilai v.

Di mana di Python 3.5 instal di mesin saya saat ini menghasilkan:

bar 1
foo 0
baz 42

Detail:

Seperti yang diusulkan pada 2012 oleh Raymond Hettinger (lih. Mail pada python-dev dengan subjek "Kamus yang lebih ringkas dengan iterasi yang lebih cepat" ) dan sekarang (pada 2016) diumumkan dalam email oleh Victor Stinner kepada python-dev dengan subjek "Python 3.6 dict menjadi kompak dan mendapatkan versi pribadi, dan kata kunci menjadi dipesan " karena perbaikan / implementasi masalah 27350 " Compact dan dipesan dict " di Python 3.6 sekarang kita akan dapat, untuk menggunakan dict built-in untuk mempertahankan urutan memasukkan !!

Semoga ini akan mengarah pada implementasi OrderedDict lapisan tipis sebagai langkah pertama. Seperti yang ditunjukkan @ JimFasarakis-Hilliard, beberapa melihat kasus penggunaan untuk tipe OrderedDict juga di masa mendatang. Saya pikir komunitas Python pada umumnya akan memeriksa dengan seksama, apakah ini akan bertahan dalam ujian waktu, dan apa langkah selanjutnya.

Saatnya memikirkan kembali kebiasaan pengkodean kita untuk tidak melewatkan kemungkinan yang dibuka oleh pemesanan stabil:

• Argumen kata kunci dan
• (menengah) penyimpanan dict

Yang pertama karena memudahkan pengiriman dalam implementasi fungsi dan metode dalam beberapa kasus.

Yang kedua karena mendorong untuk lebih mudah menggunakan dicts sebagai penyimpanan perantara dalam pemrosesan pipa.

Raymond Hettinger dengan baik hati memberikan dokumentasi yang menjelaskan " The Tech Behind Python 3.6 Dictionaries " - dari presentasi San Francisco Python Meetup Group 2016-DEC-08.

Dan mungkin beberapa Stack Overflow halaman pertanyaan dan jawaban yang dihiasi dengan tinggi akan menerima varian informasi ini dan banyak jawaban berkualitas tinggi akan memerlukan pembaruan per versi juga.

Caveat Emptor (tetapi juga lihat pembaruan di bawah 2017-12-15):

Seperti yang dicatat @ajcr dengan benar: "Aspek pelestarian pesanan dari implementasi baru ini dianggap sebagai detail implementasi dan tidak boleh diandalkan." (dari whatsnew36 ) bukan nit picking, tapi kutipannya terpotong agak pesimistis ;-). Ini berlanjut sebagai "(ini dapat berubah di masa depan, tetapi diinginkan untuk memiliki implementasi dict baru ini dalam bahasa untuk beberapa rilis sebelum mengubah spesifikasi bahasa untuk mandat semantik pelestarian pesanan untuk semua implementasi Python saat ini dan masa depan; ini juga membantu menjaga kompatibilitas ke belakang dengan versi bahasa yang lebih lama di mana urutan iterasi acak masih berlaku, misalnya Python 3.5). "

Jadi seperti dalam beberapa bahasa manusia (misalnya Jerman), penggunaan membentuk bahasa, dan kehendak sekarang telah dinyatakan ... di whatsnew36 .

Pembaruan 2017-12-15:

Dalam surel ke daftar python-dev , Guido van Rossum menyatakan:

Jadikan begitu. "Dict menjaga urutan penyisipan" adalah putusannya. Terima kasih!

Jadi, efek samping versi 3,6 CPython dari pemesanan penyisipan dict sekarang menjadi bagian dari spesifikasi bahasa (dan tidak lagi hanya detail implementasi). Utas surat itu juga memunculkan beberapa tujuan desain yang berbeda untuk collections.OrderedDictdiingatkan oleh Raymond Hettinger selama diskusi.

Saya memiliki masalah yang sama, dan saya menyelesaikannya seperti ini:

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

(Orang yang menjawab "Tidak mungkin untuk menyortir dict" tidak membaca pertanyaan! Bahkan, "Saya dapat mengurutkan pada kunci, tetapi bagaimana saya bisa mengurutkan berdasarkan nilai-nilai?" Jelas berarti bahwa ia menginginkan daftar kunci diurutkan sesuai dengan nilai nilainya.)

Harap perhatikan bahwa pesanan tidak didefinisikan dengan baik (kunci dengan nilai yang sama akan berada dalam urutan acak dalam daftar keluaran).

Jika nilainya numerik, Anda juga dapat menggunakan Counterdari koleksi .

from collections import Counter

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

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

Dalam Python 2.7, cukup lakukan:

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

salin-tempel dari: http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes

Nikmati ;-)

Ini kodenya:

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

Inilah hasilnya:

Asli

{'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}

Pangkat

{'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}

Coba pendekatan berikut. Mari kita mendefinisikan kamus yang disebut mydict dengan data berikut:

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

Jika seseorang ingin mengurutkan kamus dengan kunci, orang dapat melakukan sesuatu seperti:

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

Ini akan menghasilkan output berikut:

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

Di sisi lain, jika seseorang ingin mengurutkan kamus berdasarkan nilai (seperti yang ditanyakan dalam pertanyaan), seseorang dapat melakukan hal berikut:

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

Hasil dari perintah ini (mengurutkan kamus berdasarkan nilai) harus mengembalikan yang berikut:

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

Mulai dari Python 3.6, dictobjek sekarang dipesan dengan urutan penyisipan. Ini secara resmi dalam spesifikasi 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}

Sebelum itu, Anda harus menggunakannya OrderedDict.

Dokumentasi Python 3.7 mengatakan:

Diubah dalam versi 3.7: Urutan kamus dijamin menjadi urutan penyisipan. Perilaku ini adalah detail implementasi CPython dari 3.6.

Anda dapat membuat "indeks terbalik" juga

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

Sekarang kebalikan Anda memiliki nilai; setiap nilai memiliki daftar kunci yang berlaku.

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

Anda dapat menggunakan collections.Counter . Catatan, ini akan berfungsi untuk nilai numerik dan non-numerik.

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

Anda dapat menggunakan skip dict yang merupakan kamus yang secara permanen diurutkan berdasarkan nilai.

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

Jika Anda menggunakan keys(), values()atau items()Anda akan mengulanginya dalam urutan berdasarkan nilai.

Diimplementasikan menggunakan datastructure daftar skip .

Anda juga dapat menggunakan fungsi kustom yang dapat diteruskan ke tombol.

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

Seperti yang ditunjukkan oleh Dilettant , Python 3.6 sekarang akan menyimpan pesanan ! Saya pikir saya akan berbagi fungsi yang saya tulis yang memudahkan penyortiran iterable (tuple, list, dict). Dalam kasus yang terakhir, Anda bisa mengurutkan baik pada kunci atau nilai, dan itu bisa memperhitungkan perbandingan numerik. Hanya untuk> = 3,6!

Ketika Anda mencoba menggunakan diurutkan pada iterable yang memegang mis string dan ints, diurutkan () akan gagal. Tentu saja Anda dapat memaksa perbandingan string dengan str (). Namun, dalam beberapa kasus Anda ingin melakukan perbandingan numerik aktual di mana 12lebih kecil dari 20(yang tidak terjadi dalam perbandingan string). Jadi saya datang dengan yang berikut ini. Saat Anda ingin perbandingan angka eksplisit, Anda dapat menggunakan flag num_as_numyang akan mencoba melakukan penyortiran angka eksplisit dengan mencoba mengonversi semua nilai menjadi float. Jika itu berhasil, itu akan melakukan pengurutan numerik, jika tidak akan menggunakan perbandingan string.

Komentar untuk perbaikan atau permintaan push disambut.

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

Berikut ini solusi menggunakan zip on d.values()dand.keys() . Beberapa baris di bawah tautan ini (pada objek tampilan Kamus) adalah:

Ini memungkinkan pembuatan pasangan (nilai, kunci) menggunakan zip (): pairs = zip (d.values ​​(), d.keys ()).

Jadi kita bisa melakukan hal berikut:

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

Tentu saja, ingat, Anda perlu menggunakan OrderedDictkarena kamus Python biasa tidak menjaga urutan aslinya.

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

Jika Anda tidak memiliki Python 2.7 atau lebih tinggi, hal terbaik yang dapat Anda lakukan adalah mengulangi nilai-nilai dalam fungsi generator. (Ada OrderedDictuntuk 2.4 dan 2.6 di sini , tetapi

a) Saya tidak tahu seberapa baik kerjanya

dan

b) Anda harus mengunduh dan menginstalnya tentu saja. Jika Anda tidak memiliki akses administratif, maka saya takut pilihannya keluar.)

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

Anda juga dapat mencetak setiap nilai

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

Harap ingat untuk menghapus tanda kurung setelah dicetak jika tidak menggunakan Python 3.0 atau lebih tinggi

Gunakan ValueSortedDict dari 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)]

Ini berfungsi di 3.1.x:

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

Baru belajar keterampilan yang relevan dari Python untuk Semua Orang .

Anda dapat menggunakan daftar sementara untuk membantu Anda mengurutkan kamus:

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

Jika Anda ingin mengurutkan daftar dalam urutan menurun, cukup ubah baris pengurutan asli ke:

tmp = sorted(tmp, reverse=True)

Menggunakan pemahaman daftar, liner satu akan menjadi:

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

Output sampel:

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

Iterasi melalui dict dan urutkan berdasarkan nilainya dalam urutan menurun:

$ 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

Jika nilai-nilai Anda adalah bilangan bulat, dan Anda menggunakan Python 2.7 atau yang lebih baru, Anda dapat menggunakan collections.Counterbukan dict. The most_commonMetode akan memberikan semua item, diurutkan berdasarkan nilai.

Demi kelengkapan, saya memposting solusi menggunakan heapq . Catatan, metode ini akan bekerja untuk nilai numerik dan non-numerik

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

Karena persyaratan untuk mempertahankan kompatibilitas dengan versi Python yang lebih lama saya pikir solusi OrderedDict sangat tidak bijaksana. Anda menginginkan sesuatu yang berfungsi dengan Python 2.7 dan versi yang lebih lama.

Tetapi solusi koleksi yang disebutkan dalam jawaban lain benar-benar hebat, karena Anda melatih kembali hubungan antara kunci dan nilai yang dalam kasus kamus sangat penting.

Saya tidak setuju dengan pilihan nomor satu yang disajikan dalam jawaban lain, karena itu membuang kunci.

Saya menggunakan solusi yang disebutkan di atas (kode yang ditunjukkan di bawah) dan mempertahankan akses ke kedua kunci dan nilai-nilai dan dalam kasus saya pemesanan adalah pada nilai-nilai, tetapi yang penting adalah urutan kunci setelah memesan nilai-nilai.

from collections import Counter

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


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