आप एक शब्दकोष से आइटम को कैसे क्रमबद्ध करते हैं, उसे पुनर्प्राप्त करते हैं?

Question

क्या पाइथन शब्दकोश से आइटम को पुनर्प्राप्त करने के क्रम में आइटम पुनर्प्राप्त करना संभव है?

Answer 1

मानक पायथन dict ऐसा करने में सक्षम नहीं है।

मानक लाइब्रेरी में collections मॉड्यूल में "आदेशित शब्दकोश" (जो प्रविष्टि के क्रम का ट्रैक रखता है) जोड़ने के लिए एक प्रस्ताव (PEP 372) है। इसमें variousimplementationsofordereddictionaries के लिंक शामिल हैं (पाइथन कुकबुक में इन tworecipes को भी देखें)।

यदि आप चाहते हैं कि आपका कोड "आधिकारिक" संस्करण (यदि प्रस्ताव अंततः स्वीकार किया गया हो) के साथ संगत हो, तो आप पीईपी में संदर्भ कार्यान्वयन के साथ रहना चाहेंगे।

संपादित करें: पीईपी स्वीकार किया गया और पायथन 2.7 और 3.1 में जोड़ा गया। the docs देखें।

Answer 2

आप बेस डॉट क्लास के साथ ऐसा नहीं कर सकते - यह हैश द्वारा आदेश दिया गया है। आप अपना खुद का शब्दकोश बना सकते हैं जो वास्तव में कुंजी, मूल्य जोड़े या somesuch की एक सूची है, जिसे आदेश दिया जाएगा।

Answer 3

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

class ordered_dict(dict): 
    def __init__(self, *args, **kwargs): 
     dict.__init__(self, *args, **kwargs) 
     self._order = self.keys() 

    def __setitem__(self, key, value): 
     dict.__setitem__(self, key, value) 
     if key in self._order: 
      self._order.remove(key) 
     self._order.append(key) 

    def __delitem__(self, key): 
     dict.__delitem__(self, key) 
     self._order.remove(key) 

    def order(self): 
     return self._order[:] 

    def ordered_items(self): 
     return [(key,self[key]) for key in self._order] 


od = ordered_dict() 
od["hello"] = "world" 
od["goodbye"] = "cruel world" 
print od.order()   # prints ['hello', 'goodbye'] 

del od["hello"] 
od["monty"] = "python" 
print od.order()   # prints ['goodbye', 'monty'] 

od["hello"] = "kitty" 
print od.order()   # prints ['goodbye', 'monty', 'hello'] 

print od.ordered_items() 
# prints [('goodbye','cruel world'), ('monty','python'), ('hello','kitty')] 

Answer 4

अगर आप की जरूरत नहीं है dict कार्यक्षमता, और केवल आपके द्वारा डाले गए क्रम में tuples को वापस करने की आवश्यकता है, कतार एक बेहतर काम नहीं करेगा?

Answer 5

मैंने अच्छी सफलता के साथ पहले स्थिर योग्यता का उपयोग किया है।

http://pypi.python.org/pypi/StableDict/0.2

Answer 6

या, बस time.now() टपल में पहले क्षेत्र के रूप में के साथ कुंजी एक टपल बनाते हैं।

फिर आप dictname.keys(), sort, और voila के साथ कुंजी पुनर्प्राप्त कर सकते हैं!

गेरी

Answer 7

यह जब तक आप बाद में संदर्भित करने के लिए एक अलग सूची में कुंजी की दुकान संभव नहीं है।

Answer 8

या PEP-372 के लिए कार्यान्वयन से किसी का उपयोग pythonutils से here वर्णित है, odict module की तरह।

मैंने सफलतापूर्वक पोको का उपयोग किया।org कार्यान्वयन, यह आपके साथ

my_dict={} 
my_dict["foo"]="bar" 

my_dict=odict.odict() 
my_dict["foo"]="bar" 

की जगह के रूप में आसान है और आवश्यकता होती है सिर्फ this file

Answer 9

आप क्या कर सकते, एक महत्वपूर्ण आदेश inputted का प्रतिनिधित्व करने के साथ मूल्यों सम्मिलित है और फिर आइटम पर sorted() पर कॉल करें।

>>> obj = {} 
>>> obj[1] = 'Bob' 
>>> obj[2] = 'Sally' 
>>> obj[3] = 'Joe' 
>>> for k, v in sorted(obj.items()): 
...  print v 
... 
Bob 
Sally 
Joe 
>>> 

Answer 10

उपयोग OrderedDict(), संस्करण 2.7

जिज्ञासा की बस एक बात के बाद से उपलब्ध:

from collections import OrderedDict 
a = {} 
b = OrderedDict() 
c = OredredDict() 

a['key1'] = 'value1' 
a['key2'] = 'value2' 

b['key1'] = 'value1' 
b['key2'] = 'value2' 

c['key2'] = 'value2' 
c['key1'] = 'value1' 

print a == b #True 
print a == C#True 
print b == C#False