Arbre phylogenetique - python

Bonjour,

Lors d'un de mes projets scolaires, il m'est demandé d'implémenter une fonction qui affiche un arbre phylo de manière agréable à lire.

C'est à dire qu'un arbre de ce type :
Pièce jointe 143831

devra être affiché de la sorte :

Pièce jointe 143834

En essayant de passer par une fonction chapeau j'ai écris ca :

Code:

---

1 2 3 4 5 6 7 8 9

def profondeur(monarbre,i): if tree == None : return 0 else: (u,fg,fd) = monarbre print "+" print /"| "*(profondeur(fg,i+1)-1) "|--+ " profondeur(fg,i+1) profondeur (fd,i+1)

---

Je n'arrive pas a debugger mon code. Si jamais je pouvais avoir un tuyau.. Merci!

Salut,

dans la ligne suivante:

Code:

---

print /"| "*(profondeur(fg,i+1)-1) "|--+ " profondeur(fg,i+1)

---

• le "/" est en trop
• il faut concaténer tes chaines de caractères ou mettre une virgule entre 2

les erreurs successives qu'on obtient en essayant de lancer un fichier contenant juste ta fonction fournissent de bons indices:

Code:

---

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

File "./arbre.py", line 9 print /"| "*(profondeur(fg,i+1)-1) "|--+ " profondeur(fg,i+1) ^ SyntaxError: invalid syntax ... File "./arbre.py", line 9 print "| "*(profondeur(fg,i+1)-1) "|--+ " profondeur(fg,i+1) ^ SyntaxError: invalid syntax ... File "./arbre.py", line 9 print "| "*(profondeur(fg,i+1)-1) + "|--+ " profondeur(fg,i+1) ^ SyntaxError: invalid syntax

---

Bonjour,

Citation:

---

Envoyé par Tryph

Salut,

dans la ligne suivante:

Code:

---

print /"| "*(profondeur(fg,i+1)-1) "|--+ " profondeur(fg,i+1)

---

• le "/" est en trop
• il faut concaténer tes chaines de caractères ou mettre une virgule entre 2

---

du coup j'ai écrit ca :

Code:

---

1 2 3 4 5 6 7 8 9

def profondeur(monarbre,i): if tree == None: return 0 else: (u,fg,fd) = monarbre print "+ " + str(u) print "| " *(profondeur(fg,i+1)-1) + "|--+ " + str(profondeur(fg,i+1)) profondeur(fd,i+1)

---

et du coup au final quand je veux afficher mon arbre comme demandé :

Code:

---

1 2 3

def prettyprint(monarbre,0) profondeur(monarbre,0)

---

Mais je semble toujours avoir un problème..

Traverser une arborescence est un problème intéressant et tu as déjà compris que tu devais le faire avec une fonction récursive.

Mais il faudrait nous montrer l'arbre en question et aussi le résultat que tu obtiens parce que la simple phrase "Mais je semble toujours avoir un problème" ça ne nous dit rien.

Salut,

c'est déjà bien, la définition de la fonction ne lève plus d'erreur.
le problème c'est que tu ne nous dis pas quel est ton problème et que tu ne nous fourni pas d'exemple d'arbre pour tester.
dans ces conditions c'est difficile de t'aider.

fourni nous un exemple d'arbre à afficher et explique nous quel est le problème que tu constates.

Citation:

---

Envoyé par Tryph

Salut,

c'est déjà bien, la définition de la fonction ne lève plus d'erreur.
le problème c'est que tu ne nous dis pas quel est ton problème et que tu ne nous fourni pas d'exemple d'arbre pour tester.
dans ces conditions c'est difficile de t'aider.

fourni nous un exemple d'arbre à afficher et explique nous quel est le problème que tu constates.

---

Citation:

---

Envoyé par VinsS

Mais il faudrait nous montrer l'arbre en question et aussi le résultat que tu obtiens parce que la simple phrase "Mais je semble toujours avoir un problème" ça ne nous dit rien.

---

Salut,

pour vous répondre, l'arbre que je voudrais testé est le suivant :
Pièce jointe 143972

et je l'ai codé de cette façon :

Code:

---

1 2 3 4 5

monarbre = ( ("A",0), (("B",0.15), (("C",0.22), None, None), (("D",0.12), None, None)), (("E",0.2), (("F",0.18), None, None), (("G",0.22), None, None)))

---

quand je teste juste ma fonction profondeur j'obtiens ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

>>> profondeur(monarbre,0) + ('A', 0) + ('B', 0.15) + ('C', 0.22) |--+ 0 Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 7, in profondeur File "<stdin>", line 7, in profondeur TypeError: unsupported operand type(s) for -: 'NoneType' and 'int'

---

alors que je devrai avoir ceci : Pièce jointe 143974

de plus quand j'essaye d'utiliser ma fonction profondeur comme fonction chapeau j'obtiens une erreur :

Code:

---

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

def prettyprint(monarbre,0): profondeur(monarbre,0)   >>> def prettyprint(monarbre,0): File "<stdin>", line 1 def prettyprint(monarbre,0): ^ SyntaxError: invalid syntax >>> profondeur(monarbre,0) File "<stdin>", line 1 profondeur(monarbre,0) ^ IndentationError: unexpected indent

---

Merci

Salut,

Citation:

---

Envoyé par chlowecita

Salut,

pour vous répondre, l'arbre que je voudrais testé est le suivant :
Pièce jointe 143972

