मैं कुंजी द्वारा एक शब्दकोश कैसे सॉर्ट कर सकता हूं?

Question

क्या से जाने के लिए एक अच्छा तरीका होगा {2:3, 1:89, 4:5, 3:0}करने के लिए {1:89, 2:3, 3:0, 4:5}?
मैंने कुछ पदों की जाँच की लेकिन वे सभी "सॉर्ट किए गए" ऑपरेटर का उपयोग करते हैं जो ट्यूपल्स लौटाते हैं।

Comments

शब्दकोश आंतरिक रूप से अनसुलझी हैं। शब्दकोश प्रदर्शित करना दूसरी बात है। वैसे भी, क्या आप वास्तव में इसके लिए सॉर्ट करने की आवश्यकता है?

— कार्ल केनटेल

शब्दकोशों को क्रमबद्ध नहीं किया गया है। वे बस यदि आप तत्वों के माध्यम से जाना चाहते हैं, तो आपको कुछ ऐसा करना होगा जैसा आपने कहा था जैसे "सॉर्ट किए गए में कुंजी के लिए" (d.keys ()) "d" आपके शब्दकोश का नाम है

— रयान हेनिंग

@KarlKnechtel - मेरा उपयोग मामला यह है कि मेरे पास एक सीएलआई एप्लिकेशन है जिसमें एक आदिम मेनू है और मेनू विकल्प कुंजी के रूप में एक शब्दकोश में हैं। मैं उपयोगकर्ता की पवित्रता के लिए वर्णानुक्रम में कुंजियों को प्रदर्शित करना चाहूंगा।

— रैंडी

शब्दकोश में

— nbro

ध्यान दें कि डक्ट्स अब प्रविष्टि क्रम (अजगर 3.6+) द्वारा आदेशित हैं। नीचे दिए गए कुछ जवाब इस ओर इशारा करते हैं।

— मत्तीस

Answer 1

मानक पायथन शब्दकोश अनियंत्रित हैं। यहां तक ​​कि अगर आपने जोड़े (कुंजी, मूल्य) जोड़े को सॉर्ट किया है, तो आप उन्हें dictइस तरह से स्टोर करने में सक्षम नहीं होंगे जो ऑर्डर को संरक्षित करेंगे।

उपयोग करने का सबसे आसान तरीका है OrderedDict, जो उन तत्वों को सम्मिलित करने के क्रम को याद रखता है:

In [1]: import collections

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

In [3]: od = collections.OrderedDict(sorted(d.items()))

In [4]: od
Out[4]: OrderedDict([(1, 89), (2, 3), (3, 0), (4, 5)])

कभी भी इस बात का ध्यान न रखें कि odइसका प्रिंट आउट क्या है; यह उम्मीद के मुताबिक काम करेगा:

In [11]: od[1]
Out[11]: 89

In [12]: od[3]
Out[12]: 0

In [13]: for k, v in od.iteritems(): print k, v
   ....: 
1 89
2 3
3 0
4 5

अजगर ३

पायथन 3 उपयोगकर्ताओं के लिए, .items()इसके बजाय एक का उपयोग करने की आवश्यकता है .iteritems():

In [13]: for k, v in od.items(): print(k, v)
   ....: 
1 89
2 3
3 0
4 5

Comments

मैंने इसका इस्तेमाल किया और यह काम करता है, मुझे लगता है कि यह अधिक कोड और अतिरेक है, लेकिन काम हो जाता है, # अनियंत्रित तानाशाही d = {2: 3, 1:89, 4: 5, 3: 0} आदेश दिया गया = {} क्रम में कुंजी के लिए। (d.iterkeys ()): orderedDict [कुंजी] = डी [कुंजी]

— एंटनी

@achrysochoou: अगर वह काम किया है, यह सरासर किस्मत से होना चाहिए था। जैसा कि आपको बताया गया है, नियमित शब्दकोशों में छँटाई की कोई अवधारणा नहीं है, चाहे आप छँटाई या यादृच्छिक तरीके से असाइन करें।

— रिकार्डो कॉर्डेंस

अजगर 3.7+ के लिए:sorted_dict = dict(sorted(unsorted_dict.items()))

— aksh1618

अजगर 3.7+ को ऑर्डर की आवश्यकता नहीं होनी चाहिए क्योंकि यह अब डिफ़ॉल्ट रूप से ऑर्डर करता है :-)

— Anueway

