यादृच्छिक "int सबस्क्रिप्ट करने योग्य नहीं है" व्यवहार

Question

मैं एक वैध JSON फ़ाइल (5 स्तरों को घोंसला घोंसला) पढ़ रहा हूं, फिर इसमें कुछ डेटा जोड़ रहा हूं, और बाद में कुछ गणनाओं के लिए उस डेटा का उपयोग करने का प्रयास कर रहा हूं।

मुझे यादृच्छिक फैशन में int is not subscriptable त्रुटियां मिल रही हैं। मैं इसके चारों ओर अपने सिर लपेट नहीं सकता। str() पर कास्टिंग करने में मदद नहीं करता है, pprint के साथ प्रिंटिंग इसे कम नहीं करता है, इनपुट पर int() पर कास्टिंग या तो मदद नहीं करता है। मैं सख्त विकल्पों में से बाहर चल रहा हूँ ...

मुख्य कार्य

with open(rNgram_file, 'r', encoding='utf-8') as ngram_file: 
    data = json.load(ngram_file) 
    data = rank_items(data) 
    data = probability_items(data) 

rank_items (डेटा)

सभी मान 5-नेस्ट किए गए स्तर पर गिने जाते हैं, और कहा पेड़ में ऊपर काम कर रहे हैं। मैंने int() को संभावित समाधान के रूप में इनपुट में डाला, लेकिन इससे मदद नहीं मिली। मुद्दा x_grams['_rank']

for ngram, one_grams in data.items(): 
     ngram_rank = 0 
     for one_gram, two_grams in one_grams.items(): 
      one_gram_rank = 0 
      [..] 
       for four_gram, values in four_grams.items(): 
       # 4gram = of, values = 34 
       three_gram_rank += values 
       four_grams['_rank'] = int(three_gram_rank) 
       two_gram_rank += three_gram_rank 
      [..]  
      two_grams['_rank'] = int(one_gram_rank) 
      ngram_rank += one_gram_rank 
     one_grams['_rank'] = int(ngram_rank) 

probability_items (डेटा) हो रही है के साथ होता है

