G'Day,
J'essaie de trouver la profondeur récursive d'une fonction qui chalintre un dictionnaire et je suis un peu perdu ...
Actuellement, j'ai quelque chose comme: et je veux savoir à quel point le dictionnaire est imbriqué le plus imbécile est ... donc je fais ce qui suit ... < PRE> XXX Un seul problème est que la boucle récursive ne renvoie que le retour de la valeur finale (0).
Si je mets dans une déclaration d'impression
Je suis sûr C'est simple - je viens de recevoir Jellybrain. Cheers pour i in d.keys (): puis je peux au moins imprimer la valeur la plus élevée de la récursion, mais renvoyer la valeur est une matière différente ...
5 Réponses :
Vous devez stocker la valeur rétroduite à partir de l'appel récursif et renvoyer la valeur maximale trouvée, sinon, vous appelez la fonction récursive sans rien faire avec la valeur renvoyée! [et retourner 0 comme prévu, car il n'a jamais été changé]
@Raymondhettinger: fonctionne parfaitement pour moi et des impressions '4'. J'ai supposé ici que l'OP voulait le dictionnaire externe comme "0".
Assurez-vous d'attribuer le résultat de l'appel récursif à profondeur em>. En outre, comme @amit dit, envisagez d'utiliser max em> de sorte que vous puissiez gérer des dicts avec plusieurs paires de valeurs de clé (une structure Treeelike). def dict_depth(d, depth=0):
if not isinstance(d, dict) or not d:
return depth
return max(dict_depth(v, depth+1) for k, v in d.iteritems())
>>> myDict = {'leve1_key1': {'level2_key1':
{'level3_key1': {'level4_key_1':
{'level5_key1': 'level5_value1'}}}}}
>>> dict_depth(myDict)
5
Notez juste que sans utiliser max () en profondeur, vous pouvez remplacer profondeur avec une valeur plus petite, si le dictionnaire a plus d'une clé.
@amit je suis d'accord. Il est toujours dangereux de commencer avec le code de l'OP :-)
Je ne peux pas battre possible battre Raymond Hettinger, s'il est d = {1: 2, 2: {3: {5: 6}}, 3: {4: 4}, 7: 8}
def recursion_depth(dict_, depth):
for k in dict_:
print "key{0}:value{1} = depth:{2}".format(k, dict_[k], depth)
if type(dict_[k]) == dict:
actual_depth = recursion_depth(dict_[k], depth+1)
if actual_depth > depth: depth += 1
return depth
>>>recursion_depth(d,0)
key1:value2 = depth:0
key2:value{3: {5: 6}} = depth:0
key3:value{5: 6} = depth:1
key5:value6 = depth:2
key3:value{4: 4} = depth:1
key4:value4 = depth:2
key7:value8 = depth:2
2
une version non récursive:
MyDict = {'a': {'a1': {'a11': 5, 'a12':[{2:'a22'}], 'a13':{'a14':'a11'}}, 'a2': 6}, 'b':{7:{8:{9:{10:{11:'11'}}}}}, 'c': {'c1': 18, 'c2': 1}}
def find_depth(dep,val):
if isinstance(val,dict):
dep=dep+1
for j in val:
find_depth(dep,val[j])
temp_depth.append(dep)
dep=0
return max(temp_depth)
elif isinstance(val,list):
for k in val:
find_depth(dep,k)
max_depth={}
for i in MyDict:
dep=0
temp_depth=[]
max_depth.update({i:(find_depth(dep,MyDict[i]))})
print max_depth
Here is code works fine if even list also included.
Vous ne trouverez aucune limite ici (sauf pour la mémoire disponible). Chaque dictionnaire imbriqué est un nouvel objet qui ne sait rien sur son parent.
Mais votre code pourrait courir dans une pile-débordement. Cela n'a rien à voir avec aucune limite de dictionnaire.