पायथॉन 3.7.4 मैनुअल से: "डिक्शनरी पर सूची (डी) एक डिक्शनरी में, डिक्शनरी ऑर्डर में इस्तेमाल की जाने वाली सभी कुंजियों की एक सूची देता है"। इसलिए प्रविष्टि क्रम कुछ है जो संरक्षित है और हम इस पर भरोसा कर सकते हैं।

— मुस्तफा हादियन

Answer 2

खुद डिक्शनरी ने आइटम ऑर्डर नहीं किए हैं, जैसे कि क्या आप उन्हें किसी ऑर्डर पर प्रिंट करना चाहते हैं, यहां कुछ उदाहरण दिए गए हैं:

पायथन में 2.4 और इसके बाद के संस्करण:

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

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

देता है:

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

(2.4 से नीचे पायथन) :)

keylist = mydict.keys()
keylist.sort()
for key in keylist:
    print "%s: %s" % (key, mydict[key])

स्रोत: http://www.saltycrane.com/blog/2007/09/how-to-sort-python-dEDIA-by-keys/

Comments

तुम भी आदेश में उपयोग कर सकते हैं python 2.4+ में NPE के जवाब के रूप में

— radtek

और यदि आप आइटम का उपयोग कर रहे हैं () तो आप इसे पसंद कर सकते हैंfor key, value in sorted(mydict.items())"

— beep_check

खुद डिक्शनरी ने इस तरह के आइटम ऑर्डर नहीं किए हैं -> अब सच नहीं है!

— मेराज

कैसे आए, आप समझा सकते हैं?

— जेम्स

Answer 3

से पायथन के collectionsपुस्तकालय प्रलेखन :

>>> from collections import OrderedDict

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

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

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

>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

Comments

बहुत बढ़िया! दोस्तों अगर आप ऑर्डर को उलटना चाहते हैं (आरोही पर चढ़ना) तो आप बस reverse=Trueउदाहरण के लिए जोड़ देंOrderedDict(sorted(d.items(), reverse=True, key=lambda t: t[0]))

— benscabbia

PyCharm में, कोई फर्क नहीं पड़ता कि मैं किस शब्दकोश का उपयोग करता हूं, मुझे हमेशा यह चेतावनी मिलती है:Unexpected type(s): (List[str]) Possible types: (Mapping) (Iterable[Tuple[Any, Any]])

— Euler_Salter

Answer 4

CPython / PyPy 3.6 और किसी भी Python 3.7 या उच्चतर के लिए, यह आसानी से किया जाता है:

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

Comments

उसी चीज को लिखने का एक और तरीका एक समझ का उपयोग करना है: {key:d[key] for key in sorted(d.keys())}

— flow2k

Answer 5

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

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

>>> from sortedcontainers import SortedDict
>>> d = {2:3, 1:89, 4:5, 3:0}
>>> s = SortedDict(d)
>>> s.items()
[(1, 89), (2, 3), (3, 0), (4, 5)]

SortedDict प्रकार भी अनुक्रमणित स्थान लुक्स और विलोपन का समर्थन करता है जो अंतर्निहित तानाशाही प्रकार के साथ संभव नहीं है।

>>> s.iloc[-1]
4
>>> del s.iloc[2]
>>> s.keys()
SortedSet([1, 2, 4])

Answer 6

सीधे शब्दों में:

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

for k,v in sd:
    print k, v

आउटपुट:

1 89
2 3
3 0
4 5

Comments

sdtuples की सूची है, शब्दकोश नहीं। (अभी भी उपयोगी है।)

— nischi

Answer 7

जैसा कि दूसरों ने उल्लेख किया है, शब्दकोश स्वाभाविक रूप से अव्यवस्थित हैं। हालाँकि, यदि समस्या केवल एक क्रमबद्ध तरीके से शब्दकोशों को प्रदर्शित करने की है , तो आप __str__एक शब्दकोश उप-विधि में विधि को ओवरराइड कर सकते हैं , और बिलियन के बजाय इस शब्दकोश वर्ग का उपयोग कर सकते हैं dict। उदाहरण के लिए।

class SortedDisplayDict(dict):
   def __str__(self):
       return "{" + ", ".join("%r: %r" % (key, self[key]) for key in sorted(self)) + "}"


>>> d = SortedDisplayDict({2:3, 1:89, 4:5, 3:0})
>>> d
{1: 89, 2: 3, 3: 0, 4: 5}

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

Answer 8

एक और तरीका मिला:

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

अद्यतन:
1. यह भी नेस्टेड वस्तुओं (धन्यवाद @DanielF) को सॉर्ट करता है।
2. अजगर शब्दकोश अनियंत्रित हैं इसलिए यह प्रिंट के लिए ही संभव है या केवल स्ट्रेट को असाइन करना है।