यह वह जगह है जहां त्रुटियां होती हैं। यादृच्छिक रूप से, यह int is not subscriptable की शिकायत करेगा जहां x_rank या x_grams['rank] मुद्रित या असाइन किए जा रहे हैं, भले ही उनका मूल्यांकन type() (यदि यह काम करता है, <class 'int'>) मैंने नीचे टिप्पणी के साथ सबसे आम पंक्तियों को चिह्नित किया है। अजीब तरह से पर्याप्त, लाइन 2 और 3 एक अपवाद उठाना कभी नहीं ...

for ngram, one_grams in data.items(): 
     ngram_rank = int(one_grams['_rank'])    # never gives an error 
     print("NgramRank: ", str(ngram_rank))    # never gives an error 
     if ngram != '_rank': 
      for one_gram, two_grams in one_grams.items(): 
       pprint(type(two_grams['_rank']))    # common error point 
       one_gram_rank = str(two_grams['_rank'])  # never reaches this 
       if one_gram != '_rank': 
        for two_gram, three_grams in two_grams.items(): 
         pprint(type(three_grams['_rank'])) # common error point 
         pprint(str(three_grams['_rank'])) # never reaches this 
         two_gram_rank = str(three_grams['_rank']) 
         [..] 
        one_gram_prob = int(one_gram_rank)/int(ngram_rank) 
        two_grams['_prob'] = one_gram_prob 
      ngram_prob = int(ngram_rank)/int(ngram_rank) 
      one_grams['_prob'] = ngram_prob 

randowm फैशन में, एक अपवाद सामान्य त्रुटि मुद्दे पर ऊपर फेंक दिया है। इन अपवादों के कारण, नीचे दी गई रेखाएं कभी नहीं पहुंचती हैं। लेकिन यदि आप सामान्य त्रुटि बिंदु हटाते हैं, तो नीचे दी गई रेखाएं त्रुटि बिंदु बन जाती हैं। और कभी-कभी, यह आंतरिक-के-लूप में सभी तरह से एक पूर्ण रन करता है, मूल्यांकन किए जाने पर <class 'int'> प्रिंटिंग, और सभी, जब तक यह अपवाद पर रोक नहीं जाता है।

मैं कोई सुराग नहीं क्या हो रहा है, मैं भी समझ में नहीं आता कि कैसे इस त्रुटि हो सकता है जब मैं चूंकि यह एक अजीब मुद्दा है Type()

साथ यह मूल्यांकन कर रहा हूँ, और मैं स्पष्ट रूप से एक अजीब गलती कर रहा हूँ , मैंने यहां सभी कोड को एक गिस्ट में रखा है: https://gist.github.com/puredevotion/7922480

आशा है कि कोई मदद कर सकता है!

ट्रैस बैक विवरण लाइन के लिए

['Traceback (most recent call last):\n', ' File "Ngram_ranking.py", line 121, in probability_items\n pprint(type(four_grams[\'_rank\']))\n', "TypeError: 'int' object is not subscriptable\n"] 

*** extract_tb: 
[('Ngram_ranking.py', 121, 'probability_items', "pprint(type(four_grams['_rank']))")] 

*** format_tb: 
[' File "Ngram_ranking.py", line 121, in probability_items\n pprint(type(four_grams[\'_rank\']))\n'] 

*** tb_lineno: 121 
Exception in on line 121: pprint(type(four_grams['_rank'])): 'int' object is not subscriptable 

Traceback 115

['Traceback (most recent call last):\n', ' File "Ngram_ranking.py", line 115, in probability_items\n pprint(type(three_grams[\'_rank\']))\n', "TypeError: 'int' object is not subscriptable\n"] 

*** extract_tb: 
[('Ngram_ranking.py', 115, 'probability_items', "pprint(type(three_grams['_rank']))")] 

*** format_tb: 
[' File "Ngram_ranking.py", line 115, in probability_items\n pprint(type(three_grams[\'_rank\']))\n'] 

*** tb_lineno: 115 
Exception in on line 115: pprint(type(three_grams['_rank'])): 'int' object is not subscriptable 

PPRINT (डेटा) probability_items के शीर्ष पर (डेटा)

{'aesthetic': {'_rank': 290, 
      'feeling': {'_rank': 10, 
         'the': {'_rank': 10, 
           'feeling': {'_rank': 10, 'of': 10}}}, 
      'perception': {'_rank': 280, 
          'and': {'_rank': 190, 
            'the': {'_rank': 190, 
              'design': 15, 
              'environment': 5, 
              'music': 100, 
              'painting': 15, 
              'work': 5, 
              'works': 50}}, 
          'of': {'_rank': 90, 
           'the': {'_rank': 50, 
             'work': 30, 
             'world': 20}, 
           'their': {'_rank': 40, 'female': 40}}}}} 

Answer 1

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

मैं सिर्फ अपने शब्दकोश का कुछ हिस्सा ले लेंगे

{ 
'aesthetic': 
    { 
    '_rank': 290, 
    'feeling': 
     { 
     '_rank': 10, 
     'the': 
      { 
      '_rank': 10, 
      'feeling': 
       { 
       '_rank': 10, 
       'of': 10 
       } 
      } 
     }, 
    } 
} 

आपका शीर्ष स्तर शब्दकोश (कुंजी aesthetic के लिए) मूल्य के रूप में एक समान है हमेशा एक शब्दकोश है। लेकिन निचले स्तरों में उनके कुछ मूल्यों के रूप में ints भी है।

इस प्रकार जब आप

for ngram, one_grams in data.items(): 

आप ngram=aesthetics और one_grams={the dictionary} है

int(one_grams['_rank']) 

हमेशा (काम करेगा के रूप में मूल्य शब्दकोश तत्व _rank है। तो तुम कभी नहीं एक त्रुटि यहाँ मिलता है।

अब हम अगले चरण

0 पर जाएं

रनिंग one_grams शब्दकोश के लिए .items() देता

(one_gram,two_grams) = [('_rank', 290), ('feeling', {'_rank': 10, 'the': {'_rank': 10, 'feeling': {'_rank': 10, 'of': 10}}})] 

सूचना two_grams पहली प्रविष्टि के लिए एक int और दूसरे के लिए एक dict है। जब से तुम() पूरे से अधिक आइटम पुनरावृति जबकि

two_grams['_rank'] 

कर आप त्रुटि (जो आपको बताता है कि आप एक int पर पहुंच जाते हैं जब dict उम्मीद थी) में चलाने। आंतरिक लूप में भी यही समस्या होती है।

जैसे शब्दकोशों का आदेश नहीं दिया जाता है, आइटम() किसी भी क्रम में वापस आ सकते हैं। इस प्रकार _rank पहला तत्व या अन्य शब्दकोश तत्वों के नीचे हो सकता है। उस स्थिति में आप अंदरूनी लूप के लिए उतरते हैं और वहां एक ही समस्या का सामना करते हैं।

आप जबकि सभी छोरों में

for one_gram,two_grams one_grams.items(): 
    if one_gram=='_rank': 
     continue 

पुनरावृत्ति _rank कुंजी उपेक्षा कर सकते हैं।