Python-Datei Parsen: Build-tree von text-Datei

Das große Problem ist die "lookahead" , denke ich, verursacht die Hässlichkeit in Frage. Es kann etwas verkürzt:

def _recurse_tree(parent, depth, source):
    last_line = source.readline().rstrip()
    while last_line:
        tabs = last_line.count('\t')
        if tabs < depth:
            break
        node = last_line.strip()
        if tabs >= depth:
            if parent is not None:
                print "%s: %s" %(parent, node)
            last_line = _recurse_tree(node, tabs+1, source)
    return last_line

inFile = open("test.txt")
_recurse_tree(None, 0, inFile)

Da reden wir Rekursion, nahm ich Schmerzen zu vermeiden, alle globalen Variablen (source und last_line). Es wäre mehr pythonic machen Sie Mitglieder auf einige parser-Objekt.

InformationsquelleAutor der Antwort Mu Mind

Ich würde keine Rekursion für so etwas überhaupt (Ok, vielleicht würde ich wenn ich die Programmierung dieses in einer Sprache wie Scheme, aber das ist Python hier). Rekursion ist ideal für die Iteration über die Daten, die geformt ist wie ein Baum, und in diesen Fällen würde es vereinfachen Sie Ihre Konstruktion erheblich, wenn im Vergleich zu normalen Schleifen.

Dies ist jedoch hier nicht der Fall. Ihre Daten sicher stellt einen Baumaber es formatiert ist sequentiell, d.h. es ist eine einfache Sequenz von Linien. Solche Daten werden am leichtesten verarbeitet werden, der mit einer einfachen Schleife, obwohl Sie könnten, machen das design mehr Allgemeinen, wenn Sie es wünschen, durch die Trennung in drei verschiedene Schichten: die sequentielle-reader analysiert die tabs als eine Spezifikation der Tiefe der Stufe), der Baum inserter (welcher ein Knoten in einem Baum in einer bestimmten Tiefe Ebene, die durch verfolgen der Letzte Knoten wurde eingefügt in den Baum und den Baum selbst:

import re

# *** Tree representation ***
class Node(object):
    def __init__(self, title):
        self.title = title
        self.parent = None
        self.children = []

    def add(self, child):
        self.children.append(child)
        child.parent = self

# *** Node insertion logic ***
class Inserter(object):
    def __init__(self, node, depth = 0):
        self.node = node
        self.depth = depth

    def __call__(self, title, depth):
        newNode = Node(title)
        if (depth > self.depth):
            self.node.add(newNode)
            self.depth = depth
        elif (depth == self.depth):
            self.node.parent.add(newNode)
        else:
            parent = self.node.parent
            for i in xrange(0, self.depth - depth):
                parent = parent.parent
            parent.add(newNode)
            self.depth = depth

        self.node = newNode

# *** File iteration logic ***
with open(r'tree.txt', 'r') as f:    
    tree = Node(f.readline().rstrip('\n'))
    inserter = Inserter(tree)

    for line in f:
        line = line.rstrip('\n')
        # note there's a bug with your original tab parsing code:
        # it would count all tabs in the string, not just the ones
        # at the beginning
        tabs = re.match('\t*', line).group(0).count('\t')
        title = line[tabs:]
        inserter(title, tabs)

Wenn ich hatte, um diesen code zu testen, bevor Sie einfügen hier, schrieb ich eine sehr einfache Funktion pretty-print der Baum, den ich lese-Speicher. Für diese Funktion, die natürlichste Sache war, Rekursion zu verwenden, natürlich, weil jetzt der Baum ist in der Tat dargestellt, die tree-Daten:

def print_tree(node, depth = 0):
    print '%s%s' % ('  ' * depth, node.title)
    for child in node.children:
        rec(child, depth + 1)

print_tree(tree)

InformationsquelleAutor der Antwort Boaz Yaniv