मैं मूल्य से एक शब्दकोश कैसे सॉर्ट करूं?

Question

मेरे पास एक डेटाबेस में दो क्षेत्रों से पढ़े गए मूल्यों का शब्दकोश है: एक स्ट्रिंग क्षेत्र और एक संख्यात्मक क्षेत्र। स्ट्रिंग फ़ील्ड अद्वितीय है, इसलिए यह शब्दकोश की कुंजी है।

मैं कुंजियों पर सॉर्ट कर सकता हूं, लेकिन मैं मूल्यों के आधार पर कैसे सॉर्ट कर सकता हूं?

नोट: मैंने यहां स्टैक ओवरफ्लो प्रश्न पढ़ा है। मैं शब्दकोश के मूल्य द्वारा शब्दकोशों की सूची कैसे छाँटूँ ? और संभवतः मेरे कोड को शब्दकोशों की सूची में बदल सकता है, लेकिन चूंकि मुझे वास्तव में उन शब्दकोशों की सूची की आवश्यकता नहीं है जो मैं जानना चाहता था कि क्या आरोही या अवरोही क्रम में क्रमबद्ध करने के लिए एक सरल समाधान है।

Comments

शब्दकोश डेटा संरचना में अंतर्निहित आदेश नहीं है। आप इसके माध्यम से पुनरावृत्ति कर सकते हैं, लेकिन यह गारंटी देने के लिए कुछ भी नहीं है कि पुनरावृत्ति किसी विशेष आदेश का पालन करेगी। यह डिज़ाइन के अनुसार है, इसलिए प्रतिनिधित्व के लिए आपका सबसे अच्छा दांव मोबाइल डेटा संरचना का उपयोग करने के लिए प्रबल है।

— डेशिमन

"सॉर्ट किया गया ()" शब्दकोशों पर काम कर सकता है (और क्रमबद्ध कुंजी की सूची देता है), इसलिए मुझे लगता है कि वह इसके बारे में जानते हैं। उनके कार्यक्रम को जाने बिना, किसी को यह बताना बेतुका है कि वे गलत डेटा संरचना का उपयोग कर रहे हैं। यदि तेज़ लुकअप वे हैं जो आपको 90% समय की आवश्यकता है, तो एक तानाशाह शायद वही है जो आप चाहते हैं।

— बोबपौल

छँटाई शब्दकोशों के लिए सभी तीन आउटपुट (चाबियाँ, मूल्य, दोनों) यहाँ एक स्पष्ट और संक्षिप्त शैली में कवर किए गए हैं: stackoverflow.com/questions/16772071/sort-dict-by-value-python

— JStraD

@Daishiman आधार वर्ग का आदेश नहीं दिया जा सकता है, लेकिन ऑर्डरडीड निश्चित रूप से है।

— टेलर एड्मिस्टन

पायथन में 3.6+ डिक्शनरी ऑर्डर को सुरक्षित रखते हैं। यह निश्चित रूप से, उन्हें मूल्य द्वारा क्रमबद्ध करने की संभावना के समान नहीं है, लेकिन दूसरी तरफ यह कहने के लिए अब वैध नहीं है कि "शब्दकोश डेटा संरचना में अंतर्निहित आदेश नहीं है"।

— कोनराड कोसिक

Answer 1

अजगर 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}

बूढ़ा अजगर

एक शब्दकोश को छांटना संभव नहीं है, केवल एक शब्दकोश का प्रतिनिधित्व प्राप्त करने के लिए जो क्रमबद्ध है। शब्दकोश स्वाभाविक रूप से क्रमहीन हैं, लेकिन सूची और टुपल्स जैसे अन्य प्रकार नहीं हैं। तो आपको सॉर्ट किए गए मानों का प्रतिनिधित्व करने के लिए एक ऑर्डर किए गए डेटा प्रकार की आवश्यकता होती है, जो कि एक सूची होगी - शायद ट्यूपल्स की एक सूची।

उदाहरण के लिए,

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

sorted_xप्रत्येक tuple में दूसरे तत्व द्वारा क्रमबद्ध tuples की एक सूची होगी। 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])

यदि आप आउटपुट को एक तानाशाही के रूप में चाहते हैं, तो आप इसका उपयोग कर सकते हैं collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Comments

मूल्य योजनाओं द्वारा छाँटे