et je l'ai codé de cette façon :

Code:

---

1 2 3 4 5

monarbre = ( ("A",0), (("B",0.15), (("C",0.22), None, None), (("D",0.12), None, None)), (("E",0.2), (("F",0.18), None, None), (("G",0.22), None, None)))

---

---

A mes yeux, ça n'a pas grand sens, mais on a peut-être des manières de raisonner différentes.
Pourais tu expliquer la logique de ton code comme si on était des gamins de 6 ans ?

Question subsidiaire : On vous a appris à faire créer et utiliser des classes en cours ?

Citation:

---

Envoyé par Petibidon

Salut,

A mes yeux, ça n'a pas grand sens, mais on a peut-être des manières de raisonner différentes.
Pourais tu expliquer la logique de ton code comme si on était des gamins de 6 ans ?

Question subsidiaire : On vous a appris à faire créer et utiliser des classes en cours ?

---

Salut,

Je vais essayer.
Alors à partir de l'arbre encodé tel que :

Code:

---

1 2 3 4

monarbre = ( ("A",0), (("B",0.15), (("C",0.22), None, None), (("D",0.12), None, None)), (("E",0.2), (("F",0.18), None, None), (("G",0.22), None, None)))

---

qui lorsqu'on le "dessine" correspond à Pièce jointe 143977
Je souhaite l'afficher d'une manière plus agréable ce qui permettra tout au long de mon projet une lecture et un debogage facilité.
Donc je veux afficher mon arbre dans l'ordre préfixe ce qui revient à afficher, la racine (ici ('A',0), noté u), puis le fils gauche (n) de ma racine, puis le fils gauche (n+1) de mon fils gauche (n) etc, et ensuite le fils droit de mon fils gauche (n+1) puis le fils droit de mon fils gauche (n) etc.
Ensuite on passe à l'affichage du fils droit (n) de ma racine, puis le fils gauche de mon fils droit etc.

J'espère avoir été plus clair.. :s

Et quant à la question subsidiaire, la réponse est non.

Là tu répètes l'objectif de ton programme, pas la logique de ton code.

Ce que je veux que tu décrive, c'est la structure de ta variable "monarbre" : Selon quelle logique tu l'as implémentée de cette manière. Que représente chaque variable, chaque tuple, etc. Comme si on était des débiles.

Cette manière de décrire les choses te permettra de réfléchir à la manière dont tu as fait les choses, ce que tu comptes faire, et comment tu vas le faire, et peut-être de revoir ta structure pour simplifier la manière d'atteindre l'objectif.

Une vulgarisation de la programmation informatique, c'est expliquer des choses compliquées, avec un langage restreint, à quelqu'un qui ne réfléchit pas, mais qui fait exactement ce qu'on lui demande, ni plus, ni moins. Donc si tu arrives à décrire une manière de faire les choses qu'un enfant de 6 ans pourrait comprendre, tu as déjà une bonne partie de ton programme qui est écrit, y'a plus qu'à le traduire.

Hum je vois

Donc je prends la racine de mon arbre de base c'est de la que tout va commencer. Je la marque : + (A,0) avec A = racine 0 = la distance depuis la racine.
puis je vais à la ligne et je veux appliquer la meme chose au fils gauche de ma racine, donc ce fils gauche devient ma racine +1, et comme par rapport à ma racine initiale on est descendu d'un niveau je dois avoir :
+ ('A',0)
|--+ ('B', 0.15)

je descends encore d'un niveau tel que ('B', 0.15) devient ma nouvelle racine. Je m'occupe alors de son fils gauche. Comme de la racine initiale on est descendu d'encore un niveau je decale d'un espace de façon à avoir :
+ ('A',0) ==> racine initiale
|--+ ('B', 0.15) ==> racine +1
| |--+ (’C’, 0.22) ==> racine +2

ma racine +2 n'ayant pas de fils, je "remonte" à ma racine+1 et je veux afficher son fils droit. Le fils droit de racine+1 étant au meme niveau que racine+2 on y verra le même décalage

+ ('A',0) ==> racine initiale
|--+ ('B', 0.15) ==> racine +1
| |--+ ('C', 0.22) ==> racine +2
| |--+ ('D', 0.12)

Hors avec mon code je n'arrive à afficher que jusqu'au niveau racine+2 , sans l'affichage de ('D',0.12) et SANS les décalages.


Concernant la variable monarbre, elle nous à été donné tel quel par le prof. Mais de ce que je n'en ai compris : on a monarbre(u,fg,fd) avec u : racine fg : fils gauche, fd : fils droit.
mais chaque noeud de mon arbre est représenté par un tuple ('A',0) = A : noeud, 0 = distance du noeud A, à la racine de l'arbre.

dans ton script y a une ligne qui fait un peu mal à la tête, c'est celle-ci:

Code:

---

print "| " *(profondeur(fg,i+1)-1) + "|--+ " + str(profondeur(fg,i+1))

---

cette ligne est inutilement compliquée, elle ne fait pas ce que tu souhaite qu'elle fasse à mon avis et en plus elle finit par provoquer une erreur.

à mon avis, tu devrais la remplacer par un simple:

Code:

---

profondeur(fg,i+1)

---

tu verras que ça ne plante plus et que le résultat est pas si éloignée de ce que tu souhaite au final.
à partir de cette base incomplète mais saine, je pense que tu y verras plus clair. et sinon, il sera toujours temps de réclamer plus d'aide.

