नेस्टेड शब्दकोश में सभी तत्वों को कैसे गिनें?

Question

मैं नेस्टेड शब्दकोश में उपरोक्त संख्याओं को सबसे कुशल तरीके से कैसे गिन सकता हूं? लेन() फ़ंक्शन काम नहीं करता है के रूप में मैं शुरू में यह करने की उम्मीद:

>>> food_colors = {'fruit': {'orange': 'orange', 'apple': 'red', 'banana': 'yellow'}, 'vegetables': {'lettuce': 'green', 'beet': 'red', 'pumpkin': 'orange'}} 
>>> len(food_colors) 
2 
>>> 

क्या होगा यदि मैं वास्तव में उसके उप-तत्व की संख्या की गणना करना चाहते हैं? (उदाहरण के लिए, अपेक्षित परिणाम "6" होना चाहिए) क्या प्रत्येक तत्व के माध्यम से लूपिंग और subelements की qty को संक्षेप में करने के बजाय ऐसा करने का एक बेहतर तरीका है? इस विशेष आवेदन में, मेरे पास गिनने के लिए लगभग पांच मिलियन उपखंड हैं और प्रत्येक घड़ी चक्र की गणना होती है।

Answer 1

क्या यह गारंटी है कि प्रत्येक शीर्ष-स्तरीय कुंजी के शब्दकोश के रूप में एक शब्दकोश है, और कोई दूसरा-स्तरीय कुंजी कोई शब्दकोश नहीं है? यदि ऐसा है, तो आप जितनी तेजी से उम्मीद कर सकते हैं:

sum(len(v) for v in food_colors.itervalues()) 

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

Answer 2

sum(len(x) for x in food_colors.values()) 

Answer 3

क्या आप केवल तत्काल बच्चों को चाहते हैं? यदि हां, तो यह शायद सबसे अच्छा है:

sum(len(x) for x in fc.values()) 

Answer 4

उसके उप-तत्व अलग वस्तुओं रहे हैं, वहाँ कोई अन्य रिश्ते उपयोग करने के लिए है कि उन पर पुनरावृत्ति की तुलना में तेजी मौलिक होगा - हालांकि वहाँ (तरीके कि ऐसा करने के लिए बहुत सारी map का उपयोग कर रहे हैं , या .values(), उदाहरण के लिए) जो प्रदर्शन में भिन्न होंगे, पर्याप्त है कि आप शायद उनकी तुलना करने के लिए timeit का उपयोग करना चाहेंगे।

तो उन्हें गिनती अपने आवेदन के लिए महत्वपूर्ण है, कि आसान बनाने के लिए कुछ चीजें करने पर विचार:,

• उनकी गणना के रूप में आप डेटा संरचना नेस्टेड dict रों के बजाय
• निर्माण एक में स्मृति पर विचार sqlite मेज, connect(":memory:") का उपयोग कर (इस नीचे अन्य कार्यों को धीमा कर सकते हैं, या उन्हें और अधिक जटिल है, लेकिन व्यापार बंद पर विचार के लायक है।)

Answer 5

c = sum([len(i) for i in fruit_colors.values() ]) 

Answer 6

अपने विशिष्ट प्रश्न के लिए, तुम सिर्फ इस का उपयोग कर सकते हैं:

>>> d={'fruit': 
     {'orange': 'orange', 'apple': 'red', 'banana': 'yellow'}, 
     'vegetables': 
     {'lettuce': 'green', 'beet': 'red', 'pumpkin': 'orange'}} 
>>> len(d) 
2   # that is 1 reference for 'fruit' and 1 for 'vegetables' 
>>> len(d['fruit']) 
3   # 3 fruits listed... 
>>> len(d['vegetables']) 
3   # you thought of three of those... 
>>> len(d['fruit'])+len(d['vegetables']) 
6 

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

पायथन के मूल डेटा संरचना lists, sets, tuples, and dictionaries हैं। इन आंकड़ों में से कोई भी संदर्भ, संदर्भ के अनुसार, स्वयं के किसी भी नेस्टेड संस्करण या अन्य डेटा संरचनाओं को 'पकड़' सकता है।

इस सूची में एक nested list है:

>>> l = [1, [2, 3, [4]], [5, 6]] 
>>> len(l) 
3 
>>> l[0] 
1 
>>> l[1] 
[2, 3, [4]] 
>>> l[2] 
[5, 6] 

पहला तत्व पूर्णांक 1. है तत्वों 1 और 2 सूचियों खुद को कर रहे हैं। यह मूल पायथन डेटा संरचनाओं के किसी अन्य के बारे में भी सच हो सकता है। ये recursive data structures हैं।

>>> color='color' 
>>> family='family' 
>>> sensation='sensation' 
>>> good_things={ 
      'fruit': 
      { 
       'orange': 
        { 
        color: 'orange', 
        family: 'citrus', 
        sensation: 'juicy' 
        }, 
       'apple': 
        { 
        color: ['red','green','yellow'], 
        family:'Rosaceae', 
        'sensation': 'woody' 
        }, 
       'banana': 
        { 
        color: ['yellow', 'green'], 
        family: 'musa', 
        sensation: 'sweet' 
        } 
      }, 
      'vegatables': 
      { 
       'beets': 
        { 
        color: ['red', 'yellow'], 
        family: 'Chenopodiaceae', 
        sensation: 'sweet' 
        }, 
       'broccoli': 
        { 
        color: 'green', 
        family: 'kale', 
        sensation: 'The butter you put on it', 
        } 
      } 
     }  

अब जब कि डेटा के खिलाफ प्रश्नों अधिक मतलब:: आप उन pprint

साथ मुद्रित कर सकते हैं आप अपने शब्दकोश थोड़ा बेहतर ढंग से व्यवस्थित है, यह पायथन के सबसे सरल उपकरणों के साथ यह से जानकारी निकालने के आसान है

>>> len(good_things) 
2      # 2 groups: fruits and vegetables 
>>> len(good_things['fruit']) 
3      # three fruits cataloged 
>>> len(good_things['vegetables']) 
2      # I can only think of two vegetables... 
>>> print good_things['fruit']['apple'] 
{'color': ['red', 'green', 'yellow'], 'sensation': 'woody', 'family': 'Rosaceae'} 
>>> len(good_things['fruit']['apple']['color']) 
3      # apples have 3 colors 

Answer 7

आप इसे रिकर्सिव फ़ंक्शन के साथ कर सकते हैं।

>>> x 
{'a': 1, 'b': 2, 'c': 3, 'd': {'I': 1, 'II': 2, 'III': 3}, 'e': 5} 
>>> def test(d): 
... cnt = 0 
... for e in d: 
...  if type(d[e]) is dict: 
...  cnt += test(d[e]) 
...  else: 
...  cnt += 1 
... return cnt 
... 
>>> test(x) 
7 

Answer 8

नेस्टेड मनमाना गहराई शब्दकोशों के लिए:

def num_elements(x): 
    if isinstance(x, dict): 
    return sum([num_elements(_x) for _x in x.values()]) 
    else: return 1