— Gregg Lind

sorted_x.reverse()आपको एक अवरोही क्रम प्रदान करेगा (दूसरे

— टुप्ले

saidimu: चूंकि हम पहले से ही उपयोग कर रहे हैं sorted(), यह reverse=Trueतर्क में पारित करने के लिए बहुत अधिक कुशल है ।

— rhh

अजगर 3 में मैंने एक मेमने का इस्तेमाल किया sorted(d.items(), key=lambda x: x[1]):। क्या यह अजगर २.x में काम करेगा?

— कीओ

ऑर्डरडडिक्ट ने 2.7 में संग्रह में जोड़ा। छाँटे

— monkut

Answer 2

की तरह सरल: sorted(dict1, key=dict1.get)

ठीक है, यह "शब्दकोश मूल्यों द्वारा क्रमबद्ध" करने के लिए वास्तव में संभव है। हाल ही में मुझे एक कोड गोल्फ (स्टैक ओवरफ़्लो प्रश्न कोड गोल्फ: वर्ड फ़्रीक्वेंसी चार्ट ) में ऐसा करना पड़ा । संक्षिप्त, समस्या इस प्रकार की थी: एक पाठ दिया गया था, गिनती करें कि प्रत्येक शब्द कितनी बार सामना किया गया है और घटती आवृत्ति द्वारा क्रमबद्ध शीर्ष शब्दों की एक सूची प्रदर्शित करता है।

यदि आप कुंजी के रूप में शब्दों के साथ एक शब्दकोष और मूल्य के रूप में प्रत्येक शब्द की घटनाओं की संख्या का निर्माण करते हैं, तो यहां सरल किया गया है:

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

मैं यह विस्तृत विवरण लिखने के लिए लिख रहा हूं कि लोग अक्सर "मैं आसानी से कुंजी द्वारा एक शब्दकोश को कैसे सॉर्ट कर सकता हूं, लेकिन इसका मूल्य के आधार पर क्रमबद्ध कैसे कर सकता हूं" - और मुझे लगता है कि मूल पोस्ट इस तरह के मुद्दे को संबोधित करने की कोशिश कर रहा था। और समाधान मानों के आधार पर, कुंजियों की सूची का प्रकार करना है, जैसा कि ऊपर दिखाया गया है।

Comments

यह भी अच्छा है लेकिन key=operator.itemgetter(1)दक्षता के लिए अधिक स्केलेबल होना चाहिएkey=d.get

— स्मि

@raylu मैं आइटमगेटर का उपयोग करके "काम नहीं करता" व्यवहार का निरीक्षण करता हूं: ----- from operator import itemgetter d = {"a":7, "b":1, "c":5, "d":3} sorted_keys = sorted(d, key=itemgetter, reverse=True) for key in sorted_keys: print "%s: %d" % (key, d[key]) ----- -> b: 1 c: 5 a: 7 d: 3 परिणाम हर बार जब मैं कोड चलाता हूं तो परिवर्तन होता है: अजीब । (क्षमा करें, ठीक से प्रदर्शित करने के लिए कोड नहीं मिल सकता है)

— bli

@bli sorted_keys = sorted(d.items(), key=itemgetter(1), reverse=True)और for key, val in sorted_keys: print "%s: %d" % (key, val)- आइटमगेटर एक फ़ंक्शन बनाता है जब इसे कॉल किया जाता है, तो आप इसे सीधे अपने उदाहरण में उपयोग नहीं करते हैं। और एक

— ताना

मैं आपको बताने के लिए भविष्य से आया हूं collections.Counter, जिसमें एक most_commonतरीका है जो आपको रुचि दे सकता है :)

— Eevee

@ ईवे - वहाँ है कि, गैर- f2f छोटी टिप्पणियों में गलत समझा जाने का जोखिम। Amuzing tidbit: collections.Counter2.7 में जोड़ा गया था, जो लगभग 7 साल पहले जारी किया गया था! (मैं तब इसके बारे में नहीं जानता था - प्लस मैंने इसे संक्षिप्तता के उद्देश्य से कोड-गोल्फ में टाला होगा, जो कि गेम का एकमात्र जुनून है)

— Nas Banov

Answer 3

आप उपयोग कर सकते हैं:

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

Comments