et une autre chose aussi, pense à remplacer cette variable "tree" dans le test de ton "if", ça marchera mieux aussi ;)

Citation:

---

pour vous répondre, l'arbre que je voudrais testé est le suivant :
Pièce jointe 143972

et je l'ai codé de cette façon :

Code:

---

1 2 3 4 5

monarbre = ( ("A",0), (("B",0.15), (("C",0.22), None, None), (("D",0.12), None, None)), (("E",0.2), (("F",0.18), None, None), (("G",0.22), None, None)))

---

---

Désolé mais ton arbre est inexact.

Soit le schéma initial soit les tuples imbriqués.

Le résultat que tu obtiens avec prettyprint correspond bien aux tuples mais ce n'est pas le schéma donné.

Si c'est ce schéma que tu dois définir, avec les valeurs numériques, les tuples ne sont pas adaptés tu dois utiliser un dictionnaire.

Ceci représente ton schéma:

Code:

---

1 2 3 4 5 6 7 8 9 10

tree = {"A": (0, {"B": (0.15, {"C": 0.22,}, {"D": 0.12,})}, {"E": (0.2, {"F": 0.18,}, {"G": 0.22,}) }) }

---

Si tu dois préserver les valeurs None, ça peut se faire.

Si l'arbre est fourni par son prof, y'a pas d'autre choix que de faire avec.
Il est exact, mais vraiment pas clair en fait.

Les fonctions déjà codées par chlowecita s'approchent de la solution mais nécessitent des corrections.

En les reprenant en expliquant de manière détaillée ce que doit faire chaque ligne, elle devrait arriver à avoir un algo correct qu'il y aura plus qu'à traduire.

Citation:

---

Envoyé par Petibidon

Si l'arbre est fourni par son prof, y'a pas d'autre choix que de faire avec.
Il est exact, mais vraiment pas clair en fait.

---

Non, il n'est pas exact.

je vois pas ce qu'il y a d'inexact dans cet arbre...
les données ne sont pas tout à fait dans le même ordre que sur l'image...?
si c'est ça, c'est juste un "problème" d'affichage, ça change rien à l'(in)exactitude des données.

après, discuter sur l'(in)exactitude de l'arbre, ça n'a aucun intérêt et ça n'aidera certainement pas le demandeur.
ce qu'il veut c'est l'afficher, pas debattre sur l'ordre des éléments qu'il contient.

Si c'est bien le schéma présenté qui doit être traité, alors je le redis, l'arbre est faux et le code ne pourra jamais produire qu'un résultat faux.

Code:

---

1 2 3 4 5

monarbre = ( ("A",0), (("B",0.15), (("C",0.22), None, None), (("D",0.12), None, None)), (("E",0.2), (("F",0.18), None, None), (("G",0.22), None, None)))

---

Cet arbre est ceci:

Code:

---

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

|---- ("A", 0) |---- ("B", 0.15) | |---- ("C", 0.22) | | |- None | | |- None | |---- ("D", 0.12) | |- None | |- None |---- ("E",0.2) |---- ("F", 0.18) | |- None | |- None |---- ("G",0.22) |- None |- None

---

où l'on voit que ("A",0) n'est le parent de rien du tout alors que sur le schéma il est parent de ("B", 0.15) et de ("E",0.2)


Edit: J'ajouterai que ("B", 0.15) et ("E",0.2) ne sont parent de rien du tout non plus.

Sisi, l'arbre est exact.
Si tu regarde bien, chaque niveau est un tuple (info, gauche, droite), où info est lui même un tuple... C'est illisible et capillotracté, mais correct.

je plussoie fermement ce que raconte Petitbidon et j'ajouterai que les None au bout des branches sont justement là pour signifier que c'est la fin de la branche et un code correct ne les affichera pas.
c'est d'ailleurs à ça que sert le "if tree == None:" dans le code de clowecita, à ceci près qu'il faut remplacer "tree" par "monarbre" pour que ça fonctionne.

et d'ailleurs, avec quelques petites corrections sur le code de clowecita, j'obtiens ça:

Code:

---

1 2 3 4 5 6 7

+ ('A', 0) |--+ ('B', 0.15) | |--+ ('C', 0.22) | |--+ ('D', 0.12) |--+ ('E', 0.2) | |--+ ('F', 0.18) | |--+ ('G', 0.22)

---

et il suffit d'inverser 2 lignes pour obtenir ce résultat qui est plus proche de l'image fournie:

Code:

---

1 2 3 4 5 6 7

+ ('A', 0) |--+ ('E', 0.2) | |--+ ('G', 0.22) | |--+ ('F', 0.18) |--+ ('B', 0.15) | |--+ ('D', 0.12) | |--+ ('C', 0.22)

---

Désolé Tryph, mais dans ton résultat ("A", 0) n'est pas le parent de ce qui suit, or c'est ce qui est exigé dans le schéma de base.

J'ai effectivement rajouter les None dans mon arbre pour éviter une vérification de plus, je les ai remplacés par des dictionnaires vides plus exactement.

Soit ceci:

Code:

---

1 2 3 4 5 6 7 8 9

arbre = {("A", 0): ({("B", 0.15): ({("C", 0.22): {}}, {("D", 0.12): {}})}, {("E", 0.2): ({("F", 0.18): {}}, {("G", 0.22): {}})}) }

