Erstellen stark verschachtelte Python-Wörterbücher in einer sauberen programmatischen Weise

Question

Ich verwende eine Reihe von Funktionen, um ein stark verschachteltes Wörterbuch zu füllen. Ich frage mich, ob es eine sauberere Möglichkeit gibt, dies zu tun, als nur eine lange Zuordnungszeichenfolge, wie im folgenden Beispiel gezeigt.

outputdict = {} 
outputdict['x']={} 
outputdict['x']['y']={} 
outputdict['x']['y']['total_patients']=len(example_dict.keys()) 
outputdict['x']['y']['z']={} 
for variable1 in variable1s: 
    outputdict['x']['y']['z'][str(variable1)]={} 
    outputdict['x']['y']['z'][str(variable1)]['total_patients']=function_1(example_dict, variable1).count() 
    for popn in ['total','male','female']: 
     outputdict['x']['y']['z'][str(variable1)][popn]={} 
     for age_bucket in np.linspace(40,60,5): 
      age_str = str(age_bucket)+'_'+str(age_bucket+5) 
      outputdict['x']['y']['z'][str(variable1)][popn][age_str]={} 
      outputdict['x']['y']['z'][str(variable1)][popn]["total"]={} 
      for res in restypes: 
       if popn == 'total': 
        codelist, ncodes = function_2(function_1(example_dict, variable1), res, age_bucket) 
       else: 
        codelist, ncodes = function_2_gender(function_1(example_dict, variable1), res, age_bucket, popn) 
       outputdict['x']['y']['z'][str(variable1)][popn][age_str][res]={} 
       outputdict['x']['y']['z'][str(variable1)][popn][age_str][res]['total_codes']=ncodes 
       outputdict['x']['y']['z'][str(variable1)][popn][age_str][res]['top_codes']=[] 
       for item in codelist: 
        disp = {"code": item[0][:2], "value":item[0][2], "count":item[1]} 

        outputdict['x']['y']['z'][str(variable1)][popn][age_str][res]['top_codes'].append(disp) 


       codelist, ncodes = list_top_codes(function_1(example_dict, variable1), res) 
       outputdict['x']['y']['z'][str(variable1)][popn]["total"][res]={} 
       outputdict['x']['y']['z'][str(variable1)][popn]["total"][res]['top_codes']=[] 
       for item in codelist: 
        disp = {"code": item[0][:2], "value":item[0][2], "count":item[1]} 
        outputdict['x']['y']['z'][str(variable1)][popn]["total"][res]['top_codes'].append(disp) 
outputdict 

Answer 1

Sie könnten autovivification mit defaultdict verwenden. Dies würde es ermöglichen Ihnen die Erstellung von leeren dicts zu überspringen, da sie automatisch erstellt werden würde, wenn nicht definiert Taste dereferenziert wird:

from collections import defaultdict 

dd = lambda: defaultdict(dd) 

d = dd() 
d['foo']['bar']['foobar'] = 1 

So Ihr Code wie folgt aussieht:

outputdict = dd() 
outputdict['x']['y']['total_patients']=len(example_dict.keys()) 

for variable1 in variable1s: 
    outputdict['x']['y']['z'][str(variable1)]['total_patients']=function_1(example_dict, variable1).count() 

Die andere mögliche Verbesserung wäre sein, die verschachtelte Wörterbuch variablen gespeichert, so dass Sie nicht überall den vollständigen Pfad geben würde:

for variable1 in variable1s: 
    nested = dd() 
    outputdict['x']['y']['z'][str(variable1)]=nested 
    nested['total_patients']=function_1(example_dict, variable1).count() 

Answer 2

Sie können Wörterbuch Initialisierungen vermeiden mit einem Standarddict eines Diktats. Sie können diese beliebig verketten, um eine geschachtelte Wörterbuchhierarchie zu erstellen. Zum Beispiel ist hier ein 2- und 3-Ebenen-Hierarchiewörterbuch.

two_level = defaultdict(lambda: defaultdict(dict)) 
three_level = defaultdict(lambda: defaultdict(lambda: defaultdict(dict))) 

Ihr Wörterbuch ist nun wie folgt: two_level[1][2] und three_level[1][2][3] und leer dicts {} sein.

Also in Ihrem Fall scheint es, Ihnen eine 4-Stufen-Verschachtelung haben, so würde ich wahrscheinlich initialisieren outputdict als:

output_dict = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))) 

nicht denken Sie an etwas anderes hier tun kann - ich würde empfehlen dass Sie diese verschachtelte Struktur möglichst vereinfachen.