जो मैंने देखा है ( docs.python.org/2/library/… ) से, एक वर्ग है जिसे आर्डरडक्ट कहा जाता है जिसे क्रमबद्ध किया जा सकता है और ऑर्डर को फिर भी डिक्शनरी बनाकर रखा जा सकता है। कोड के उदाहरणों से, आप इसे क्रमबद्ध करने के लिए लैम्ब्डा का उपयोग कर सकते हैं, लेकिन मैंने इसे व्यक्तिगत रूप से आज़माया नहीं है: P

— UsAndRufus

मैं पसंद करते हैं key=lambda (k, v): vव्यक्तिगत रूप से

— Claudiu

@ कोलियु मुझे वह (k, v)वाक्य रचना भी पसंद है , लेकिन यह पायथन 3 में उपलब्ध नहीं है, जहां ट्यूपल पैरामीटर अनपैकिंग को हटा दिया गया था।

— बॉब स्टेन

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

— Dr_Hope

Tuples का एक क्रमबद्ध सूची में से एक dict बनाने सं फिर से आदेश को मारता है ...

— जीन फ़्राँस्वा Fabre

Answer 4

डायट्स को सॉर्ट नहीं किया जा सकता है, लेकिन आप उनसे एक सॉर्ट की गई सूची बना सकते हैं।

तानाशाह मूल्यों की एक क्रमबद्ध सूची:

sorted(d.values())

मूल्य द्वारा क्रमबद्ध (कुंजी, मूल्य) जोड़े की एक सूची:

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

Comments

किस क्रम में कुंजी समान मूल्य के साथ रखी गई है? मैंने पहले कुंजियों द्वारा सूची को सॉर्ट किया, फिर मूल्यों द्वारा, लेकिन समान मूल्य के साथ कुंजियों का क्रम नहीं रहता है।

— सब्रेवॉल्फी

डायट्स को अब सॉर्ट किया जा सकता है, जिसकी शुरुआत CPython 3.6 से हो रही है और अन्य सभी पायथन कार्यान्वयन 3.7

— बोरिस

Answer 5

हाल ही में पायथन 2.7 में, हमारे पास नया ऑर्डरडीडक्ट प्रकार है, जो उस आदेश को याद करता है जिसमें आइटम जोड़े गए थे।

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

द ऑर्डरडीडक्ट एक सामान्य तानाशाह की तरह व्यवहार करता है:

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

Comments

यह वह नहीं है जो प्रश्न के बारे में है - यह चाबियों के क्रम को बनाए रखने के बारे में नहीं है, लेकिन "मूल्य के अनुसार छंटाई" के बारे में है

— नास बानोव

@नास बानोव: यह कुंजी द्वारा छँटाई नहीं है। यह क्रम में छंटनी है, हम आइटम बनाते हैं। हमारे मामले में, हम मूल्य के अनुसार क्रमबद्ध हैं। दुर्भाग्य से, 3-आइटम तानाशाह दुर्भाग्य से चुना गया था, इसलिए आदेश समान था, जब मूल्य और कुंजी द्वारा सॉर्ट किया गया था, इसलिए मैंने नमूना तानाशाही का विस्तार किया।

— मायखाल

sorted(d.items(), key=lambda x: x[1])क्या आप बता सकते हैं कि xइसका क्या मतलब है, यह x[1]लंबोदर क्यों ले सकता है ? ऐसा क्यों नहीं हो सकता है x[0]? आपका बहुत बहुत धन्यवाद!

— JZAU

@ बॉर्न d.items()एक सूची देता है जैसे टुपल्स का कंटेनर (key, value)। [0]टपल के पहले तत्व तक पहुँचता है - कुंजी - और [1]दूसरे तत्व तक पहुँचता है - मान।

— बॉलपॉइंटबैन

नोट: 3.6 के रूप में (एक CPython / PyPy कार्यान्वयन विवरण के रूप में) और 3.7 के रूप में (पायथन भाषा की गारंटी के रूप में), सादा dictसम्मिलन का आदेश दिया गया है, इसलिए आप बस आधुनिक पायथन पर चलने वाले कोड के OrderedDictसाथ बदल सकते हैं dict। OrderedDictवास्तव में अब और ज़रूरत नहीं है जब तक कि आपको किसी मौजूदा dict( move_to_end/ popitem) के आदेश को पुनर्व्यवस्थित करने की आवश्यकता न हो या आदेश-संवेदनशील होने के लिए समानता तुलना की आवश्यकता हो। यह सादे की तुलना में बहुत अधिक मेमोरी का उपयोग करता है dict, इसलिए यदि आप कर सकते हैं, तो dictजाने का रास्ता है।

