Treeview à partir d'une liste

Bonjour,

Je débute avec Python (important de le préciser :) ) et je bloque souvent sur le même problème, sans trouver une solution propre.

J'aimerai réaliser un listing d'objets type Treeview (ou arbre généalogique ) à partir de données allant de paire.

Exemple :

Code:

---

maListe = [["orange","fruit"], ["banane","fruit"], ["courgette", "legume"], ["chaise", "meuble"]]

---

Ce qu'il me faudrait comme résultat :

Code:

---

maNouvelleListe = [[fruit, [orange, banane]], [legume, [courgette]], [meuble,[chaise]]

---

Si vous aviez quelques pistes d'idées cela m'aiderait beaucoup :)
Merci par avance

Je dirais 3 solutions

- Les dictionnaires
- Les namedtuple
- Les classes

Si tu es débutant je te conseille les dictionnaires, mais le problème c'est que je ne sais pas ce que tu veux en faire après.

Sinon j'aime bien les classes mais pour ton niveau (à moins que tu connaisses d'autres langages) c'est un peu trop évolué.

Edit : Ce qui donnerait en faisant simple

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

maListe = [["orange","fruit"], ["banane","fruit"], ["courgette", "legume"], ["chaise", "meuble"]]   dico = {}   for liste in maListe: value, key = liste if key not in dico: dico[key] = [value] else: dico[key].append(value)   print dico   # {'legume': ['courgette'], 'fruit': ['orange', 'banane'], 'meuble': ['chaise']}   # Dictionnaire trié   dico = OrderedDict(sorted(dico.items(), key=lambda t: t[0]))   # OrderedDict([('fruit', ['orange', 'banane']), ('legume', ['courgette']), ('meuble', ['chaise'])])

---

Merci de ta réponse :D

Alors je me suis rendu compte de quelques problèmes.

D'une part j'ai oublié de préciser que ma version de Python est la 2.6
Je travail en effet sur Maya un logiciel d'infographie 3D.

Et donc d'après mes quelques recherches OrderedDict() n'est disponible qu'à partir de la 2.7 ...

Deuxièmement je ne sais pas si mon exemple était le meilleur.

En gros ma liste initiale est agencée de la manière suivante :

Code:

---

exempleList = [["Parent1","Child1"], ["Parent1","Child2"], ["Child1","Child3"], ["Parent2","Parent1"]]

---

De manière visuelle j'obtient quelque chose comme :

Code:

---

1 2 3 4 5

Parent2 |-Parent1 |---Child1 |-----Child3 |---Child2

---

En gros chaque liste peut contenir plusieurs listes qui elles même en contiennent d'autres etc ... Un tableau en somme.
J'ai fait quelques tests, seulement je me retrouve à faire des boucle dans des boucles dans des boucles etc ... Au final je cherche simplement à trier un liste.

Voilà j'espère avoir était assez explicite, j'avoue que c'est un peu compliqué pour moi :') Merci encore :)

Bonjour,

Ça, c'est un problème amusant!

Et assez général: construire un arbre des descendances à partir de liens de filiations. C'est un problème qu'on rencontre aussi dans la construction des graphes de planification à partir des liens de précédences des tâches.

Voilà comment je ferais.

0- rappel des données: la liste des liens de filiation.

Code:

---

d = [["Parent1","Child1"], ["Parent1","Child2"], ["Child1","Child3"], ["Parent2","Parent1"]]

---

1- il faut trouver le début de l'arbre, c'est à dire le ou les parent(s) jamais cité(s) comme enfant dans les liens de filiation:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

def cherche_parents_initiaux(d): """cherche le ou les parent(s) sans ascendance """ a = [] for p1, c1 in d: sansparent = True for p2, c2 in d: if p1 == c2: # ici, le parent p1 est cité comme enfant c2 sansparent = False break if sansparent: # ici: p1 = parent jamais cité comme enfant dans les filiations a.append(p1) return a

---

2- Pour chaque parent sans ascendance, il faut trouver ses enfants, puis les enfants de ses enfants, etc... Pour cela, on va construire l'arbre des descendances comme une liste de listes en choisissant comme 'brique' de base: [parent, [enfant1, enfant2, ...]]. Chaque enfant pouvant, bien entendu, reprendre la même 'brique': [enfant1, [enfants1_1, enfant1_2, ...]]. Les 'feuilles' de l'arbre sont représentées par les enfants sans descendances: [enfant, []].

On note que l'algorithme de construction de l'arbre sera logiquement récursif, en espérant ici qu'on ne dépassera pas la pile de récursion limitée chez Python (env. 1000). Si l'arbre devait être trop complexe, il faudrait faire une version non récursive.

Code:

---

1 2 3 4 5 6 7

def cherche_enfants(p, d): """cherche les enfants de p dans la liste des filiations d """ l = [p, []] for p1, c1 in d: if p == p1: l[1].append(cherche_enfants(c1, d)) return l

---

3- Il ne reste plus qu'à créer une fonction d'affichage, parce que le simple affichage de l'arbre est difficilement exploitable visuellement (trop compliqué):

Code:

---

1 2 3 4 5 6

def affiche_arbre(a, niv=0): """affiche l'arbre des descendances a """ if a!=[]: print "=="*niv + a[0] for e in a[1]: affiche_arbre(e, niv+1)

---

Voilà comment on exploite:

Code:

---

1 2 3 4 5 6 7 8 9

# recherche du ou des parents sans ascendance a = cherche_parents_initiaux(d)   # pour chacun de ces parents, construction de l'arbre des descendances for p in a: arbre = cherche_enfants(p, d) affiche_arbre(arbre) print print arbre

---

Ce qui affiche:

Code:

---

1 2 3 4 5 6 7

Parent2 ==Parent1 ====Child1 ======Child3 ====Child2   ['Parent2', [['Parent1', [['Child1', [['Child3', []]]], ['Child2', []]]]]]

---

Dans le cas général, il faudrait tester les cas de boucles de l'arbre pour éviter les plantages. Dans les arbres généalogiques, ça doit être plutôt rare (un enfant ne peut pas être son propre grand-père), mais dans les graphes de planifications, ça arrive (2 tâches qui s'attendent l'une l'autre).

Je n'ai pas testé dans tout les cas, mais le principe est là: bon courage!

Et bien tout d'abord merci pour cette réponse exhaustive :)
Il va me falloir un peu de temps pour tout comprendre mais le résultat est bien la ! Tout fonctionne parfaitement :)
En ce qui concerne les éventuelles boucles, ne vous en faites pas, chaque objet ne peut avoir qu'un seul parent dans mon cas ;)