---

Ce qui produit ceci:

Code:

---

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

vincent@tiemoko:~/Bureau$ python printtree.py ('A', 0) | |--('B', 0.15) | | | |--('C', 0.22) | |--('D', 0.12) |--('E', 0.2) | | | |--('F', 0.18) | |--('G', 0.22)

---

Citation:

---

Envoyé par Tryph

dans ton script y a une ligne qui fait un peu mal à la tête, c'est celle-ci:

Code:

---

print "| " *(profondeur(fg,i+1)-1) + "|--+ " + str(profondeur(fg,i+1))

---

cette ligne est inutilement compliquée, elle ne fait pas ce que tu souhaite qu'elle fasse à mon avis et en plus elle finit par provoquer une erreur.

à mon avis, tu devrais la remplacer par un simple:

Code:

---

profondeur(fg,i+1)

---

tu verras que ça ne plante plus et que le résultat est pas si éloignée de ce que tu souhaite au final.
à partir de cette base incomplète mais saine, je pense que tu y verras plus clair. et sinon, il sera toujours temps de réclamer plus d'aide.

et une autre chose aussi, pense à remplacer cette variable "tree" dans le test de ton "if", ça marchera mieux aussi ;)

---

Je ne comprends pas trop la. Remplacer toute ma ligne par

Code:

---

profondeur(fg,i+1)

---

?

En testant j'obtiens

Code:

---

1 2 3 4

>>> profondeur(monarbre,0) + ('A', 0) + ('B', 0.15) + ('C', 0.22)

---

Alors je vois pas en quoi ca résout mon problème.

Concernant l'arbre et son code c'est en effet du copier coller de ce que mon prof m'a fourni.

Citation:

---

Envoyé par Tryph

je plussoie fermement ce que raconte Petitbidon et j'ajouterai que les None au bout des branches sont justement là pour signifier que c'est la fin de la branche et un code correct ne les affichera pas.
c'est d'ailleurs à ça que sert le "if tree == None:" dans le code de clowecita, à ceci près qu'il faut remplacer "tree" par "monarbre" pour que ça fonctionne.

et d'ailleurs, avec quelques petites corrections sur le code de clowecita, j'obtiens ça:

Code:

---

1 2 3 4 5 6 7

+ ('A', 0) |--+ ('B', 0.15) | |--+ ('C', 0.22) | |--+ ('D', 0.12) |--+ ('E', 0.2) | |--+ ('F', 0.18) | |--+ ('G', 0.22)

---

---

C'est en effet la fonction des None selon mon cours. et c'est le code que je dois obtenir mais je ne vois pas comment en faisant la modif
sur

Code:

---

profondeur(fg,i+1)

---

tu as pu obtenir cela.

Citation:

---

Envoyé par VinsS

Désolé Tryph, mais dans ton résultat ("A", 0) n'est pas le parent de ce qui suit, or c'est ce qui est exigé dans le schéma de base.

---