— शैडो रेंजर

Answer 6

अद्यतन: पायथन 3.5 का उपयोग करते हुए 5 DECEMBER 2015

जब भी मुझे स्वीकृत उत्तर उपयोगी लगा, मुझे यह भी आश्चर्य हुआ कि यह मानक पुस्तकालय संग्रह मॉड्यूल से एक व्यवहार्य, आधुनिक विकल्प के रूप में ऑर्डरडीडक्ट को संदर्भित करने के लिए अद्यतन नहीं किया गया है - बिल्कुल इस प्रकार की समस्या को हल करने के लिए डिज़ाइन किया गया है।

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

आधिकारिक आर्डर डिडक्ट डॉक्यूमेंटेशन बहुत समान उदाहरण पेश करता है, लेकिन सॉर्ट फ़ंक्शन के लिए लैम्बडा का उपयोग करना:

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

Answer 7

हंक गे के जवाब के रूप में बहुत ही सुंदर :

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

या जॉन फोहे द्वारा सुझाए गए अनुसार थोड़ा अनुकूलित:

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

Comments

..और हंक गे के जवाब के साथ, आपको वर्ग कोष्ठक की आवश्यकता नहीं है। क्रमबद्ध () खुशी से किसी भी पुनरावृत्ति ले जाएगा, जैसे एक जनरेटर अभिव्यक्ति।

— जॉन फोहि

(कुंजी, मान) के साथ समाप्त होने के लिए आपको अभी भी (मान, कुंजी) टपल तत्वों को स्वैप करने की आवश्यकता हो सकती है। एक और सूची समझ की जरूरत है। [(key, value) for (value, key) in sorted_list_of_tuples]

— कहा जाता है कि आपीम ने

नहीं, वर्ग कोष्ठक को छोड़ना बेहतर है, क्योंकि sortedवैसे भी सूची को फिर से बनाना होगा, और जीनकंप से पुनर्निर्माण तेज होगा। कोडगॉल्फिंग के लिए अच्छा है, गति के लिए बुरा है। बदसूरत ([])संस्करण रखें ।

— जीन फ़्राँस्वा Fabre

Answer 8

यह अक्सर नामित नाम का उपयोग करने के लिए बहुत उपयोगी हो सकता है । उदाहरण के लिए, आपके पास कुंजी के रूप में 'नाम' का एक शब्दकोष है और मूल्यों के रूप में 'स्कोर' है और आप 'स्कोर' को क्रमबद्ध करना चाहते हैं:

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) को इस तरह से कहेंगे:

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

Comments

मैं इसे वापस शब्दकोश में कैसे बदल सकता हूं?

— राणा

as_list = [खिलाड़ी (v, k) के लिए (k, v) के लिए d.items ()] as_dict = dict (p.name, p.score) में p के लिए as_list)

— रेमी

Answer 9

पाइथन 3.6 के रूप में अंतर्निहित तानाशाही का आदेश दिया जाएगा

अच्छी खबर है, इसलिए ओपी के मूल उपयोग के मामले में एक स्ट्रिंग से एक अद्वितीय स्ट्रिंग आईडी के साथ डेटाबेस से पुनर्प्राप्त मैपिंग जोड़े को मानों और संख्यात्मक मानों के रूप में एक अंतर्निहित पायथन v3.6 + तानाशाही में है, अब सम्मिलित आदेश का सम्मान करना चाहिए।

यदि डेटाबेस क्वेरी से परिणामी दो कॉलम तालिका अभिव्यक्तियाँ कहती हैं जैसे:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

दो पायथन टुपल्स, 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)

इस मामले में उपज (नए अजगर के लिए 3.6+ बिल्ट-इन तानाशाह!):

foo 0
bar 1
baz 42

v के प्रति समान क्रम में।

जहां पायथन 3.5 मेरी मशीन पर स्थापित होता है वहां वर्तमान में इसकी पैदावार होती है:

bar 1
foo 0
baz 42

विवरण:

