अजगर: से अधिक पुनरावृति शब्दकोश द्वारा कुंजी

Question

अनुसार क्रमबद्ध मैं एक अजगर शब्दकोश

steps = {1:"value1", 5:"value2", 2:"value3"} 

मैं दोहराना चाहते पर इस कुंजी के द्वारा आदेश सॉर्ट हो जाता है की जरूरत है।

मैं इस कोशिश की:

x = sorted(steps, key=lambda key: steps[key]) 

लेकिन मूल्यों एक्स से चले गए हैं।

Answer 1

I need to iterate over this is sorted order by the key.

मुझे लगता है कि lambdas यहाँ overkill है, इस प्रयास करें: आपके उपयोग के मामले के आधार पर

>>> steps = {1:"val1", 5:"val2", 2:"val3"} 
>>> 
>>> for key in sorted(steps): 
...  print steps[key] 
... 
val1 
val3 
val2 

Answer 2

आपको steps.items() से अधिक पुनरावृत्त करने की आवश्यकता है, क्योंकि dict पर एक पुनरावृत्ति केवल इसकी चाबियाँ लौटाती है।

>>> x = sorted(steps.items()) 
>>> x 
[(1, 'value1'), (2, 'value3'), (5, 'value2')] 

क्रमबद्ध चाबियाँ पर दोहराएं:

>>> for key in sorted(steps): 
...  # use steps[keys] to get the value 

Answer 3

, यह एक विकल्प हो सकता है पहले से ही आदेश दिया गया शब्दकोश पकड़ने के लिए। विवरण के लिए pythons OrderedDict देखें। यदि आप कुंजी को पूर्णांक के रूप में सॉर्ट करना चाहते हैं, तो आपको उन्हें पूर्णांक में परिवर्तित करना होगा। ऐसा करने का सबसे अच्छा क्षण आपके उपयोग के मामले पर निर्भर करता है।

Answer 4

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

आपके मामले में तो, आप उपयोग करेंगे: कुंजियों/मूल्यों/मदों के लिए

from sortedcontainers import SortedDict 
steps = SortedDict({1:"value1", 5:"value2", 2:"value3"}) 

# Then iterate the items: 

for key, value in steps.items(): 
    print key, value 

# Or iterate the values: 

for value in steps.values(): 
    print value 

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

Answer 5

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

steps = {1:"val1", 5:"val2", 2:"val3"} 

for key in sorted(steps): 
    print steps[key] 
... 
val1 
val3 
val2 

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

steps = {randint(0, 100000): randint(0, 100000) for _ in range(100000) } # random dict 

%%timeit 
sort_list = [value for _, value in sorted(steps.items(), key=lambda item: item[0])] 
1 loops, best of 3: 241 ms per loop 

%%timeit 
sort_list = [steps[k] for k in sorted(steps, key=lambda k: k)] 
1 loops, best of 3: 196 ms per loop 

%%timeit 
sort_list = [ steps[key] for key in sorted(steps) ] 
10 loops, best of 3: 106 ms per loop 

Answer 6

मामले में अपनी चाबी पूर्णांकों, लेकिन तार नहीं है कि पूर्णांक के रूप में पार्स किया जाना चाहिए रहे हैं:

steps = {'1':'value1', '10': 'value0', '5':'value2', '2':'value3'} 

आप अपने समाधान के लिए कुछ इसी तरह का उपयोग कर सकते हैं: तो फिर कैसे करना

for key, value in sorted(steps, key=lambda key: int(key[0])): 
    print(key) 

1 
2 
5 
10