2012-12-04 18 views
6

में बदलना मेरे पास एक बहुत बड़ा शब्दकोश है, शायद 10,000 keys/values और मैं सभी मानों को 0 पर बदलना चाहता हूं। मुझे पता है कि मैं सभी मानों को 0 पर लूप कर सकता हूं और यह हमेशा के लिए ले सकता है। क्या वैसे भी है कि मैं एक साथ सेट सभी मान 0 पर कर सकता हूं?साथ ही एक शब्दकोश के सभी मानों को शून्य पायथन

विधि लूपिंग, बहुत धीमी गति से:

#example dictionary 
a = {'a': 1, 'c': 1, 'b': 1, 'e': 1, 'd': 1, 'g': 1, 'f': 1, 'i': 1, 'h': 1, 'k': 1, 
'j': 1, 'm': 1, 'l': 1, 'o': 1, 'n': 1, 'q': 1, 'p': 1, 's': 1, 'r': 1, 'u': 1, 
't': 1, 'w': 1, 'v': 1, 'y': 1, 'x': 1, 'z': 1} 
for key.value in a.items(): 
    a[key] = 0 

आउटपुट:

{'a': 0, 'c': 0, 'b': 0, 'e': 0, 'd': 0, 'g': 0, 'f': 0, 'i': 0, 'h': 0, 'k': 0, 
'j': 0, 'm': 0, 'l': 0, 'o': 0, 'n': 0, 'q': 0, 'p': 0, 's': 0, 'r': 0, 'u': 0, 
't': 0, 'w': 0, 'v': 0, 'y': 0, 'x': 0, 'z': 0} 
+0

आप अपने कोड प्रोफाइल और इस पाया सीमित कारक होना जरूरी ? 10k वस्तुओं वाला एक शब्दकोश बहुत बड़ा नहीं है। –

+0

इसका इतना आकार नहीं है कि यह कितनी बार है कि मैं शब्दकोशों के माध्यम से लूपिंग करने जा रहा हूं। मैंने इसे लगभग हर सेकेंड के माध्यम से लूप करने के लिए प्रोग्राम किया है और इसके अतिरिक्त, मेरे पास एक से अधिक शब्दकोश नहीं हैं। – enginefree

+0

यदि आप सभी मान निरंतर मेमोरी ब्लॉक में होंगे तो आप सभी मानों को 0 पर सेट कर सकते हैं। मुझे नहीं लगता कि आप इसे बिल्टिन dict के साथ कर सकते हैं ... जब तक कि आप सी –

उत्तर

20

आप dict.fromkeys() हैं:

a = dict.fromkeys(a, 0) 
+0

क्या लूपिंग से कोई तेज है? और मेरा मानना ​​है कि दौड़ते समय यह दो बार स्मृति लेगा, क्योंकि यह एक अलग प्रतिलिपि बना रहा है, सही? – ernie

+1

आश्चर्य की बात है कि, लूपिंग तेज है, आपकी विधि, '10000000 लूप, 3: 0.0226 उपयोगक प्रति लूप ', लूपिंग' 10000000 लूप, 3: 0 का सर्वोत्तम।0224 usec प्रति लूप ' – enginefree

+1

प्रोफाइलिंग के लिए @enginefree धन्यवाद; मैं कल्पना करता हूं कि दोनों समान होना चाहिए क्योंकि आपके मूल लूप और सेकी दोनों ही इटरेटर का उपयोग करते हैं। मुझे लगता है कि एक खाली प्रति स्टोर करने के लिए क्रिएटिवेटा का विचार सबसे अधिक समझ में आता है। – ernie

5

धन्यवाद @akaRem उसकी टिप्पणी :)

a = dict.fromkeys(a.iterkeys(), 0) 
के लिए
+3

चूंकि आपको सभी चाबियों की प्रतिलिपि की आवश्यकता नहीं है, इसलिए 'iterkeys() 'का उपयोग करना बेहतर होगा – akaRem

0

आप जो भी लिखते अपने dict मूल्यों होने की जरूरत है पता है, तो आप कर सकते थे इस:

  1. दुकान एक array.array वस्तु में dict मूल्यों। यह स्मृति के निरंतर ब्लॉक का उपयोग करता है।
  2. dict, बल्कि वास्तविक मान भंडारण सरणी सूचकांक जिस पर वास्तविक मूल्य पाया जा सकता है
  3. शून्य

प्रदर्शन का परीक्षण नहीं किया था का एक सन्निहित बाइनरी स्ट्रिंग के साथ सरणी reinitialize की दुकान की ज्यादा संभावना थी , लेकिन यह तेजी से होना चाहिए ...


import array 

class FastResetDict(object): 

    def __init__(self, value_type): 
     self._key_to_index = {} 
     self._value_type = value_type 
     self._values = array.array(value_type) 

    def __getitem__(self, key): 
     return self._values[self._key_to_index[key]] 

    def __setitem__(self, key, value): 
     self._values.append(value) 
     self._key_to_index[key] = len(self._values) - 1 

    def reset_content_to_zero(self): 
     zero_string = '\x00' * self._values.itemsize * len(self._values) 
     self._values = array.array(self._value_type, zero_string) 



fast_reset_dict = FastResetDict('i') 
fast_reset_dict['a'] = 103 
fast_reset_dict['b'] = -99 

print fast_reset_dict['a'], fast_reset_dict['b'] 
fast_reset_dict.reset_content_to_zero() 
print fast_reset_dict['a'], fast_reset_dict['b'] 
1

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

हो रहा उपयोग सूची समझ से इसे रोकने के लिए:

aDictionary = { x:0 for x in aDictionary} 

नोट: यह केवल 2.7.x और 2.x अनन्य