जैसा कि 2012 में रेमंड हेटिंगर द्वारा प्रस्तावित किया गया था (विषय पर "तेज पुनरावृति के साथ अधिक कॉम्पैक्ट शब्दकोशों" के साथ अजगर-देव पर cf. मेल ) और अब (2016 में) विक्टर स्टिनर द्वारा एक मेल में अजगर के लिए अजगर-देव के लिए एक मेल की घोषणा की गई "पायथन 3.6 तानाशाह। कॉम्पैक्ट और एक निजी संस्करण हो जाता है, और कीवर्ड 27350 " समस्या के कार्यान्वयन / कार्यान्वयन के कारण " कॉम्पैक्ट हो जाते हैं और "आदेश दिया जाता है" पायथन 3.6 में अब हम सम्मिलित आदेश को बनाए रखने के लिए एक अंतर्निहित तानाशाही का उपयोग करने में सक्षम होंगे !!

उम्मीद है कि यह पहले चरण के रूप में एक पतली परत ऑर्डरडेड डिसीजन को लागू करेगा। जैसा कि @ JimFasarakis-Hilliard ने संकेत दिया है, कुछ भविष्य में ऑर्डर किए गए प्रकार के लिए भी मामलों का उपयोग करते हैं। मुझे लगता है कि बड़े पैमाने पर पायथन समुदाय सावधानीपूर्वक निरीक्षण करेगा, अगर यह समय की कसौटी पर खड़ा होगा, और अगले कदम क्या होंगे।

स्थिर आदेश द्वारा खोली गई संभावनाओं को याद न करने के लिए हमारी कोडिंग आदतों पर पुनर्विचार करने का समय:

• कीवर्ड तर्क और
• (इंटरमीडिएट) तानाशाही भंडारण

पहला क्योंकि यह कुछ मामलों में कार्यों और विधियों के कार्यान्वयन में प्रेषण को आसान बनाता है।

दूसरा, क्योंकि यह dictपाइपलाइनों के प्रसंस्करण में मध्यवर्ती भंडारण के रूप में अधिक आसानी से उपयोग करने के लिए प्रोत्साहित करता है ।

रेमंड हेटिंगर ने कृपया अपने सैन फ्रांसिस्को पायथन मीटअप ग्रुप प्रेजेंटेशन 2016-DEC-08 से " द टेक बिहाइंड पायथन 3.6 डिक्शनर्स " - यह समझाते हुए प्रलेखन प्रदान किया ।

और शायद कुछ स्टैक ओवरफ्लो उच्च सजाए गए प्रश्न और उत्तर पृष्ठ इस जानकारी के वेरिएंट प्राप्त करेंगे और कई उच्च गुणवत्ता वाले उत्तर के लिए प्रति संस्करण भी आवश्यकता होगी।

कैविट एम्प्टर (लेकिन 2017-12-15 के अपडेट को भी देखें):

जैसा कि @ajcr सही रूप से नोट करता है: "इस नए कार्यान्वयन का आदेश-संरक्षण पहलू एक कार्यान्वयन विवरण माना जाता है और इस पर भरोसा नहीं किया जाना चाहिए।" ( whatsnew36 से ) नाइट पिकिंग नहीं, लेकिन प्रशस्ति पत्र थोड़ा निराशावादी ;-) कट गया था। यह जारी है "(यह भविष्य में बदल सकता है, लेकिन सभी मौजूदा और भविष्य के पायथन कार्यान्वयनों के लिए ऑर्डर-प्रोटेक्टिंग शब्दार्थों को अनिवार्य करने के लिए भाषा की युक्ति को बदलने से पहले कुछ रिलीज के लिए भाषा में इस नए तानाशाही कार्यान्वयन के लिए वांछित है;" भाषा के पुराने संस्करणों के साथ पीछे-संगतता को संरक्षित करने में मदद करता है जहां यादृच्छिक पुनरावृत्ति क्रम अभी भी प्रभाव में है, उदाहरण के लिए पायथन 3.5)। "

इसलिए कुछ मानव भाषाओं (जैसे जर्मन) में, उपयोग भाषा को आकार देता है, और अब व्हाट्सएवन 36 में ... घोषित किया गया है ।

2017-12-15 अपडेट करें:

अजगर-देव सूची में एक मेल में , गुइडो वैन रोसुम ने घोषणा की:

इसे ऐसा बनाओ। "निर्णय प्रविष्टि आदेश रखता है" सत्तारूढ़ है। धन्यवाद!

