Ich versuche eine Funktion zu schreiben, die eine Zeichenfolge aus einem multidimensionalen Wörterbuch ausgibt.

Question

Hier ist die Funktion, die ich schrieb:

def print_dict(d, indent, CMD_str, index = 0): 
if isinstance(d,dict): 
    for key, value in d.items(): 

     CMD_str += ('\t' * indent + str(key) + '\n') 
     # print('\t' * indent + str(key) + '\n') 
     if isinstance(value, dict): 
      CMD_str += print_dict(value, indent+1, CMD_str, index = index+1) 
     elif isinstance(value,list): 
      for i in value: 
       if isinstance(i,list): 
        CMD_str += print_dict(i,indent+1, CMD_str = CMD_str, index = index+1) 
       else: 
        CMD_str += ('\t'*(indent+1) + i + '\n') 
     else: 
      CMD_str += ('\t' * (indent+1) + str(value) + '\n') 
elif isinstance(d,list): 
    for i in d: 
     print(index) 
     if isinstance(i,list): 
      CMD_str += print_dict(i,indent+1, CMD_str, index = index+1) 
     else: 
      CMD_str += ('\t'*(indent) + i) 

return CMD_str 

Diese Funktion ursprünglich das Wörterbuch gedruckt und funktionierte perfekt. Allerdings muss ich jetzt eine Zeichenkette ausgeben, anstatt zu drucken, also habe ich das Eingabeargument CMD_str hinzugefügt, damit ich die Zeichenkette solange in der Funktion belassen kann, bis ich mich durch das Wörterbuch durchgearbeitet habe. Allerdings bleibt es irgendwo hängen und ich kann nicht verstehen warum. Durch das Drucken von Einrückwerten kann ich sagen, dass es ungefähr 10 Mal durchlaufen wird, bevor es stecken bleibt. Jede Hilfe würde sehr geschätzt werden.

Answer 1

Sie haben einen doppelten Code in Ihrer rekursiven Funktion, der zur besseren Übersichtlichkeit reorganisiert werden kann und die Wahrscheinlichkeit eines Fehlers verringert. Hier ein Beispiel:

tab = " " 

def print_dict(d, indent): 
    result = [] 
    for key, value in d.items(): 
     result.append(tab*indent + str(key)) 
     result.append(print_obj(value, indent+1)) 
    return '\n'.join(result) 

def print_list(a, indent): 
    result = [] 
    for value in a: 
     result.append(print_obj(value, indent)) 
    return '\n'.join(result) 

def print_obj(obj, indent): 
    result = "" 

    if type(obj) is dict: 
     result = print_dict(obj, indent) 
    elif type(obj) is list: 
     result = print_list(obj, indent) 
    else: 
     result = tab*indent + str(obj) 

    return result 

d = { 
    'key1': ['val1', 'val2', {'key3':'val3'}], 
    'key4': 'val5', 
    'key5': { 
     'key6': 'val6', 
     'key7': [1, 2, 3, 4] 
    } 
} 

import pprint 

pprint.pprint(d, width=1) 
print print_obj(d, 0) 

Der Ausgang ist

{'key1': ['val1', 
      'val2', 
      {'key3': 'val3'}], 
'key4': 'val5', 
'key5': {'key6': 'val6', 
      'key7': [1, 
        2, 
        3, 
        4]}} 
key1 
    val1 
    val2 
    key3 
    val3 
key5 
    key7 
    1 
    2 
    3 
    4 
    key6 
    val6 
key4 
    val5 

Answer 2

1. von pprint bewusst sein.
2. Separate Arbeit nach Gültigkeitsbereichen - Ihre Funktion funktioniert selbst und erwartet, dass der Aufrufer die gleiche Arbeit auch ausführt, was zur Code-Duplizierung führt. Ich habe Ihren Code ein wenig überarbeitet:

---

from numbers import Number 

def recursive_print(item, level=0): 
    result = '' 
    indent = '\t' * level 
    if isinstance(item, dict): 
     result += '\n'.join(
      indent + str(key) + '\n' + 
      recursive_print(value, level+1) 
      for (key, value) in item.items() 
     ) 
    elif isinstance(item, list): 
     def one_line_printable(x): return isinstance(x, str) or isinstance(x, Number) 
     if all(one_line_printable(element) for element in item): 
      result += indent + '\t'.join(str(element) for element in item) 
     else: 
      result += '\n'.join(recursive_print(element, level) for element in item) 
    else: 
     result += indent + str(item) 
    return result 

Beachten Sie, dass die Funktion bei jedem Aufruf kümmern seine Einbuchtung soll. Es ist jedoch der Aufrufer, der '\n' nach dem Text liefern soll - zurückgegebene Zeichenfolge endet nicht mit '\n'.