bah biensur que si ("A", 0) est le parent de ce qui suit...
la représentation ne te parait sans doute pas évidente, tu estimes probablement que ta représentation est plus claire (et je suis d'accord sur ce point), ça n'empèche que ce n'est qu'une question de représentation.
et le fait que la représentation ne soit pas la meilleure n'en fait pas quelque chose de faux.

pour preuve, en modifiant juste la représentation, sans rien changer dans l'algo, j'obtiens ça:

Code:

---

1 2 3 4 5 6 7

('A', 0) |-('B', 0.15) | |-('C', 0.22) | |-('D', 0.12) |-('E', 0.2) | |-('F', 0.18) | |-('G', 0.22)

---

ce qui est plus proche de ce que tu considères comme juste, la ligne vide entre un parent et ses enfant en moins.


les données de l'arbre sont aussi plus clairement organisées dans un dictionnaire, je suis d'accord aussi sur ce point.
mais le fait est que le format de l'arbre d'entré est donné et qu'il n'est fait qu'avec des tuples. il faut faire avec...


le format de sortie attendu est donné aussi dans le premier post, et il faut encore une fois faire avec.
pour rappel:
http://www.developpez.net/forums/att...-14.28.38.png/
c'est très exactement ce que j'obtiens avec les données fournies sous forme de tuple et on pourrait tout aussi bien avoir le même résultat avec des données sous forme de dictionnaire

Citation:

---

Envoyé par chlowecita

Je ne comprends pas trop la. Remplacer toute ma ligne par

Code:

---

profondeur(fg,i+1)

---

?

En testant j'obtiens

Code:

---

1 2 3 4

>>> profondeur(monarbre,0) + ('A', 0) + ('B', 0.15) + ('C', 0.22)

---

Alors je vois pas en quoi ca résout mon problème.

---

attention, je n'ai pas dit que ça resoudrait ton problème, j'ai dit que le code ne planterait plus (en admettant que tu as aussi remplacé "tree" par "monarbre") et que tu aurais une base propre pour continuer.
et je te rassure, en faisant juste cette modification, j'ai exactement la même chose que toi: toutes les entrées qui s'affichent dans le bon ordre mais sans la représentation de l'arborescence.

Citation:

---

Envoyé par chlowecita

C'est en effet la fonction des None selon mon cours. et c'est le code que je dois obtenir mais je ne vois pas comment en faisant la modif
sur

Code:

---

profondeur(fg,i+1)

---

tu as pu obtenir cela.

---

y a méprise, pour obtenir ce résultat je me suis pas contenté de simplifier la ligne dont je t'ai parlé, j'ai fait d'autres corrections/ajouts (mais vraiment pas grand chose).
mais je n'ai pas l'intention de fournir le code entierement corrigé.
ce que je veux bien faire, c'est te donner des indices et des indications pour que tu réussisses toi-même à trouver la solution.

Oui j'ai bien fait les modifications :

Code:

---

1 2 3 4 5 6 7 8

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre print "+ " + str(u) print "| " *profondeur(fg,i+1) profondeur(fd,i+1)

---

ce que je ne comprends pas c'est pourquoi dans mon code cela s'arrete à ('C',0.22)

Code:

---

1 2 3 4

>>> profondeur(monarbre,0) + ('A', 0) + ('B', 0.15) + ('C', 0.22)

---

et pourquoi cette ligne n'est pas exécutée :

Code:

---

print "| " *profondeur(fg,i+1)

---

Peux tu expliquer ce que tu penses que doit faire cette ligne ?

Je dois me tromper mais pour moi elle affichait autant de "| " que de "niveau" que l'on descendait dans l'arbre pour le noeud correspondant.


J'ai essayé de mon coté de modifier un peu mon code.
La au moins j'ai tous les noeuds qui s'affiche et plus seulement les 3 premiers. Pour essayer d'y voir plus clair j'y ai rajouté des annotations mais je ne comprends pas le résultat obtenu.

Mon code :

Code:

---

1 2 3 4 5 6 7 8

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre print "+ " + str(u) print "| FILS GAUCHE " + str(profondeur(fg,i+1)) print "| FILS DROIT " + str(profondeur(fd,i+1))

---

et mon résultat :

Code:

---

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

>>> profondeur(monarbre,0) + ('A', 0) + ('B', 0.15) + ('C', 0.22) | FILS GAUCHE 0 | FILS DROIT 0 | FILS GAUCHE None + ('D', 0.12) | FILS GAUCHE 0 | FILS DROIT 0 | FILS DROIT None | FILS GAUCHE None + ('E', 0.2) + ('F', 0.18) | FILS GAUCHE 0 | FILS DROIT 0 | FILS GAUCHE None + ('G', 0.22) | FILS GAUCHE 0 | FILS DROIT 0 | FILS DROIT None | FILS DROIT None

---

ce que je ne comprends pas et que vous pourrez peut etre m'expliquer c'est pourquoi mes 3 premiers noeuds sont affiché comme des racines

Je comprends que pour cette partie on est
+ ('C', 0.22)
| FILS GAUCHE 0
| FILS DROIT 0
| FILS GAUCHE None

car ('C',0.22) n'a pas de fils gauche, pas de fils droit, mais pourquoi j'ai un fils gauche None ?
Cela viendrait de la facon de coder l'arbre ? Ou tous mon code de la fonction profondeur est pourri ?

Citation:

---

Envoyé par chlowecita

Je dois me tromper mais pour moi elle affichait autant de "| " que de "niveau" que l'on descendait dans l'arbre pour le noeud correspondant.

---

dans l'état actuel des choses, il est impossible que la ligne suivante t'affiche les différents niveaux

Code:

---

print "| " *profondeur(fg,i+1)

---

si tu regardes ta fonction profondeur, tu peux noter qu'elle ne ne peut renvoyer que 2 résultat différents:

• 0 si l'arbre qu'on lui a donné est égal à None
• rien si l'arbre qu'on lui a donné est différent de None. et en Python, "rien" se traduit par None (garde ça en tête ça va resservir plus tard)

donc ta ligne de code ci-dessus ne peut faire que 2 choses:

• afficher une chaine vide ("| " * 0) ç chaque niveau durant le parcours d'une branche
• provoquer une erreur ("| " * None) et faire planter le programme quand on arrive au bout de la branche

tu as déjà l'explication se rapportant au fait que seuls les 3 niveaux de la première branche étaient affichés.

Citation:

---

Envoyé par chlowecita

J'ai essayé de mon coté de modifier un peu mon code.
La au moins j'ai tous les noeuds qui s'affiche et plus seulement les 3 premiers. Pour essayer d'y voir plus clair j'y ai rajouté des annotations mais je ne comprends pas le résultat obtenu
....

Code:

---

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

>>> profondeur(monarbre,0) + ('A', 0) + ('B', 0.15) + ('C', 0.22) | FILS GAUCHE 0 | FILS DROIT 0 | FILS GAUCHE None + ('D', 0.12) | FILS GAUCHE 0 | FILS DROIT 0 | FILS DROIT None | FILS GAUCHE None + ('E', 0.2) + ('F', 0.18) | FILS GAUCHE 0 | FILS DROIT 0 | FILS GAUCHE None + ('G', 0.22) | FILS GAUCHE 0 | FILS DROIT 0 | FILS DROIT None | FILS DROIT None

---

ce que je ne comprends pas et que vous pourrez peut etre m'expliquer c'est pourquoi mes 3 premiers noeuds sont affiché comme des racines

---

pour les 3 niveaux qui sont affichés comme des racines, c'est tout à fait normal et faut suivre le déroulement du programme pour le comprendre.
voir les lignes en bleu ci dessous... et toutes les autres aussi en fait, il est important que tu comprennes comment se déroule ton programme.

Code:

---

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

la fonction profondeur est appelée avec l'arbre entier en argument ("A", 0), ... (niveau 0) la racine ("A", 0) est récupérée dans une variable, ainsi que le fils gauche ('B', 0.15), ... et le fils droit ("E",0.2), ... la racine est affichée: "+ " + str(u) -> + ("A", 0) la fonction profondeur est appelée avec le fils gauche ('B', 0.15), ... (niveau 1) la racine ('B', 0.15) est récupérée dans une variable, ainsi que le fils gauche ("C",0.22), ... et le fils droit ("D",0.12), .... faut bien comprendre qu'ici, monarbre n'est plus l'arbre entier, uniquement la branche gauche du premier niveau la racine est affichée: "+ " + str(u) -> + ("B", 0.15) la fonction profondeur est appelée avec le fils gauche ("C",0.22), ... (niveau 2) la racine ("C",0.22) est récupérée dans une variable, ainsi que le fils gauche None et le fils droit None. ici, monarbre n'est plus que la branche gauche de la première branche gauche la racine est affichée: "+ " + str(u) -> + ("C",0.22) la fonction profondeur est appelée avec le fils gauche None (niveau 3) la fonction profondeur du niveau 3 renvoie 0 affichage de "| FILS GAUCHE " + 0 la fonction profondeur est appelée avec le fils droit None (niveau 3) la fonction profondeur du niveau 3 renvoie 0 affichage de "| FILS DROIT " + 0 on est arrivé à la fin de la fonction profondeur pour le niveau 2, on ne renvoie rien; en vrai, c'est None qui renvoyé. affichage de "| FILS GAUCHE " + None la fonction profondeur est appelée avec le fils droit ("D",0.12), ... (niveau 2) ... je te laisse poursuivre à partir d'ici ...

---

Citation:

---

Envoyé par chlowecita

mais pourquoi j'ai un fils gauche None ?

---

la réponse est dans la ligne rouge et les quelques ligne précédentes du déroulement ci-dessus.

Citation:

---

Envoyé par chlowecita

Cela viendrait de la facon de coder l'arbre ? Ou tous mon code de la fonction profondeur est pourri ?

---

ça vient pas de l'arbre mais de ton code.
je dirais pas qu'il est pourri, mais je pense que t'as pas bien compris ce qu'est la récursion encore (le fait qu'une fonction s'appelle elle même). et du coup tu t'y prends mal pour afficher tes niveaux.
selon moi, la bonne façon de faire, c'est de pas chercher à récupérer le résultat de la fonction profondeur pour afficher les niveaux. quand tu appelles la fonction profondeur sur le fils gauche puis le fils droit, tu ne dois rien faire avec le retour de la fonction. tout ce qui est affichage doit être fait avant que la fonction profondeur s'appelle elle même.
pour être plus clair, toutes les instructions en rapport avec l'affichage doivent se trouver avant ces lignes:

Code:

---

1 2	profondeur(fg,i+1) profondeur(fd,i+1)

---

Citation:

---

Envoyé par Tryph

pour les 3 niveaux qui sont affichés comme des racines, c'est tout à fait normal et faut suivre le déroulement du programme pour le comprendre.
voir les lignes en bleu ci dessous... et toutes les autres aussi en fait, il est important que tu comprennes comment se déroule ton programme.

Code:

---

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

la fonction profondeur est appelée avec l'arbre entier en argument ("A", 0), ... (niveau 0) la racine ("A", 0) est récupérée dans une variable, ainsi que le fils gauche ('B', 0.15), ... et le fils droit ("E",0.2), ... la racine est affichée: "+ " + str(u) -> + ("A", 0) la fonction profondeur est appelée avec le fils gauche ('B', 0.15), ... (niveau 1) la racine ('B', 0.15) est récupérée dans une variable, ainsi que le fils gauche ("C",0.22), ... et le fils droit ("D",0.12), .... faut bien comprendre qu'ici, monarbre n'est plus l'arbre entier, uniquement la branche gauche du premier niveau la racine est affichée: "+ " + str(u) -> + ("B", 0.15) la fonction profondeur est appelée avec le fils gauche ("C",0.22), ... (niveau 2) la racine ("C",0.22) est récupérée dans une variable, ainsi que le fils gauche None et le fils droit None. ici, monarbre n'est plus que la branche gauche de la première branche gauche la racine est affichée: "+ " + str(u) -> + ("C",0.22) la fonction profondeur est appelée avec le fils gauche None (niveau 3) la fonction profondeur du niveau 3 renvoie 0 affichage de "| FILS GAUCHE " + 0 la fonction profondeur est appelée avec le fils droit None (niveau 3) la fonction profondeur du niveau 3 renvoie 0 affichage de "| FILS DROIT " + 0 on est arrivé à la fin de la fonction profondeur pour le niveau 2, on ne renvoie rien; en vrai, c'est None qui renvoyé. affichage de "| FILS GAUCHE " + None la fonction profondeur est appelée avec le fils droit ("D",0.12), ... (niveau 2) ... je te laisse poursuivre à partir d'ici ...

---

la réponse est dans la ligne rouge et les quelques ligne précédentes du déroulement ci-dessus.

---

Merci ! J'ai bidouillé mon code de pas grand chose

Code:

---

1 2 3 4 5 6 7 8 9 10

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre print "+ " + str(u)   profondeur(fg,i+1)   profondeur(fd,i+1)

---

Je comprends pourquoi (cf vos explications en bleues) tous mes noeuds sont affichés comme des racines. En effet, avec mon code j'obtiens ceci

Code:

---

1 2 3 4 5 6 7 8

>>> profondeur(monarbre,0) + ('A', 0) + ('B', 0.15) + ('C', 0.22) + ('D', 0.12) + ('E', 0.2) + ('F', 0.18) + ('G', 0.22)

---

parcontre je comprends pas cette partie

Citation:

---

Envoyé par Tryph

ça vient pas de l'arbre mais de ton code.
je dirais pas qu'il est pourri, mais je pense que t'as pas bien compris ce qu'est la récursion encore (le fait qu'une fonction s'appelle elle même). et du coup tu t'y prends mal pour afficher tes niveaux.
selon moi, la bonne façon de faire, c'est de pas chercher à récupérer le résultat de la fonction profondeur pour afficher les niveaux. quand tu appelles la fonction profondeur sur le fils gauche puis le fils droit, tu ne dois rien faire avec le retour de la fonction. tout ce qui est affichage doit être fait avant que la fonction profondeur s'appelle elle même.
pour être plus clair, toutes les instructions en rapport avec l'affichage doivent se trouver avant ces lignes:

Code:

---

1 2	profondeur(fg,i+1) profondeur(fd,i+1)

---

---

Je vois pas. J'ai essayé en placant un retour à la ligne

Code:

---

print "\n" "| "

---

avant

Code:

---

1 2	profondeur(fg,i+1) profondeur(fd,i+1)

---

[/QUOTE] mais ce n'est pas ca. Je ne sais pas quoi ecrire pour decaler d'un espace à chaque fois que je descends d'un niveau enfaite

J'ai essayé ca aussi du coup :

Code:

---

1 2 3 4 5 6 7 8 9 10

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre print "+ " + str(u) print "| " + "|-"*i profondeur(fg,i+1)   profondeur(fd,i+1)

---

Je pense pas être loin, enfin je l'espere vu le résultat que ca me donne

Code:

---

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

>>> profondeur(monarbre,0) + ('A', 0) | + ('B', 0.15) | |- + ('C', 0.22) | |-|- + ('D', 0.12) | |-|- + ('E', 0.2) | |- + ('F', 0.18) | |-|- + ('G', 0.22) | |-|-

---

Mais du coup mon problème ca serait la récursivité car les noeuds ne s'affichent pas la ou ils devraient à cause de

Code:

---

print "+ " + str(u)

---

je suis perdue.

Salut,

Je continue à chercher parce que ca m'embête vraiment et j'en suis venu à ca

Code:

---

1 2 3 4 5 6 7 8 9 10

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre print "+ " + str(u) print "| " * i + str(fg) print "|--+ " *i + str(fd) profondeur(fg,i+1) profondeur(fd,i+1)

---

qui me renvoie ceci :

Code:

---

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

>>> profondeur(monarbre,0) + ('A', 0) (('B', 0.15), (('C', 0.22), None, None), (('D', 0.12), None, None)) (('E', 0.2), (('F', 0.18), None, None), (('G', 0.22), None, None)) + ('B', 0.15) | (('C', 0.22), None, None) |--+ (('D', 0.12), None, None) + ('C', 0.22) | | None |--+ |--+ None + ('D', 0.12) | | None |--+ |--+ None + ('E', 0.2) | (('F', 0.18), None, None) |--+ (('G', 0.22), None, None) + ('F', 0.18) | | None |--+ |--+ None + ('G', 0.22) | | None |--+ |--+ None

---

C'est pas mieux j'ai l'impression et je pense que mon problème est sur la partie

Code:

---

1 2 3

print "+ " + str(u) print "| " * i + str(fg) print "|--+ " *i + str(fd)

---

au niveau du stockage des variables ? Mais malheureusement je ne vois pas comment faire. Si quelqu'un aurait une piste.. Merci !

Et je m'obstine et j'obtiens un résultat qui se rapproche de plus en plus à ce que je dois avoir normalement.

Mais PROBLEME je ne suis plus en récursif.

Code:

---

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

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre print "+ " + str(u) print "|--+" + str(fg[0]) print "| " *i + "|--+" + str(fg[i]) print "| " *i + "|--+" + str(fg[i+1]) print "|--+ " + str(fd[0]) print "| " *i + "|--+" + str(fd[i]) print "| " *i + "|--+" + str(fd[i+1])

---

qui me donne :

Code:

---

1 2 3 4 5 6 7 8

>>> profondeur(monarbre,1) + ('A', 0) |--+('B', 0.15) | |--+(('C', 0.22), None, None) | |--+(('D', 0.12), None, None) |--+ ('E', 0.2) | |--+(('F', 0.18), None, None) | |--+(('G', 0.22), None, None)

---

du coup je vois bien que j'aurai un problème lors de l'exécution de mon fichier test si j'ai un arbre qui va plus loin que i+2 mais je bute.. Help please

Salut,

bien tenté la méthode toute statique qui ne fonctionne que pour 2 niveaux mais c'est assez laid et comme tu le dis, c'est surtout pas très flexible. ;)