इसलिए, संस्करण 3.6 CPython साइड-इफ़ेक्ट ऑफ़ डिसकस इन्सर्टन ऑर्डरिंग अब लैंग्वेज स्पेक (और अब केवल कार्यान्वयन डिटेल नहीं) का हिस्सा बन रहा है। collections.OrderedDictचर्चा के दौरान रेमंड हेटिंगर द्वारा याद दिलाए जाने के लिए उस मेल थ्रेड में कुछ विशिष्ट डिजाइन लक्ष्य भी सामने आए ।

Comments

आपके द्वारा लिंक किए गए 'whatsnew' पृष्ठ पर चेतावनी पर बल दिया जाना चाहिए: इस नए कार्यान्वयन के आदेश-संरक्षण पहलू को कार्यान्वयन विवरण माना जाता है और इस पर भरोसा नहीं किया जाना चाहिए । किसी को यह नहीं मानना ​​चाहिए कि dictप्रकार उनके कोड में प्रविष्टि आदेश का सम्मान करेगा। यह भाषा की परिभाषा का हिस्सा नहीं है और कार्यान्वयन भविष्य की किसी भी रिलीज़ में बदल सकता है। OrderedDictगारंटी आदेश का उपयोग करना जारी रखें ।

— एलेक्स रिले

@ajcr के लिए धन्यवाद, बहुत सराहना की - स्माइली के रूप में और शायद मेरी प्रतिक्रिया में बुने गए थे, ये संकेत दिया जाना चाहिए, परिवर्तन बड़े पैमाने पर है, लेकिन ज़ाहिर है, केवल सीपीथॉन (संदर्भ कार्यान्वयन) और PyPy के लिए उपलब्ध है। पूरी तरह से अलग कुछ के लिए ... मैं गैर-कार्यान्वयन विवरणों से बात करता हूं जब मैन-मशीन निर्देशों को कोड करता हूं। अगर यह केवल ज्योनत ;-) होता ... तो शायद मुझे इसे लिखने की हिम्मत नहीं होती।

— दिलतपंत

OrderedDictनिश्चित रूप से गिराया नहीं जाएगा; इसके बजाय, यह वर्तमान तानाशाही कार्यान्वयन के आसपास एक पतला आवरण बन जाएगा (ताकि आप जोड़ सकें कि यह अधिक कॉम्पैक्ट हो जाएगा)। ImportErrorपाठकों को गुमराह करने के लिए इस स्निपेट को जोड़ना सबसे अच्छा विचार नहीं है, OrderedDictजिसका कोई फायदा नहीं है।

— दिमित्री फासरकिस हिलियार

@ JimFasarakis-Hilliard प्रतिक्रिया के लिए धन्यवाद। "काफी अच्छे विचारों" ने मुझे मुस्कुरा दिया - भविष्य की भविष्यवाणी करना अक्सर कठिन होता है। लेकिन मुझे पसंद है कि आपका सुझाव स्रोतों की जाँच करेगा, इसे आज़माएगा और फिर तदनुसार उत्तर को अपडेट करेगा। एक बार फिर धन्यवाद।

— दिलतन्त

@AlexRiley यह चेतावनी अब सटीक नहीं है। Python3.7 गारंटीकृत शब्दकोश का आदेश दिया।

— जेरिट

Answer 10

मुझे भी यही समस्या थी, और मैंने इसे इस तरह हल किया:

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

(जो लोग जवाब देते हैं "एक तानाशाह को छांटना संभव नहीं है" ने सवाल नहीं पढ़ा? वास्तव में, "मैं कुंजियों पर छँट सकता हूं, लेकिन मैं मूल्यों के आधार पर कैसे छांट सकता हूं?" इसका स्पष्ट अर्थ है कि वह एक सूची चाहता है। कुंजियाँ उनके मान के मान के अनुसार क्रमबद्ध होती हैं।)

कृपया ध्यान दें कि आदेश अच्छी तरह से परिभाषित नहीं किया गया है (उसी मूल्य के साथ कुंजियाँ आउटपुट सूची में एक अनियंत्रित क्रम में होंगी)।

Comments

आप परिणाम से चूक रहे हैं

— Dejell

