python - मैं मूल्य से एक शब्दकोश कैसे क्रमबद्ध करूं?




sorting dictionary (25)

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

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

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

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

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

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

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


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

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

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

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

SELECT a_key, a_value FROM a_table ORDER BY a_value;

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

इस मामले में उपज (नए पायथन 3.6+ के लिए अंतर्निहित dict!):

foo 0
bar 1
baz 42

वी के प्रति मान एक ही क्रम में।

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

bar 1
foo 0
baz 42

विवरण:

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

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

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

  • कीवर्ड तर्क और
  • (मध्यवर्ती) dict भंडारण

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

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

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

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

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

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

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

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

पाइथन-देव सूची के लिए एक मेल में , गिडो वैन रॉसम ने घोषित किया:

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

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


दिया गया शब्दकोश

e = {1:39, 4:34, 7:110, 2:87}

छंटाई

sred = sorted(e.items(), key=lambda value: value[1])

परिणाम

[(4, 34), (1, 39), (2, 87), (7, 110)]

आप चीजों को मूल्य से क्रमबद्ध करने के लिए एक लैम्ब्डा फ़ंक्शन का उपयोग कर सकते हैं और उन्हें एक चर के अंदर संसाधित कर सकते हैं, इस मामले में मूल शब्दकोश के साथ sred

उम्मीद है की वो मदद करदे!


जैसा कि डिलेट्टन द्वारा इंगित किया गया है , पाइथन 3.6 अब आदेश जारी रखेगा ! मैंने सोचा कि मैं एक ऐसा फ़ंक्शन साझा करूंगा जो मैंने लिखा था जो एक पुनरावृत्त (टुपल, सूची, dict) की छंटाई को आसान बनाता है। बाद के मामले में, आप या तो कुंजी या मानों पर सॉर्ट कर सकते हैं, और यह खाते में संख्यात्मक तुलना ले सकता है। केवल> = 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")

मैं इस के साथ आया था,

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

पायथन 3.x के लिए: x.items() बदल रहा है।

>>> sorted_x
{0: 0, 1: 2, 2: 1, 3: 4, 4: 3}

या collections.OrderedDict साथ प्रयास करें। collections.OrderedDict !

x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
from collections import OrderedDict

od1 = OrderedDict(sorted(x.items(), key=lambda t: t[1]))

हाल ही में पायथन 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]))

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

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

Dicts से ValueSortedDict का उपयोग करें:

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

तकनीकी रूप से, शब्दकोश अनुक्रम नहीं हैं, और इसलिए क्रमबद्ध नहीं किया जा सकता है। आप कुछ ऐसा कर सकते हैं

sorted(a_dictionary.values())

मानते हुए प्रदर्शन एक बड़ा सौदा नहीं है।


हांक गे के जवाब के समान ही बहुत कुछ;

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

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

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


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

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


निम्नलिखित दृष्टिकोण आज़माएं। आइए निम्नलिखित डेटा के साथ मैडिक्ट नामक एक शब्दकोश को परिभाषित करें:

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

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

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


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

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

यह शब्दकोश के भीतर प्रत्येक प्रविष्टि के मानों से शब्दकोश को सबसे छोटे से सबसे बड़े तक सॉर्ट करेगा।


यह शब्दकोश में कुंजी-मूल्य जोड़े की सूची देता है, जो मूल्य से उच्चतम से निम्नतम क्रमबद्ध होता है:

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

कुंजी द्वारा क्रमबद्ध शब्दकोश के लिए, निम्न का उपयोग करें:

sorted(d.items(), reverse=True)

वापसी tuples की एक सूची है क्योंकि शब्दकोश खुद को हल नहीं किया जा सकता है।

यह दोनों मुद्रित या आगे गणना में भेजा जा सकता है।


यदि मान संख्यात्मक हैं तो आप संग्रह से काउंटर का भी उपयोग कर सकते हैं

from collections import Counter

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


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

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

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

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

यदि आपके पास पाइथन 2.7 या उच्चतर नहीं है, तो आप जेनरेटर फ़ंक्शन में मानों पर सबसे अच्छा कर सकते हैं। (यहां 2.4 और 2.6 के लिए ऑर्डर्ड डिक्ट here , लेकिन

a) I don't know about how well it works 

तथा

b) You have to download and install it of course. If you do not have administrative access, then I'm afraid the option's out.)
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 या ऊपर का उपयोग नहीं करते हैं तो प्रिंट के बाद कोष्ठक को निकालना याद रखें


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


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

Dict मूल्यों की एक क्रमबद्ध सूची:

sorted(d.values())

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

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

अद्यतन: पाइथन 3.5 का उपयोग कर 5 दिसंबर 2015

जबकि मुझे स्वीकार्य उत्तर उपयोगी पाया गया, मुझे यह भी आश्चर्य हुआ कि मानक पुस्तकालय संग्रह मॉड्यूल से 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)])

यह कोड है:

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}

आप एक "उलटा इंडेक्स" भी बना सकते हैं

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 उपयोग कर सकते हैं। 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)])

a = [{'name':'Homer', 'age':39}, ...]

# This changes the list a
a.sort(key=lambda k : k['name'])

# This returns a new list (a is not modified)
sorted(a, key=lambda k : k['name']) 




python sorting dictionary