non l'idéal c'est bien la récursion et, comme tu l'as deviné, ton problème avec la version récursive se trouve ici (plus particulièrement aux lignes 2 et 3):

Code:

---

1 2 3

print "+ " + str(u) print "| " * i + str(fg) print "|--+ " *i + str(fd)

---

tu cherches ici à afficher la racine et ses 2 enfants, alors que tu n'as aucun besoin d'afficher les enfants puisque ceux-ci seront affiché quand tu appelleras la fonction profondeur avec chacun d'eux.
concrètement, dans la fonction profondeur, tu n'a à te soucier que de l'affichage de racine de l'arbre, soit la variable "u" dans ton code. et les ligne 2 et 3 du code ci dessus sont clairement en trop.
après tu as besoin d'afficher cette racine avec le bon nombre de décalages et ça tombe bien parce que tu connais ce nombre de décalage par le paramètre "i" de ta fonction.

Citation:

---

Envoyé par Tryph

Salut,

bien tenté la méthode toute statique qui ne fonctionne que pour 2 niveaux mais c'est assez laid et comme tu le dis, c'est surtout pas très flexible. ;)

non l'idéal c'est bien la récursion et, comme tu l'as deviné, ton problème avec la version récursive se trouve ici (plus particulièrement aux lignes 2 et 3):