ध्यान दें कि आप डिक्शनरी और डिस्चार्जिंग मानों को अपनी कुंजी के अनुसार प्रसारित कर रहे हैं, इसलिए प्रदर्शन के लिहाज से यह एक इष्टतम समाधान नहीं है।

— रॉन क्लेन

@ डेजेल: जैसा कि योगदानकर्ता कहता है, वह इस प्रश्न की व्याख्या करता है कि "क्या मैं मूल्यों के अनुसार छांटी गई कुंजी की सूची प्राप्त कर सकता हूं"। हमें परिणाम में मूल्यों की आवश्यकता नहीं है, हम उन्हें शब्दकोश में रखते हैं।

— मैक्स

Answer 11

यदि मान संख्यात्मक हैं, तो आप संग्रह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)]    

Comments

क्या बारे में अगर आप शब्दकोश >>> एक्स = { 'हैलो': 1, 'अजगर': 5, 'दुनिया': 300} है

— जेम्स Sapam

@ चंदवा Counter({'hello':1, 'python':5, 'world':300}).most_common()देता है [('world', 300), ('python', 5), ('hello', 1)]। यह वास्तव में किसी भी सॉर्टेबल मूल्य प्रकार के लिए काम करता है (हालांकि कई अन्य काउंटर ऑपरेशनों को किलों में तुलनीय होने के लिए मूल्यों की आवश्यकता होती है)।

— lvc

Answer 12

पायथन 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

का आनंद लें ;-)

Answer 13

यह कोड है:

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}

Answer 14

निम्नलिखित दृष्टिकोण का प्रयास करें। हमें निम्नलिखित डेटा के साथ एक डिक्शनरी को डिक्शनरी के रूप में परिभाषित करने दें:

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

Comments

बहुत बढ़िया! for key, value in sorted(mydict.iteritems(), key=lambda (k,v): v["score"]):आपको एक उपकुंजी द्वारा क्रमबद्ध करने की अनुमति देता है

— एंडोमर

यह मुझे Python3 में लैम्ब्डा के पास सिंटैक्स त्रुटि देता है

— सुलेमान इलाही

Answer 15

पायथन 3.6 से शुरू, dictवस्तुओं को अब सम्मिलन क्रम द्वारा आदेशित किया जाता है। यह आधिकारिक रूप से पायथन 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।

अजगर 3.7 प्रलेखन कहता है:

संस्करण 3.7 में परिवर्तित: शब्दकोश आदेश प्रविष्टि आदेश होने की गारंटी है। यह व्यवहार 3.6 से CPython का कार्यान्वयन विवरण था।

Comments

बहुत अच्छा काम करता है! dict(sorted(words.items(), key=lambda x: x[1], reverse=True))DESC के लिए

— vizyourdata

Answer 16

आप "उलटा सूचकांक" भी बना सकते हैं

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]

Answer 17

आप संग्रह का उपयोग कर सकते हैं। मुठभेड़ । ध्यान दें, यह संख्यात्मक और गैर-संख्यात्मक दोनों मूल्यों के लिए काम करेगा।

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

Comments

यह इवान सास के जवाब से कैसे अलग है ?

— पीटर मोर्टेंसन

Answer 18

आप स्किप डिक्टेड का उपयोग कर सकते हैं, जो एक ऐसा शब्द है जो स्थायी रूप से मूल्य के अनुसार क्रमबद्ध होता है।

>>> 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()फिर आप मूल्य द्वारा क्रमबद्ध क्रम में पुनरावृति करेंगे।

इसे स्किप लिस्ट डेटास्ट्रक्चर का उपयोग करके लागू किया गया है ।

Comments

क्या हम अभी क्रम बदल सकते हैं, यह ठीक है, लेकिन मैं निर्णय लेना चाहता हूं।

— सुलेमान इलाही

afaik आपको आदेश को उलटने के लिए अपने मूल्यों को नकारना होगा

— mal

वाह, मैं इस तरह लगता है ... धन्यवाद।

— सुलेमान इलाही

Answer 19

आप कस्टम फ़ंक्शन का भी उपयोग कर सकते हैं जो कुंजी को पास किया जा सकता है।

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)

Answer 20

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

Comments

सवाल था: मूल्य के आधार पर छाँटें, कुंजियों से नहीं ... मुझे एक फ़ंक्शन देखना पसंद है। आप संग्रह आयात कर सकते हैं और निश्चित रूप से क्रमबद्ध (data.values ​​())

