J'essaie de comprendre comment fonctionne la fonction fournie dans le corrigé, qui doit créer un labyrinthe à partir d'une chaîne.
Je ne suis même pas capable de faire fonctionner le corrigé
Bref, le code :
def creer_labyrinthe_depuis_chaine(chaine):
"""Crée un labyrinthe depuis une chaîne.
Les symboles sont définis par correspondance ici.
"""
symboles = {
"o": Mur,
"x": Robot,
".": Porte,
"u": Sortie,
}
x = 0
y = 0
robot = None
obstacles = []
for lettre in chaine:
if lettre == "\n":
x = 0
y += 1
continue
elif lettre == " ":
pass
elif lettre.lower() in symboles:
classe = symboles[lettre.lower()]
objet = classe(x, y)
if type(objet) is Robot:
if robot:
raise ValueError("il ne peut y avoir qu'un robot")
robot = objet
else:
obstacles.append(objet)
else:
raise ValueError("symbole inconnu {}".format(lettre))
x += 1
labyrinthe = Labyrinthe(robot, obstacles)
return labyrinthe
j'ai essayé de le tester comme ça :
if __name__ == "__main__" :
ch = """OOOOO. . OOO\n
O... O\n
O O\n
OOOOOOOO"""
creer_labyrinthe_depuis_chaine(ch)
charger_labyrinthe()
mais ça marche pas.
Il doit bien y avoir un moyen de le faire fonctionner indépendamment du programme, puisque c'est une fonctionne qui est indépendante des autres classes.
Mur/Robot/etc... sont appelés comme des variables non-définies. Donc ça ne peut pas marcher. Elles doivent être déclarées plus haut dans ton programme. Sinon il faut modifier le code que tu nous présente pour qu'il soit fonctionnel de façon indépendante.
oulà, j'ai rien compris. C'est décourageant parfois
Dans les choses à faire pour ce TP, il fallait, je cite : "permettre la création d'un labyrinthe depuis une chaîne de caractères"
Je n'ai pas compris à l'époque ce que ça voulait dire, et je ne comprends malheureusement toujours pas, même avec le corrigé entre les mains.
Pour moi, pour que l'utilisateur puisse créer un labyrinthe, il lui suffit d'ouvrir un éditeur de texte, faire son labyrinthe avec ses "O", ses "." et ses espaces, l'enregistrer dans l'onglet 'cartes', et c'est terminé.
Chez moi, c'est suffisant pour avoir une nouvelle carte, qui peut être utilisée par le programme.
Donc je ne comprends pas à quoi peut ressembler une fonction qui créée un labyrinthe à partir d'une chaîne, ni à quoi elle peut bien servir. Et, encore une fois, même avec le corrigé je ne comprends toujours pas.
Donc, pour "créer un labyrinthe depuis une chaîne", il faudrait : saisir une chaîne, puis utiliser la def qui transforme la chaîne en un objet labyrinthe, mais uniquement pour l'utiliser dans le reste du programme ?
Pour ça que le programme du corrigé utilise Pickle ?
Je pense que le problème, c'est que je n'ai pas compris le corrigé du tout. Je n'ai pas compris comment il fonctionnait ce labyrinthe, et je n'ai pas vraiment cherché puisque le mien fonctionne. (et ça semble bien plus simple d'y ajouter de nouveaux labyrinthes)
Je crois que je vais laisser tomber.
Pour la suite du TP, je vais faire ce que je sais, c'est à dire pas grand chose. Je serai au bout du cours Python OC, dommage d'en savoir aussi peu après avoir passé autant de temps sur ce cours (les 40h prévues, je pense que c'est une blague, pas très marrante d'ailleurs)
Je n'ai jamais suivis de cours python sur OC donc je en sais pas ce qu'il vaut niveau pédagogie, mais je suis là pour t'aider à comprendre les bases.
Je vais te faire une description ligne par ligne du corrigé. Mais il faut juste que tu persévères un peu!
Je réédite mon message avec le corrigé commenté dans quelques minutes.
----
# La fonction prend en paramètre une chaine de caractère, et renvoi un OBJET de TYPE : Labyrinthe
def creer_labyrinthe_depuis_chaine(chaine):
"""Crée un labyrinthe depuis une chaîne.
Les symboles sont définis par correspondance ici.
"""
# Ceci est un dictionnaire, il sert à faire le lien entre un caratère 'o' et une CLASSE Mur
symboles = {
"o": Mur,
"x": Robot,
".": Porte,
"u": Sortie,
}
# On parcour la boucle pour créer le labyrinthe (x = longueur * y = hauteur)
# Un index pour la colonne (largeur)
x = 0
# Un index pour la ligne (hauteur)
y = 0
# Ton OBJET robot
robot = None
# Une liste d'OBJETS constitué d'obstacle
obstacles = []
# Pour chaque lettre dans ta chaine
for lettre in chaine:
# si la lettre est "\n" => Ca signifie une nouvelle ligne
if lettre == "\n":
# On remet donc l'index de la colone à 0
x = 0
# On incrémente l'index de la ligne
y += 1
# On n'effectue pas les opération du bas de la boucle
continue
# Dans ce cas, on fait rien
elif lettre == " ":
pass
# Dans ce cas :
elif lettre.lower() in symboles:
# On récupère le TYPE de CLASSE définit dans le DICTIONNAIRE définit plus haut, exemple symboles['o'] => Mur
classe = symboles[lettre.lower()]
# On créer notre OBJET grâce au type récupéré juste au dessus, exemple objet = Mur(2,2)
objet = classe(x, y)
# Si le TYPE de l'objet est un robot
if type(objet) is Robot:
# Si il en existe déjà un on lève une erreur
if robot:
raise ValueError("il ne peut y avoir qu'un robot")
# Sinon on définit notre robot
robot = objet
# Sinon, pour n'importe quel autre TYPE d'objet
else:
# On ajoute l'objet en cours en tant "qu'obstacle" à la liste des obstacles
obstacles.append(objet)
else:
raise ValueError("symbole inconnu {}".format(lettre))
#On incrémente l'index de la colonne
x += 1
# On créer l'OBJET de TYPE Labyrinthe avec les PARAMETRES : OBJET de TYPE Robot, Listes d'OBJET (étant des d'obstacles)
labyrinthe = Labyrinthe(robot, obstacles)
# On retourne l'OBJET Labyrinthe
return labyrinthe
En espérant que ça t'aide !
A quoi ça va servir ?
Ca va surement permettre de faire "tonLabyrinthe.robot.position", ce qui te renverra la position du robot dans le labyrinthe (x,y) => "Le robot est à la case 3,6", et bien d'autre chose.
- Edité par WorstDevEver 29 juillet 2019 à 15:45:24
OK merci d'avoir pris tout ce temps pour m'aider. Je comprends à peu près comment il est fait.
Ce qui me gène, c'est que cette fonction n'est pas utilisée.
Dans le programme, on devait pouvoir, en effet, créer un labyrinthe depuis une chaîne.
Donc la fonction est là, sauf qu'on ne peut pas l'utiliser telle quelle. OK. Mais elle n'est pas non plus utilisée dans le programme. Je viens de faire une recherche, je ne la vois pas.
Donc c'est un oubli ? Il a fait une fonction et a oublié de l'intégrer dans le programme ?
Quoi qu'il en soit, on nous demande de documenter notre code pour indiquer comment il doit être utiliser. Autant dire que si je devais noter celui qui a pondu ce corrigé.....
Edit : je suis désolée. Je ne cherche pas la petite bête, simplement pour bien comprendre comment est fait un programme, j'ai BESOIN de l'utiliser, pour voir ce qu'il fait. Or là je n'y arrive pas. Je ne trouve pas de moyens de l'utiliser. Donc je ne l'ai pas vu fonctionner.....du coup c'est très abstrait tout ça
Comme je t'ai dis, je ne connais pas du tout le projet, c'est bien possible qu'il ne soit pas utilisé et ce serait bien dommage. Surtout que c'est pas vraiment pour "débutant" de faire des choses tel que stocker des classes dans un dictionnaire pour mapper des objets dynamiquement.
Du coup c'est pas très grave pour ton apprentissage si tu n'utilise pas ce code (si ça te bloque pas pour la suite des exo).
Essais juste de comprendre son fonctionnement ligne par ligne et pose des questions si t'en as.
Mais c'est sur que pour un corrigé c'est pas bien documenté
Disons qu'il y a 2 TP Roboc, le 2ème consistant à améliorer le 1er.
Cette fonction je ne l'ai pas faite, en effet, dans ma 1ère version, je ne voyais pas l'intérêt.
Sauf que là, pour l'amélioration, des tests unitaires sont exigés, et l'un d'entre eux doit vérifier justement la création d'un labyrinthe à partir d'une chaine de caractère.
Donc je voulais la faire, cette possibilité, pour pouvoir faire le test unitaire qui va avec.
Mais je ne vais pas reprendre le corrigé, puisqu'il n'est pas adapté à la façon dont j'ai conçu mon programme.
Pour ça que j'essayais un peu désespérément de le comprendre.
Si je comprenais comment il fonctionne, concrètement comment on l'utilise, je pourrai proposer quelque chose de similaire.
Tant pis.
TP Roboc
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Try->Fail->Learn->Converge to success :![{\displaystyle Q[s,a]:=(1-\alpha )Q[s,a]+\alpha (r+\gamma ~max_{a'}Q[s',a'])}](https://wikimedia.org/api/rest_v1/media/math/render/svg/6a01e974f96c943191b14eb85bd8657ea01a4cd5)
Try->Fail->Learn->Converge to success :![{\displaystyle Q[s,a]:=(1-\alpha )Q[s,a]+\alpha (r+\gamma ~max_{a'}Q[s',a'])}](https://wikimedia.org/api/rest_v1/media/math/render/svg/6a01e974f96c943191b14eb85bd8657ea01a4cd5)
Try->Fail->Learn->Converge to success :![{\displaystyle Q[s,a]:=(1-\alpha )Q[s,a]+\alpha (r+\gamma ~max_{a'}Q[s',a'])}](https://wikimedia.org/api/rest_v1/media/math/render/svg/6a01e974f96c943191b14eb85bd8657ea01a4cd5)
Try->Fail->Learn->Converge to success :![{\displaystyle Q[s,a]:=(1-\alpha )Q[s,a]+\alpha (r+\gamma ~max_{a'}Q[s',a'])}](https://wikimedia.org/api/rest_v1/media/math/render/svg/6a01e974f96c943191b14eb85bd8657ea01a4cd5)