Bonjour,

J'essaye d'écrire une fonction qui crée un arbre syntaxique a partir d'une liste de noeud qui ont chacun comme attribut (id, pid, lemma) le pid est l'id du noeud parent. La fonction que j'ai écrite fonctionne mais me renvoit un liste de liste de liste de ....
Ce que je veux c'est quelque chose comme ça:

t1 = Node("f",
             Node("d",
                  Node("a"),
                  Node("c",
                       Node("b"))),
             Node("e"))

et au lieu de ça je pense que j'ai quelque chose comme ça

t1 = Node(["f"],
             [Node(["d",
                  Node(["a"),
                  Node(["c",
                       Node(["b"])])])],
             Node(["e"])])

def createSingleTree(self, nodes,root):
        tree = []
        for node in nodes:
            if node.getPID() == root.getID():
                print node.getLemma()
                tree.append(self.createSingleTree(nodes,node))
        if not tree:
            return Node(root.getLemma())
        else:
            return Node(root.getLemma(), tree)

class Node(list):
    """
    Simple recursive representation of a tree as a labeled node with zero or
    more child nodes
    """

    def __init__(self, label, *children):
        self.label = label
        list.__init__(self, children)
        
    def is_leaf(self):
        return not self
    
    def left_child(self):
        return self[0]

    def __str__(self):
        """
        string representation of tree as a labeled bracket structure
        """
        if self.is_leaf():
            return self.label
        else:
            return ( self.label + 
                     "( " + 
                     " ".join([str(child) for child in self]) + 
                     ")" )
            
    def __repr__(self):
        return self.label

En gros il faudrait que tree ne soit plus une liste dans

return Node(root.getLemma(), tree)

Donc j'aurais besoin de votre aide.
Auriez-vous une idée qui pourrait me sortir de ce problème?
Je vous remercie d'avance

Rapidement (il y a peut-être un truc qui m'a échappé), c'est plutôt le *children que je remettrais en question à ta place. Je pense qu'il serait plus pratique de manipuler vraiment une liste d'enfants que l'on passe à la fonction. Pour rappel, une telle expression permet de représenter une liste d'arguments optionnels.

Si tu n'es pas d'accord avec moi, tu peux faire l'inverse et éclater la liste tree en plusieurs arguments avec la même syntaxe. Mais je ne suis pas sûr que ça soit une si bonne idée (on utilise plutôt cette fonctionnalité de Python quand on veut écrire du code glu qui fonctionne avec des fonctions d'un nombre quelconque d'arguments).

(Parenthèse : c'est dans ces moments là qu'on apprécie d'avoir un langage statiquement typé, et avec des types algébriques. Pourquoi avoir utilisé Python, et pas, par exemple, OCaml ?)

J'ai du mal à voir l'intérêt d'une classe dérivant de list, il y a une explication?

Sinon comme AporieDramatique, pourquoi retirer les valeurs d'une liste pour les retransformer en liste avec list.__init__()?

Autant prendre une liste de suite, non?

+1 pour l'AporieDramatique.

Sinon, return Node(root.getLemma(), *tree)

Je sais que c'est bizarre mais c'est mon professeur qui a écrit la classe Node et je ne suis pas sûr que je peux y faire des modifications.
J'essaye donc d'adapter mon code en fonction. return Node(root.getLemma(), *tree) fait exactement ce que je veux. Merci!
Je suis plus ou moins débutant en python et j'avoue que le *variable m'avait échappé dans le tutoriel de prolixe.
Merci beaucoup pour vos réponses en tout cas, je commençais à désespérer.

Citation

Je sais que c'est bizarre mais c'est mon professeur qui a écrit la classe Node et je ne suis pas sûr que je peux y faire des modifications

Eh bien tu lui demanderas l'intérêt de l'heritage de liste, ça nous apprendra quelquechose.