Code:

---

1 2 3

print "+ " + str(u) print "| " * i + str(fg) print "|--+ " *i + str(fd)

---

tu cherches ici à afficher la racine et ses 2 enfants, alors que tu n'as aucun besoin d'afficher les enfants puisque ceux-ci seront affiché quand tu appelleras la fonction profondeur avec chacun d'eux.
concrètement, dans la fonction profondeur, tu n'a à te soucier que de l'affichage de racine de l'arbre, soit la variable "u" dans ton code. et les ligne 2 et 3 du code ci dessus sont clairement en trop.
après tu as besoin d'afficher cette racine avec le bon nombre de décalages et ça tombe bien parce que tu connais ce nombre de décalage par le paramètre "i" de ta fonction.

---

Tout d'abord merci de prendre le temps de m'aider.
C'est sans doute une question con, mais si les lignes 2 et 3 sont en trop, je ne vais afficher que

Code:

---

1 2 3 4 5 6 7

+ ('A', 0) + ('B', 0.15) + ('C', 0.22) + ('D', 0.12) + ('E', 0.2) + ('F', 0.18) + ('G', 0.22)

---

parce que du coup mon parametre i n'apparait plus :(

Salut,

effectivement, si tu ne fais qu'enlever les 2 lignes que je t'ai indiqué, tout s'affiche au même niveau.

