अजगर - लौटें पहले एन कुंजी: dict

Question

से मान जोड़ों पर विचार करें निम्नलिखित शब्दकोश, डी:

d = {'a': 3, 'b': 2, 'c': 3, 'd': 4} 

मैं पहली बार एन कुंजी लौटना चाहते: d से मान युग्म (एन < = 4 इस मामले में) । ऐसा करने का सबसे प्रभावी तरीका क्या है?

Answer 1

ऐसी कोई चीज़ नहीं है जो "पहली एन" कुंजी है क्योंकि dict याद नहीं है कि कौन सी कुंजी पहले डाली गई थीं।

आप किसी भी n कुंजी-मान जोड़ों हालांकि प्राप्त कर सकते हैं:

n_items = take(n, d.iteritems()) 

यह itertools recipes से take के कार्यान्वयन का उपयोग करता है: ideone

Answer 2

:

from itertools import islice 

def take(n, iterable): 
    "Return first n items of the iterable as a list" 
    return list(islice(iterable, n)) 

ऑनलाइन काम कर यह देखें

पायथन का dict एस का आदेश नहीं दिया गया है, इसलिए यह " पहले एन "चाबियाँ।

collections.OrderedDict कक्षा उपलब्ध है यदि आपको इसकी आवश्यकता है। आप कुशलतापूर्वक के रूप में

import itertools 
import collections 

d = collections.OrderedDict((('foo', 'bar'), (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'))) 
x = itertools.islice(d.items(), 0, 4) 

for key, value in x: 
    print key, value 

itertools.islice आप lazily किसी भी पुनरावर्तक से तत्वों का एक टुकड़ा लेने के लिए अनुमति देता है इसके पहले चार तत्वों मिल सकता है। आप परिणाम चाहते हैं पुन: प्रयोज्य होने के लिए आप एक ऐसी सूची या कुछ और करने के लिए इसे परिवर्तित करने के लिए तो जैसे आवश्यकता होगी:

x = list(itertools.islice(d.items(), 0, 4)) 

Answer 3

आप कई तरीकों से इस एक नंबर से संपर्क कर सकते हैं।

for i in range(4): 
    item = d.popitem() 

Answer 4

शब्दकोशों छँटाई पर PEP 0265 देखें: यदि आदेश में एक चिंता का विषय है कि आप यह कर सकते हैं नहीं है

for key in sorted(d.keys()): 
    item = d.pop(key) 

: अगर आदेश महत्वपूर्ण है कि आप ऐसा कर सकते हैं। फिर उपर्युक्त पुनरावर्तनीय कोड का उपयोग करें।

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

उदा।

import bisect 

kvlist = [('a', 1), ('b', 2), ('c', 3), ('e', 5)] 
bisect.insort_left(kvlist, ('d', 4)) 

print kvlist # [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)] 

Answer 5

यह आपके मामले में 'सबसे अधिक कुशल' पर निर्भर करता है।

तुम सिर्फ एक विशाल शब्दकोश foo के एक अर्द्ध यादृच्छिक नमूने चाहते हैं, foo.iteritems() का उपयोग करें और के रूप में आप की जरूरत है इसे से के रूप में कई मूल्यों ले, यह एक आलसी आपरेशन कि चाबी या वस्तुओं की एक स्पष्ट सूची के निर्माण से बचा जाता है है।

यदि आपको पहले चाबियाँ सॉर्ट करने की आवश्यकता है, तो keys = foo.keys(); keys.sort() या sorted(foo.iterkeys()) जैसे कुछ का उपयोग करने के आसपास कोई रास्ता नहीं है, आपको कुंजी की एक स्पष्ट सूची बनाना होगा। फिर पहले एन keys के माध्यम से टुकड़ा या पुनरावृत्त करें।

बीटीडब्ल्यू आप 'कुशल' तरीके से क्यों परवाह करते हैं? क्या आपने अपना प्रोग्राम प्रोफाइल किया था?यदि आपने नहीं किया है, तो स्पष्ट और का उपयोग पहले समझने में आसान है। संभावना है कि यह बाधा बनने के बिना बहुत अच्छी तरह से करेगा।

Answer 6

कुछ भी पुनर्प्राप्त करने का एक बहुत ही प्रभावी तरीका स्लाइसिंग के साथ सूची या शब्दकोश समझ को जोड़ना है। "के लिए

# Python 2 
first2pairs = {k: mydict[k] for k in mydict.keys()[:2]} 
# Python 3 
first2pairs = {k: mydict[k] for k in list(mydict)[:2]} 

आम तौर पर इस तरह की एक समझ हमेशा तेजी से बराबर की तुलना में चलाने के लिए है: आप आइटम ऑर्डर करने के लिए (आप बस n यादृच्छिक जोड़े चाहते हैं) की जरूरत नहीं है, तो आप इस तरह एक समझ शब्दकोश का उपयोग कर सकते एक्स में वाई "लूप। साथ ही, .keys() का उपयोग करके कुंजीपटल कुंजियों की सूची बनाने और उस सूची को टुकड़ा करने के लिए जब आप नया शब्दकोश बनाते हैं तो आप किसी भी अनावश्यक कुंजी को 'स्पर्श' से बचते हैं।

आप कुंजी (केवल मान) एक सूची समझ की जरूरत नहीं है, तो आप उपयोग कर सकते हैं:

first2vals = [v for v in mydict.values()[:2]] 

आप मान अपनी चाबी के आधार पर हल कर की जरूरत है, यह बहुत ज्यादा मुसीबत नहीं है:

first2vals = [mydict[k] for k in sorted(mydict.keys())[:2]] 

या आप के रूप में अच्छी कुंजी की जरूरत है:

first2pairs = {k: mydict[k] for k in sorted(mydict.keys())[:2]} 

Answer 7

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

n = 2 
{key:value for key,value in d.items()[0:n]} 

Answer 8

शब्दकोश कोई ऑर्डर नहीं रखता है, इसलिए शीर्ष एन कुंजी मूल्य जोड़े लेने से पहले इसे सॉर्ट करने दें।

import operator 
d = {'a': 3, 'b': 2, 'c': 3, 'd': 4} 
d=dict(sorted(d.items(),key=operator.itemgetter(1),reverse=True)) 
#itemgetter(0)=sort by keys, itemgetter(1)=sort by values 

अब हम :, शीर्ष 'एन' तत्वों की बहाली कर इस तरह विधि संरचना का उपयोग कर सकते हैं:

:

def return_top(elements,dictionary_element): 
    '''Takes the dictionary and the 'N' elements needed in return 
    ''' 
    topers={} 
    for h,i in enumerate(dictionary_element): 
     if h<elements: 
      topers.update({i:dictionary_element[i]}) 
    return topers 

फिर शीर्ष 2 तत्वों प्राप्त करने के लिए बस इस संरचना का उपयोग

d = {'a': 3, 'b': 2, 'c': 3, 'd': 4} 
d=dict(sorted(d.items(),key=operator.itemgetter(1),reverse=True)) 
d=return_top(2,d) 
print(d) 

Answer 9

foo = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6} 
iterator = iter(foo.items()) 
for i in range(3): 
    print(next(iterator)) 

असल में, दृश्य (dict_items) को एक पुनरावर्तक में बदलें, और उसके बाद इसे अगले() के साथ पुन: चालू करें।

Answer 10

अजगर 3 के लिए और इसके बाद के संस्करण, का चयन करने के पहले n जोड़े

n=4 
firstNpairs = {k: Diction[k] for k in list(Diction.keys())[:n]}