— रेमी

Answer 21

जैसा कि दिलेटेंट ने बताया , पायथन 3.6 अब आदेश रखेगा ! मैंने सोचा था कि मैं एक समारोह साझा करूँगा जिसमें मैंने लिखा था कि एक पुनरावृत्त (टपल, सूची, तानाशाही) को छांटना आसान है। बाद के मामले में, आप या तो कुंजियों या मूल्यों पर सॉर्ट कर सकते हैं, और यह संख्यात्मक तुलना को ध्यान में रख सकता है। केवल> = 3.6 के लिए!

जब आप एक पुनरावृत्त पर सॉर्ट किए गए का उपयोग करने का प्रयास करते हैं, जो उदाहरण के साथ-साथ स्ट्रिंग्स को भी रखता है, तो सॉर्ट किया गया () विफल हो जाएगा। बेशक आप 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")

Answer 22

यहाँ ज़िप पर d.values()औरd.keys() का उपयोग कर एक समाधान है । इस लिंक के नीचे कुछ पंक्तियाँ हैं (शब्दकोश दृश्य वस्तुओं पर):

यह ज़िप (): जोड़े = ज़िप (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')]

Answer 23

बेशक, याद रखें, आपको उपयोग करने की आवश्यकता है OrderedDictक्योंकि नियमित पायथन शब्दकोश मूल क्रम नहीं रखते हैं।

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

---

यदि आपके पास पायथन 2.7 या उच्चतर नहीं है, तो आप जो सबसे अच्छा कर सकते हैं वह जनरेटर फ़ंक्शन में मूल्यों पर पुनरावृति है। (यहां OrderedDict2.4 और 2.6 के लिए है , लेकिन

क) मुझे नहीं पता कि यह कितनी अच्छी तरह काम करता है

तथा

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)

कृपया याद रखें कि पायथन 3.0 या इसके बाद के संस्करण का उपयोग नहीं करने पर प्रिंट के बाद कोष्ठक को हटा दें

Comments

नियमित पायथन डिक्शनरी मूल आदेश नहीं रखते हैं - जैसा कि पायथन 3.7, वे करते हैं।

— जेरिट

Answer 24

का प्रयोग करें 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)]

Answer 25

यह 3.1.x में काम करता है:

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

Answer 26

बस हर किसी के लिए अजगर से प्रासंगिक कौशल सीखा ।

शब्दकोश को छाँटने में आपकी मदद करने के लिए आप एक अस्थायी सूची का उपयोग कर सकते हैं:

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

Comments

यह मानों द्वारा नहीं, कुंजी द्वारा छंटनी है।

— रूबल

यदि आप इसे प्रारंभिक प्रारूप में प्रिंट करना चाहते हैं तो आपको करना चाहिए: v के लिए प्रिंट ((k, v), k को सॉर्ट किया गया ([(v, k) के लिए k, v में d.items ()]]])। आउटपुट है: [('ऑरेंज', 1.0), ('ऐप्पल', 500.1), ('अनानास', 789.0), ('केला', 1500.2)]। V के लिए [(k, v), k के साथ सॉर्ट किए गए ((v, k) के लिए k, v में d.items ()], रिवर्स = ट्रू)] आउटपुट है: [('केला', 1500.2), ('अनानास', 789.0), ('सेब', 500.1), ('नारंगी', 1.0)]

— हर्मीस मोरालेस

Answer 27

एक तानाशाही के माध्यम से अलग करें और इसे अपने मूल्यों द्वारा अवरोही क्रम में क्रमबद्ध करें:

$ 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

Answer 28

यदि आपके मान पूर्णांक हैं, और आप पायथन 2.7 या नए का उपयोग करते हैं, तो आप collections.Counterइसके बजाय उपयोग कर सकते हैं dict। most_commonविधि आप सभी आइटम, मूल्य के अनुसार क्रमबद्ध दे देंगे।

Answer 29

संपूर्णता के लिए, मैं 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)]

Answer 30

पाइथन के पुराने संस्करणों के साथ पिछड़े हमदर्दी को बनाए रखने की आवश्यकताओं के कारण मुझे लगता है कि ऑर्डरडीडक्ट समाधान बहुत नासमझ है। आप ऐसा कुछ चाहते हैं जो पायथन 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)]