Comments

लेकिन यह नेस्टेड ऑब्जेक्ट्स की कुंजियों को भी छांटता है, जो संभव नहीं है।

— डैनियल एफ

ध्यान दें कि यह केवल शब्दकोशों को सूचीबद्ध करता है, सूचियों को नहीं, उदाहरण के लिए श्रुतलेख () को क्रमबद्ध नहीं किया जाएगा क्योंकि यह एक सूची है।

— एंड्रयू

Answer 9

पायथन 3 में।

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

देता है

1 89
2 3
3 0
4 5

Answer 10

Python 3.6 के पहले Python डिक्शनरी अनियंत्रित थी। पायथन 3.6 के CPython कार्यान्वयन में, शब्दकोश प्रविष्टि क्रम रखता है। पायथन 3.7 से, यह एक भाषा सुविधा बन जाएगी।

पायथन 3.6 के चैंज में ( https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict ):

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

Python 3.7 के दस्तावेज़ में ( https://docs.python.org/3.7/tutorial/datastructures.html## )

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

तो पिछले संस्करणों के विपरीत, आप पायथन 3.6 / 3.7 के बाद एक तानाशाह को सॉर्ट कर सकते हैं। यदि आप उप-तानाशाही सहित किसी नेस्टेड को सॉर्ट करना चाहते हैं, तो आप कर सकते हैं:

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

def dict_reorder(item):
    return {k: sort_dict(v) if isinstance(v, dict) else v for k, v in sorted(item.items())}

reordered_dict = dict_reorder(test_dict)

https://gist.github.com/ligyxy/f60f0374defc383aa098d44cfbd318eb

Answer 11

यहाँ मुझे कुछ सरल उपाय मिले जिन्हें कुंजी द्वारा प्रयोग करके अजगर को क्रमबद्ध करना है pprint। जैसे।

>>> x = {'a': 10, 'cd': 20, 'b': 30, 'az': 99} 
>>> print x
{'a': 10, 'b': 30, 'az': 99, 'cd': 20}

लेकिन प्रिंट का उपयोग करते समय यह क्रमबद्ध रूप से वापस आ जाएगा

>>> import pprint 
>>> pprint.pprint(x)
{'a': 10, 'az': 99, 'b': 30, 'cd': 20}

Answer 12

शब्दकोश को छाँटने का एक आसान तरीका है।

अपने प्रश्न के अनुसार,

समाधान है:

c={2:3, 1:89, 4:5, 3:0}
y=sorted(c.items())
print y

(जहाँ c, आपके शब्दकोष का नाम है।)

यह कार्यक्रम निम्नलिखित आउटपुट देता है:

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

जैसे तुम चाहते थे

एक और उदाहरण है:

d={"John":36,"Lucy":24,"Albert":32,"Peter":18,"Bill":41}
x=sorted(d.keys())
print x

आउटपुट देता है:['Albert', 'Bill', 'John', 'Lucy', 'Peter']

y=sorted(d.values())
print y

आउटपुट देता है:[18, 24, 32, 36, 41]

z=sorted(d.items())
print z

आउटपुट देता है:

[('Albert', 32), ('Bill', 41), ('John', 36), ('Lucy', 24), ('Peter', 18)]

इसलिए इसे कुंजियों, मूल्यों और वस्तुओं में बदलकर, आप यह प्रिंट कर सकते हैं कि आप क्या चाहते हैं। यह मदद करता है!

Answer 13

आप जैसा चाहते हैं वैसा ही उत्पन्न करेंगे:

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

 sort_dic = {}

 for i in sorted(D1):
     sort_dic.update({i:D1[i]})
 print sort_dic


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

लेकिन ऐसा करने का यह सही तरीका नहीं है, क्योंकि, यह विभिन्न शब्दकोशों के साथ एक अलग व्यवहार दिखा सकता है, जिसे मैंने हाल ही में सीखा है। इसलिए टिम ने मेरी क्वेरी के जवाब में सही तरीका सुझाया है जिसे मैं यहां साझा कर रहा हूं।

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

Comments

"विभिन्न शब्दकोशों के साथ एक विशिष्ट व्यवहार" का क्या अर्थ है? "विशिष्ट व्यवहार" क्या है जिसे हल किया जा सकता है?

— पहुंचना

Answer 14

मुझे लगता है कि सबसे आसान काम यह है कि कुंजी को सॉर्ट करके सॉर्ट करें और सॉर्ट की हुई चाबी को सेव करें: वैल्यू पेयर को नए डिक्टेट में।

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be neccessary
        dict2[key] = dict1[key]

इसे स्पष्ट करने के लिए:

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted     values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be  neccessary
        value = dict1[key]
        dict2[key] = value

Answer 15

आप अपने प्रश्न के अनुसार वर्तमान शब्दकोश को कुंजी द्वारा क्रमबद्ध करके एक नया शब्दकोश बना सकते हैं।

यह आपका शब्दकोश है

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

Lambda फ़ंक्शन का उपयोग करके इस d को सॉर्ट करके एक नया शब्दकोश d1 बनाएं

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

d1 {1: 89, 2: 3, 3: 0, 4: 5} होना चाहिए, d में कुंजियों के आधार पर क्रमबद्ध।

Answer 16

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

आप जो चाहते हैं, उसे करने का सबसे सरल तरीका collections.OrderedDictतत्वों को क्रमबद्ध क्रम में सम्मिलित करना होगा ।

ordered_dict = collections.OrderedDict([(k, d[k]) for k in sorted(d.keys())])

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

कुंजी द्वारा छपे प्रिंट मूल्य:

# create the dict
d = {k1:v1, k2:v2,...}
# iterate by keys in sorted order
for k in sorted(d.keys()):
    value = d[k]
    # do something with k, value like print
    print k, value

कुंजियों द्वारा क्रमबद्ध मूल्यों की सूची प्राप्त करें:

values = [d[k] for k in sorted(d.keys())]

Comments

for k,value in sorted(d.items()):बेहतर है: टाल dict पाश में फिर से कुंजी के द्वारा तक पहुँचने

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

Answer 17

मैं सिंगल लाइन तानाशाही छँटाई के साथ आता हूँ।

>> a = {2:3, 1:89, 4:5, 3:0}
>> c = {i:a[i] for i in sorted(a.keys())}
>> print(c)
{1: 89, 2: 3, 3: 0, 4: 5}
[Finished in 0.4s]

आशा है कि यह मददगार होगा।

Answer 18

यह फ़ंक्शन अपनी कुंजी द्वारा किसी भी शब्दकोश को पुनरावर्ती रूप से सॉर्ट करेगा । यही है, अगर शब्दकोश में कोई भी मूल्य भी एक शब्दकोष है, तो यह भी इसकी कुंजी द्वारा हल किया जाएगा। यदि आप CPython 3.6 या अधिक पर चल रहे हैं, तो एक का उपयोग करने के dictबजाय एक साधारण परिवर्तन की तुलना में किया OrderedDictजा सकता है।

from collections import OrderedDict

def sort_dict(d):
    items = [[k, v] for k, v in sorted(d.items(), key=lambda x: x[0])]
    for item in items:
        if isinstance(item[1], dict):
            item[1] = sort_dict(item[1])
    return OrderedDict(items)
    #return dict(items)

Answer 19

दोस्तों आप चीजों को जटिल बना रहे हैं ... यह वास्तव में सरल है

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

आउटपुट है:

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

Comments

अपवित्र क्योंकि मुझे नहीं पता था कि उन्हें टाइप करने के लिए शब्दकोष टाइप किए गए हैं, लेकिन ओपी ने वास्तव में अनसोल्ड से सॉर्ट किए गए कमांड से "जाने" के बारे में पूछा है, ओपी ऐसा लगता है कि कुछ ऐसा है जो स्मृति में क्रमबद्ध रहता है, शायद कुछ एल्गोरिथ्म के लिए जिसे सॉर्ट कीज़ की आवश्यकता होती है

— कप्तान लेप्टान

यह विधि जंजीर असाइनमेंट की अनुमति नहीं देगी क्योंकि पाइंट रिटर्न कोई भी नहीं है। >>> adict = {'B': 1, 'A': 2, 'C': 3} >>> ppdict = pprint (adict) {'A': 2, 'B': 1, 'C': 3} >>> ppdict.type () ट्रैसबैक (सबसे हालिया कॉल अंतिम): फ़ाइल "<stdin>", पंक्ति 1, में <मॉड्यूल> विशेषता गुण: 'कोई नहीं' ऑब्जेक्ट का कोई गुण 'प्रकार' नहीं है

Answer 20

सबसे सरल समाधान यह है कि आपको एक तानाशाही कुंजी की एक सूची मिलनी चाहिए जो क्रमबद्ध हो और फिर तानाशाही पर पुनरावृति हो। उदाहरण के लिए

a1 = {'a':1, 'b':13, 'd':4, 'c':2, 'e':30}
a1_sorted_keys = sorted(a1, key=a1.get, reverse=True)
for r in a1_sorted_keys:
    print r, a1[r]

निम्नलिखित उत्पादन (अवरोही क्रम) होगा

e 30
b 13
d 4
c 2
a 1

Answer 21

ऐसा करने का एक आसान तरीका:

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

s = {k : d[k] for k in sorted(d)}

s

Out[1]: {1: 89, 2: 3, 3: 0, 4: 5} 

Answer 22

2.7 में दो तरीकों की समय की तुलना उन्हें लगभग समान दिखाती है:

>>> setup_string = "a = sorted(dict({2:3, 1:89, 4:5, 3:0}).items())"
>>> timeit.timeit(stmt="[(k, val) for k, val in a]", setup=setup_string, number=10000)
0.003599141953657181

>>> setup_string = "from collections import OrderedDict\n"
>>> setup_string += "a = OrderedDict({1:89, 2:3, 3:0, 4:5})\n"
>>> setup_string += "b = a.items()"
>>> timeit.timeit(stmt="[(k, val) for k, val in b]", setup=setup_string, number=10000)
0.003581275490432745 

Answer 23

from operator import itemgetter
# if you would like to play with multiple dictionaries then here you go:
# Three dictionaries that are composed of first name and last name.
user = [
    {'fname': 'Mo', 'lname': 'Mahjoub'},
    {'fname': 'Abdo', 'lname': 'Al-hebashi'},
    {'fname': 'Ali', 'lname': 'Muhammad'}
]
#  This loop will sort by the first and the last names.
# notice that in a dictionary order doesn't matter. So it could put the first name first or the last name first. 
for k in sorted (user, key=itemgetter ('fname', 'lname')):
    print (k)

# This one will sort by the first name only.
for x in sorted (user, key=itemgetter ('fname')):
    print (x)

Answer 24

dictionary = {1:[2],2:[],5:[4,5],4:[5],3:[1]}

temp=sorted(dictionary)
sorted_dict = dict([(k,dictionary[k]) for i,k in enumerate(temp)])

sorted_dict:
         {1: [2], 2: [], 3: [1], 4: [5], 5: [4, 5]}

Answer 25

या उपयोग करें pandas ,

डेमो:

>>> d={'B':1,'A':2,'C':3}
>>> df=pd.DataFrame(d,index=[0]).sort_index(axis=1)
   A  B  C
0  2  1  3
>>> df.to_dict('int')[0]
{'A': 2, 'B': 1, 'C': 3}
>>> 

देख:

इस के डॉक्स

पूरे पंडों का दस्तावेजीकरण

Answer 26

मेरा सुझाव यह है क्योंकि यह आपको एक आदेश को क्रमबद्ध करने की अनुमति देता है या एक तानाशाही क्रमबद्ध रखता है जैसा कि आप आइटम जोड़ रहे हैं और भविष्य में आइटम जोड़ने की आवश्यकता हो सकती है:

dictस्क्रैच से बनाएँ जैसा कि आप साथ चलते हैं। अपनी चाबियों की सूची के साथ एक दूसरी डेटा संरचना, एक सूची रखें। बाइसेक्ट पैकेज में एक इंसर्ट फंक्शन होता है जो सॉर्ट की गई लिस्ट में डालने की अनुमति देता है, या आपके डिक्ट्यू को पूरी तरह से पॉपुलेट करने के बाद आपकी लिस्ट को सॉर्ट करता है। अब, जब आप अपने तानाशाह पर पुनरावृत्ति करते हैं, तो आप इसके बजाय सूची में प्रत्येक कुंजी का उपयोग करने के लिए सूची में पुनरावृति करते हैं, जो कि तानाशाही संरचना के प्रतिनिधित्व की चिंता किए बिना (जो छंटाई के लिए नहीं की गई थी)।

Answer 27

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

for listitem in l:
    print(listitem)

Comments

14 अन्य उत्तर हैं। क्या आप अपने कोड को थोड़ा समझा सकते हैं और यह अन्य समाधानों से बेहतर क्यों हो सकता है?

— फेलिक्सएसएफडी

डाउनवोटेड - लघु अपठनीय कोड जिसका अर्थ है छोटे अर्थहीन चर नाम l, l2, l3। अजगर मानक कार्यों की जानकारी के बिना एक अप्रत्यक्ष और अक्षम एल्गोरिथ्म में एक प्रयास लगता है, और मूल पोस्ट में छोटे उदाहरण पर परीक्षण किए जाने पर किसी भी मामले में काम नहीं करता है।

— कैप्टन लेप्टन