mais si tu remplaces cette ligne:

Code:

---

print "+ " + str(u)

---

par celle-ci:

Code:

---

print "\t" * i + str(u)

---

ça donne quoi?

Citation:

---

Envoyé par Tryph

Salut,

effectivement, si tu ne fais qu'enlever les 2 lignes que je t'ai indiqué, tout s'affiche au même niveau.

mais si tu remplaces cette ligne:

Code:

---

print "+ " + str(u)

---

par celle-ci:

Code:

---

print "\t" * i + str(u)

---

ça donne quoi?

---

a oui du coup la j'ai les bons décalage il me reste juste à trouver un moyen d'afficher les " + " et les "| " *i + "|--+"
Merci beaucoup

Edit

Code:

---

1 2 3 4 5 6 7 8 9

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre print "\t" *i + "| " *(i-1) + "|--+ " + str(u)   profondeur(fg,i+1) profondeur(fd,i+1)

---

Comment je peux isoler la racine " véritable " de l'arbre, à savoir ('A',0) de facon à avoir

Code:

---

+('A',0)

---

et non pas

Code:

---

1 2 3 4 5 6 7 8

profondeur(monarbre,0) |--+ ('A', 0) |--+ ('B', 0.15) | |--+ ('C', 0.22) | |--+ ('D', 0.12) |--+ ('E', 0.2) | |--+ ('F', 0.18) | |--+ ('G', 0.22)

---

?

EDIT 2
Il doit y avoir une plus belle façon de le faire mais j'ai pensé à ca et ca à l'air de fonctionner

Code:

---

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

def profondeur(monarbre,i): if monarbre == None: return 0 else: (u,fg,fd) = monarbre if i == 0 : print "+ " + str(u) else: print "\t" *i + "| " *(i-1) + "|--+ " + str(u)   profondeur(fg,i+1) profondeur(fd,i+1)

---

Merci beaucoup ! Vraiment !

essaye d'enlever les tabulations (les "\t"), ça sera encore mieux.
je les ai mises dans l'exemple de mon post précédent juste pour te mettre sur la voie, si tu les laisses ça fait moche.


sinon pour la belle façon de faire:
- tester i == 0 pour repérer le racine de l'arbe me parait la bonne façon de faire (c'est plus ou moins ce que j'ai fait)
- pour ce qui est de l'affichage, je préfère construire ma chaine dans une variable (line dans le code ci-dessous) puis avoir une seule instruction print ensuite:

Code:

---

1 2 3 4 5 6

line = "" if i: line += "| " * (i - 1) line += "|--" line += "+ " + str(u) print line

---

mais ça c'est surtout une question de gout, d'autres diront qu'ils préfèrent mettre plusieurs print.

EDIT:
si tu veux faire du code plus "beau", ou en tout cas plus en accord avec les conventions de codage Python, tu peux chercher pep8 et pylint qui sont 2 utilitaires qui te prendront la tête pour que tu mettes bien des espace là ou il en faudrait (par exemple) ou inversement et bien plus encore...