Get Ebene der Elemente in einer verschachtelten Liste

Question

Problem:

Ich habe einige Daten verknüpft und ich möchte eine Struktur wie diese auf diesem Bild bauen:

und erhalten die Level jedes Artikels, weil ich in der Zukunft einige Berechnungen anstellen werde, indem ich auf die unterste Ebene meiner Baumstruktur starre.

Erwartetes Ergebnis:

Ich brauche eine Struktur zu erhalten, die mir Artikel pro Ebene gibt:

• Ebene 0: A
• Ebene 1: A = B, C, D
• Stufe 2: D = E, F, G
• Stufe 3: E = H, I, J, K

was ich bisher versucht:

ich diesen rekursiven Code habe versucht, das Verhalten zu simulieren, aber ich bin nicht in der Lage Elemente die Höhe der Gegenstände zu erhalten.

dict_item = {"A": ["B","C","D"], "D": ["E","F","G"], "E":["H","I","J"]} 
def build_bom(product): 
    if not dict_item.get(product): 
     return product 
    else : 
     return [build_bom(x) for x in dict_item.get(product)] 
print(build_bom("A")) 

Meine Ausgabe ist eine verschachtelte Liste wie folgt aus:

['B', 'C', [['H', 'I', 'J'], 'F', 'G']] 

Meine Frage:

Ich bin nicht sicher, ob dies der beste Ansatz ist, um mein Problem zu behandeln. Und wie bekomme ich die gewünschte Ausgabe? hier ist die gewünschte Ausgabe:

[ {"parent_E":["H", "I", "J"]}, 
{"parent_D": ["E", "F", "G"]}, 
{"parent_A"} :["D","C","B"]}, 
] 

Eine Liste von Wörterbüchern (wo Schlüssel sind Eltern und Werte sind Kinder), das erste Element in der Liste ist die unterste Ebene meiner Struktur und die letzte ist das höchste Element.

PS: Dies ist eine Simulation, aber in Zukunft muss ich mit diesem Code an großen Datensätzen arbeiten. Jede Hilfe wird geschätzt

Answer 1

Dies ist, wie ich dieses Problem angehen werde. Zuerst erzeuge ich den Baum von Ihrem dict_item Objekt.

dict_item = {"A": ["B","C","D"], "D": ["E","F","G"], "E":["H","I","J"]} 

def build_tree(x): 
    if x in dict_item: 
     return {x: [build_tree(v) for v in dict_item[x]]} 
    else: 
     return x 

tree = build_tree("A") 
print(tree) 
>>> {'A': ['B', 'C', {'D': [{'E': ['H', 'I', 'J']}, 'F', 'G']}]} 

Führen Sie dann eine Breitensuche im Baum durch. Jedes Mal, wenn wir ein Element treffen, die Kinder hat, wir hängen Sie ihn auf eine Liste:

results = [] 
queue = [tree] 

while queue: 
    x = queue.pop(0) 
    if isinstance(x, dict): 
     parent, children = list(x.items())[0] 
     results.append({'parent_' + parent: dict_item[parent]}) 
     for child in children: 
      queue.append(child) 

print(results) 
>>> [{'parent_A': ['B', 'C', 'D']}, {'parent_D': ['E', 'F', 'G']}, {'parent_E': ['H', 'I', 'J']}] 

Dann alles, was wir jetzt tun müssen, ist die Liste zu umkehren:

print list(reversed(results)) 
>>> [{'parent_E': ['H', 'I', 'J']}, {'parent_D': ['E', 'F', 'G']}, {'parent_A': ['B', 'C', 'D']}]