Erstellen Sie einen Baum basierend auf dem Schlüssel jedes Elements in der Liste

Question

>>> s 
[{'000000': [['apple', 'pear']]}, {'100000': ['good', 'bad']}, {'200000': ['yeah', 'ogg']}, {'300000': [['foo', 'foo']]}, {'310000': [['#'], ['#']]}, {'320000': ['$', ['1']]}, {'321000': [['abc', 'abc']]}, {'322000': [['#'], ['#']]}, {'400000': [['yeah', 'baby']]}] 

>>> for i in s: 
...  print i 
... 
{'000000': [['apple', 'pear']]} 
{'100000': ['good', 'bad']} 
{'200000': ['yeah', 'ogg']} 
{'300000': [['foo', 'foo']]} 
{'310000': [['#'], ['#']]} 
{'320000': ['$', ['1']]} 
{'321000': [['abc', 'abc']]} 
{'322000': [['#'], ['#']]} 
{'400000': [['yeah', 'baby']]} 

Ich möchte einen Baum basierend auf dem Schlüssel jedes Elements in der Liste erstellen.

Ergebnis in der Logik wird:

{'000000': [['apple', 'pear']]} 
    {'100000': ['good', 'bad']} 
    {'200000': ['yeah', 'ogg']} 
    {'300000': [['foo', 'foo']]} 
     {'310000': [['#'], ['#']]} 
     {'320000': ['$', ['1']]} 
      {'321000': [['abc', 'abc']]} 
      {'322000': [['#'], ['#']]} 
    {'400000': [['yeah', 'baby']]} 

vielleicht eine verschachtelte Liste dies umsetzen kann oder ich brauche eine Art Baum?

Answer 1

Hier ist ein Ansatz. Ich gehe davon aus, dass Sie sich darauf verlassen können, dass Ihre Schlüssel die Baumstruktur korrekt repräsentieren (keine '310000' ohne '300000' - das würde Probleme verursachen, wenn Sie fehlende Knoten beim Hinzufügen zu Ihrer TreeCtrl behandeln.)

Ich würde beginnen, indem Sie die Daten reorganisieren, so können Sie die zugehörigen Daten für jeden Knoten nach Schlüssel abrufen und auch einige zusätzliche Informationen in jedem Knoten speichern.

# original list of dicts 
tree = [{'000000': [['apple', 'pear']]}, 
     {'100000': ['good', 'bad']}, 
     {'200000': ['yeah', 'ogg']}, 
     {'300000': [['foo', 'foo']]}, 
     {'310000': [['#'], ['#']]}, 
     {'320000': ['$', ['1']]}, 
     {'321000': [['abc', 'abc']]}, 
     {'322000': [['#'], ['#']]}, 
     {'400000': [['yeah', 'baby']]}] 


# reorganize your data into a dict: 
# {'000000': {'data':[['apple', 'pear']]}, 
# '100000': {'data':['good', 'bad']}, ... 
tree = dict([(item.keys()[0], {'data':item[item.keys()[0]]}) 
        for item in tree]) 

Dann durchlaufen, und die übergeordnete ID für jeden Knoten herauszufinden, indem die letzte Nicht-Null-Ziffer des Schlüssels mit Null zu ersetzen, und sie dann wieder auf die ursprüngliche Anzahl von Ziffern Polsterung. Aktualisieren jedes dict mit der Mutter ID:

for key in tree_dict.keys(): 

    parent_id = key.strip('0')[:-1].ljust(len(key), '0') 

    # If it's all zeros, set it to None so we know the parent is root 
    if int(parent_id) == 0: 
     parent_id = None 

    tree_dict[key].update({'parent':parent_id}) 

Diese setzt man sich sehr schön die wx.TreeCtrl zu verwenden, da jeder Knoten nun einen Verweis auf seine Eltern hat:

{'000000':{'data': [['apple', 'pear']], 'parent': None}, 
'100000':{'data': ['good', 'bad'], 'parent': None}, 
'200000':{'data': ['yeah', 'ogg'], 'parent': None}, 
'300000':{'data': [['foo', 'foo']], 'parent': None}, 
'310000':{'data': [['#'], ['#']], 'parent': '300000'}, 
'320000':{'data': ['$', ['1']], 'parent': '300000'}, 
'321000':{'data': [['abc', 'abc']], 'parent': '320000'}, 
'322000':{'data': [['#'], ['#']], 'parent': '320000'}, 
'400000':{'data': [['yeah', 'baby']], 'parent': None}} 

den Stammknoten hinzufügen Ihre wx.TreeCtrl, und dann durch die sortierten dict Schlüssel, Hinzufügen der Daten von jedem Element der TreeCtrl, wie Sie es angezeigt möchten. Und für jedes Element, das Sie hinzufügen, aktualisieren Sie das dict erneut mit der TreeItemId, die von AppendItem() oder InsertItem() zurückgegeben wird. Wenn der Wert für "Eltern" im Dict None lautet, wissen Sie, dass der Elternknoten der Stammknoten sein muss. Wenn dies nicht der Fall ist, verwenden Sie den übergeordneten Wert, um die TreeItemId des übergeordneten Knotens abzurufen, die beim Hinzufügen zur TreeCtrl aktualisiert werden sollte.

Ich hoffe, dass das Sinn macht.

Answer 2

Wenn Sie nur eine Python-Struktur möchten, können Sie diese verwenden:

{'000000': ([['apple', 'pear']], [ 
    {'100000': (['good', 'bad'],)}, 
    {'200000': (['yeah', 'ogg'],)}, 
    {'300000': ([['foo', 'foo']],[ 
    {'310000': ([['#'], ['#']],)}, 
    {'320000': (['$', ['1']],[ 
     {'321000': ([['abc', 'abc']],)}, 
     {'322000': ([['#'], ['#']],)} 
    ])}, 
    {'400000': ([['yeah', 'baby']],)} 
])} 

z.B. Speichern Sie in jedem Schlüssel/Wert-Paar ein Tupel als Wert, so dass das erste Element des Tupels ein Knotendaten ([['apple', 'pear']] zum Beispiel) und das zweite Element des Tupels a wäre Liste der Nachkommen des Knotens.