Analyse de fichiers Python: Construire une arborescence à partir d'un fichier texte

Le gros problème, c'est le "anticipation" qui, je pense, a causé la laideur en question. Il peut être raccourcie légèrement:

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)

Puisque nous parlons de la récursivité, j'ai pris la peine d'éviter toutes les variables globales (source et last_line). Il serait plus pythonic pour en faire des membres sur certains analyseur objet.

Je ne voudrais pas utiliser la récursivité pour quelque chose comme ça (Ok, peut-être que je ferais si j'étais ce codage dans un langage comme Système, mais c'est Python ici). La récursivité est idéal pour parcourir de données qui a la forme d'un arbre, et dans ces cas, il permettrait de simplifier votre conception de considérablement lorsqu'par rapport à la normale des boucles.

Cependant, ce n'est pas le cas ici. Vos données sûrement représente un arbremais il est formaté de manière séquentielle, c'est à dire c'est une simple séquence de lignes. Ces données sont plus facilement traitée avec une simple boucle, bien que vous pourriez rendre la conception plus générale, si vous le souhaitez, en la séparant en trois couches différentes: la séquence du lecteur (qui va analyser les onglets comme une spécification de niveau de profondeur), l'arbre insertion (qui insère un nœud dans un arbre dans un niveau de profondeur, en gardant la trace du dernier nœud qui a été inséré dans l'arbre) et l'arbre lui-même:

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)

Lorsque j'ai eu à tester ce code avant de le coller ici, j'ai écrit une fonction très simple et joli imprimer l'arbre que j'ai lu de la mémoire. Pour cette fonction, la chose la plus naturelle est d'utiliser la récursivité, bien sûr, parce que maintenant, l'arbre est en effet représenté comme un arbre de données:

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

print_tree(tree)