Python: jak całkowicie przemierzyć złożony Słownik o nieznanej głębokości?

Jeśli potrzebujesz tylko przejść przez słownik, sugerowałbym użycie rekurencyjnej funkcji walk, która pobiera słownik, a następnie rekurencyjnie przechodzi przez jego elementy. Coś takiego:

def walk(node):
    for key, item in node.items():
        if item is a collection:
            walk(item)
        else:
            It is a leaf, do your thing

Jeśli chcesz również wyszukać elementy lub odpytywać kilka elementów spełniających określone kryteria, zajrzyj do modułu jsonpath.

Zamiast pisać własny parser, w zależności od zadania, Można rozszerzyć Kodery i Dekodery z modułu standardowej biblioteki json.

Polecam to szczególnie, jeśli trzeba zakodować do json obiekty należące do klas niestandardowych. Jeśli musisz wykonać jakąś operację, która może być wykonana również na łańcuchowej reprezentacji json, rozważ również iterację jsonencoder ().iterencode

Dla obu odniesień jest http://docs.python.org/2/library/json.html#encoders-and-decoders

Jeśli znasz znaczenie danych, możesz utworzyć funkcję parse, która zmieni zagnieżdżone kontenery w drzewo obiektów niestandardowych typów. Następnie użyjesz metod tych niestandardowych obiektów, aby zrobić wszystko, co musisz zrobić z danymi.

Dla przykładowej struktury danych można utworzyć Program, VariableDeclaration, VariableDeclarator, Identifier, Literal i BinaryExpression klasy, następnie użyj czegoś takiego do parsera:

def parse(d):
    t = d[u"type"]

    if t == u"Program":
        body = [parse(block) for block in d[u"body"]]
        return Program(body)

    else if t == u"VariableDeclaration":
        kind = d[u"kind"]
        declarations = [parse(declaration) for declaration in d[u"declarations"]]
        return VariableDeclaration(kind, declarations)

    else if t == u"VariableDeclarator":
        id = parse(d[u"id"])
        init = parse(d[u"init"])
        return VariableDeclarator(id, init)

    else if t == u"Identifier":
        return Identifier(d[u"name"])

    else if t == u"Literal":
        return Literal(d[u"value"])

    else if t == u"BinaryExpression":
        operator = d[u"operator"]
        left = parse(d[u"left"])
        right = parse(d[u"right"])
        return BinaryExpression(operator, left, right)

    else:
        raise ValueError("Invalid data structure.")

Może pomoże:

def walk(d):
    global path
      for k,v in d.items():
          if isinstance(v, str) or isinstance(v, int) or isinstance(v, float):
            path.append(k)
            print "{}={}".format(".".join(path), v)
            path.pop()
          elif v is None:
            path.append(k)
            ## do something special
            path.pop()
          elif isinstance(v, dict):
            path.append(k)
            walk(v)
            path.pop()
          else:
            print "###Type {} not recognized: {}.{}={}".format(type(v), ".".join(path),k, v)

mydict = {'Other': {'Stuff': {'Here': {'Key': 'Value'}}}, 'root1': {'address': {'country': 'Brazil', 'city': 'Sao', 'x': 'Pinheiros'}, 'surname': 'Fabiano', 'name': 'Silos', 'height': 1.9}, 'root2': {'address': {'country': 'Brazil', 'detail': {'neighbourhood': 'Central'}, 'city': 'Recife'}, 'surname': 'My', 'name': 'Friend', 'height': 1.78}}

path = []
walk(mydict)

Będzie produkować wyjście w ten sposób:

Other.Stuff.Here.Key=Value 
root1.height=1.9 
root1.surname=Fabiano 
root1.name=Silos 
root1.address.country=Brazil 
root1.address.x=Pinheiros 
root1.address.city=Sao 
root2.height=1.78 
root2.surname=My 
root2.name=Friend 
root2.address.country=Brazil 
root2.address.detail.neighbourhood=Central 
root2.address.city=Recife