On m'a dit de pas trop utiiser les global variable, mais là je vois pas trop d'autre solution. Du coup je fais des fonctions qui prennent global inventaire et global lieu_actuel et je refais un input dans la fonction pour demander quel objet, ça me semble le plus simple...

Franchement je crois que je vais tout mettre dans le même fichier et arrêter de faire des modules

Je ne sais pas si j'ai bien compris, mais dans ce que je t'expliquais, tu n'as pas de variables dans ton dictionnaire. Tu as seulement un nom de fonction et tu fais l'appel après avoir récupéré le nom de la fonction. Il n'y a donc pas de raison d'avoir d'erreur dans ce cas.

Si le problème vient du fait que tu passes pas toujours le même nombre de paramètres aux fonctions que tu appelles, tu peux aussi procéder autrement dans ton dictionnaire en associant à la clé un tuple (nomdetafonction, tuple des paramètres). Tu récupère ensuite le nom de la fonction et le tuple dans des variables séparées. Pour le passer en arguments, tu fais nomdelafonction(*tuple des paramètres) comme j'ai posté plus haut.

Après, si tu veux faire l'appel à la fonction dans le dictionnaire, tu peux utiliser des valeurs par défaut comme tu l'as dit. Je te déconseille les variables globales personnellement, c'est plus un nid à erreurs qu'autre chose.

Sans voir ton code, c'est difficile de te dire ce qui est le plus approprié, c'est à toi de prendre la décision.

Je te comprends. C'est un peu un enfer à gérer au début, les différents fichiers.

Personnellement, si le fichier n'est pas trop long et que les fonctions sont bien organisée en catégories à l'intérieur du code, ça me dérange pas. Après, les profs sont généralement très à cheval là-dessus parce que ça leur facilite la tâche au niveau compréhension puisque ça t'oblige à bien organiser tes fonctions.

Hmm j'ai peut-être mal compris ce que tu m'expliquais, car moi quand j'ai fais mon dico là, j'ai:
dicoFonc = {
"desc": foncDesc(),
"prendre": foncPrendre(),
}
Du coup là je l'ai mis dans mon fichier fonctions, et quand je l'import depuis mon fichier principal, eh bien il me lance toutes les fonctions qu'il y a dedans j'ai l'impression. Donc là je fais directement appel aux fonctions dans le dico, ce qu'il ne faudrait pas faire je présume ? Il faudrait juste que je mette le nom de la fonction et que j'y fasse appel seulement si l'utilisateur entre le mot qui y est associé ? Du coup je dois écrire quoi, juste foncPrendre sans les () ? Et après j'y fais appel ?

Ahh oui après des tests ça a l'air d'être ça, je dois mettre les parenthèse après le dico: dict[var](), si je comprends bien

Voilà, c'est saoulant, quand je mets mon dico dans mon fichier fonction:
dicoFonc = {
"desc" : (foncDesc,(lieu_actuel,inventaire)),
"prendre" : (foncPrendre,(lieu_actuel,inventaire)),
}

Il me sort des NameError pour lieu_actuel et inventaire. Et je peux pas les définir dans mon fichier données, car sinon quand j'appelle n'importe quelle fonction, elle reprend les lieu_actuel et inventaire de base (à cause du from données import* en haut du fichier fonctions), qui sont définis dans données, et non les nouveaux définis dans le fichier principal...
C'est ça qui m'arrive hyper souvent et c'est pour ça que je voudrai tout mettre dans le même fichier ! Du coup, je dois mettre mon dico de fonction dans le fichier principal, c'est la seule solution que je vois...

Le 07 mai 2016 à 17:08:02 TinySergi a écrit :
Hmm j'ai peut-être mal compris ce que tu m'expliquais, car moi quand j'ai fais mon dico là, j'ai:
dicoFonc = {
"desc": foncDesc(),
"prendre": foncPrendre(),
}
Du coup là je l'ai mis dans mon fichier fonctions, et quand je l'import depuis mon fichier principal, eh bien il me lance toutes les fonctions qu'il y a dedans j'ai l'impression. Donc là je fais directement appel aux fonctions dans le dico, ce qu'il ne faudrait pas faire je présume ? Il faudrait juste que je mette le nom de la fonction et que j'y fasse appel seulement si l'utilisateur entre le mot qui y est associé ? Du coup je dois écrire quoi, juste foncPrendre sans les () ? Et après j'y fais appel ?

Ouep, c'est ça. Tu veux pas appeler la fonciton, juste récupérer une variable qui pointe vers la fonction pour l'appeler après

Le 07 mai 2016 à 17:28:30 TinySergi a écrit :
Voilà, c'est saoulant, quand je mets mon dico dans mon fichier fonction:
dicoFonc = {
"desc" : (foncDesc,(lieu_actuel,inventaire)),
"prendre" : (foncPrendre,(lieu_actuel,inventaire)),
}

Il me sort des NameError pour lieu_actuel et inventaire. Et je peux pas les définir dans mon fichier données, car sinon quand j'appelle n'importe quelle fonction, elle reprend les lieu_actuel et inventaire de base (à cause du from données import* en haut du fichier fonctions), qui sont définis dans données, et non les nouveaux définis dans le fichier principal...
C'est ça qui m'arrive hyper souvent et c'est pour ça que je voudrai tout mettre dans le même fichier ! Du coup, je dois mettre mon dico de fonction dans le fichier principal, c'est la seule solution que je vois...

Sans le code, c'est difficile de te dire, mais tu peux mettre ton dictionnaire dans ton fichier principal. Je sais pas comment tu as divisé tes fichiers mais personnellement je met les fonctions dans des fichiers annexes et je garde le déroulement du programme, donc toutes les variables nécessaires, dans le programme principal. Le dictionnaire reste stocké dans une variable que tu utilises après donc tu devrais le garder dans le programme principal.

Ouais ça marche si je mets mon dico dans le principal, enfaite les variables que je mets dans les données ça peut que être des variables constantes j'ai l'impression, sinon ça couille. Mais là ton truc avec le couple fonction/tuple ça marche bien, c'est top !

Par contre pour les fonctions qui renvoient quelque chose, la fonction prendre qui renvoie le nouvel inventaire par exemple, j'avais pensé à récupérer ce qu'elles renvoient comme ça:

dicoFonc = {
NORD : (foncLoc,(NORD,lieu_actuel),lieu_actuel),
SUD : (foncLoc,(SUD,lieu_actuel),lieu_actuel),
OUEST : (foncLoc,(OUEST,lieu_actuel),lieu_actuel),
EST : (foncLoc,(EST,lieu_actuel),lieu_actuel),
"desc" : (foncDesc,(lieu_actuel,inventaire),lieu_actuel),
"prendre" : (foncPrendre,(lieu_actuel,inventaire),inventaire),
}
fonction,parametres,var_retour = dicoFonc[ordre]
var_retour = fonction(*parametres)

J'ai rajouté dans le tuple contenant le nom de la fonction et le tuple des parametres, le nom de la variable qui doit changer avec le retour de la fonction.
Mais quand je fais: var_retour = fonction(*parametres), ça ne marche pas car bien qu'elles contiennent la même chose, les deux variables ne sont pas les mêmes, du coup j'ai juste créé une nouvelle variable var_retour, à la place de remplacer la variable qui doit changer par le retour de la fonction.(lieu_actuel dans ce cas là). Du coup je vois pas vraiment comment je pourrai faire...

Peut-être que je pourrai enfin utiliser des global variable

Le 07 mai 2016 à 19:20:09 TinySergi a écrit :
Mais quand je fais: var_retour = fonction(*parametres), ça ne marche pas car bien qu'elles contiennent la même chose, les deux variables ne sont pas les mêmes, du coup j'ai juste créé une nouvelle variable var_retour, à la place de remplacer la variable qui doit changer par le retour de la fonction.(lieu_actuel dans ce cas là). Du coup je vois pas vraiment comment je pourrai faire...

Je suis désolé mais j'ai beau relire, je ne comprend vraiment pas ce que tu veux dire. Tu peux préciser ? Notamment le "les deux variables"

Le 07 mai 2016 à 19:28:41 TinySergi a écrit :
Peut-être que je pourrai enfin utiliser des global variable

"Je ne peux rien lui apprendre, cet enfant n'a aucune patience. Trop de colère en lui, comme son père. Il n'est pas prêt."

Je crois que je l'aie finalement. Est-ce que définir les variables au début du programme et fournir ces varaibles à une fonction qui réalise le déroulement ne résoudrait pas ton problème ?
Dans tous les cas, je pense que tu peux te passer des variables globales en les fournissant en entrée

Pourquoi tant de haine envers les variables global ?

Je réexplique alors, c'est vrai que j'ai été un peu brouillon:
On a donc le système de dico qui associe les possibles entrées utilisateurs en clé ("prendre") à un un tuple qui contient: le nom de la fonction qui va gérer l'action (foncPrendre) et les variables qui sont à entrer dans ladite fonction (lieu_actuel, pour controler si l'objet se trouve bien dans la pièce, et inventaire, pour pouvoir y ajouter l'objet). Normalement on aurait aussi besoin du nom de l'objet à prendre, mais j'ai préféré mettre un objet=input("Que voulez-vous prendre ?") dans la fonction prendre, parce que sinon j'y arrivais pas.
En faisant dico["prendre"], on a donc le mot "prendre" qui pointe sur notre fonction et les parametres qu'elle doit prendre. Mais le problème c'est que certaines fonctions renvoient une nouvelle valeur (un nouvel inventaire pour foncPrendre). Du coup je voulais faire un système où on ajoute au tuple contenant le nom de la fonction et le nom des parametres le nom de la variable qu'elle doit changer. On aurait donc dico={"prendre": (foncPrendre,(lieu_actuel,inventaire),inventaire))}, le deuxième "inventaire" signifiant que la variable à modifier via la fonction serait l'inventaire.
On pourrait donc faire: fonction,paramtres,var_à_changer = dico["prendre"] et du coup:
var_à_changer=fonction(*parametres) qui devrait donner concrètement
inventaire = foncPrendre(lieu_actuel,inventaire). Mais le problème, c'est qu'en faisant ça on a pas inventaire =, mais var_à_changer= car on juste recréé une variable qui prend la valeur de l'inventaire.
Alors voilà, soit cette technique ne peut pas marcher, soit je suis assez proche de la solution, mais là je vois pas comment changer les variables qui prennent la valeur renvoyée par la fonction.
C'est pour ça qu'en utilisant global inventaire dans ma fonction, je modifie directement l'inventaire et j'ai rien besoin de mettre en return, ce qui est bien plus simple

Parce que les variables globales sont toujours dangereuses... C'est plus safe de tout faire localement, histoire d'avoir vraiment les variables associées à la fonctionnalité qu'elles doivent avoir.

Sinon j'arrive pas à comprendre le problème en fait, pourquoi, tu ne peux pas tout simplement faire var_à_changer = dico["prendre"](*paramètres) ?

Pourquoi être rentrer dans cette histoire de triples valeurs inscrites pour chaque clé du dico ?

Je n'ai pas suivi la discussion totalement la discussion, mais j'ai du mal à saisir...

Car rajouter le tuple des parametres à rentrer dans la fonction ça simplifie la tâche, étant donné que les fonctions peuvent avoir des paramètres différents. Je peux me contenter de faire dico["prendre"], et j'ai directement ma fonction toute prête à être utilisée. Sinon je devrai préciser les paramètres après, comme tu l'as fait. Mais puisque toutes les fonctions du dico n'ont pas forcément les même paramètres, c'est un peu chiant.
Enfin c'est comme ça que je le vois, après si t'as un truc plus simple à me proposer...
Avec var_à_changer = dico["prendre"](*paramètres) il faudrait refaire des tests pour savoir à quel fonction on a affaire pour pouvoir y mettre les bons paramètres, et utiliser le dico c'était justement pour éviter ça.

La troisième valeur dans le tuple c'est la variable retour de la fonction, qui elle aussi n'est pas forcément la même pour chaque fonction, mais j'ai pas encore trouver la technique pour avoir au final mon
inventaire=prendre(lieu_actuel,inventaire)

Enfaite le fait d'avoir ma liste de parametres en tuple dans le dico va rendre ces paramètres immuables ?

Hmm enfaite après test, en changeant le tuple par une liste la valeur de mon dico reste la même
en gros je peux faire:
a=2 dico={"string":a}
en faisant dico["string"] il me sort 2, logique...
mais après si je fais:
a=8 dico["string"] eh bien il me ressort 2... ce qui est enquiquinant mais qui explique mes déboires. Du coup la technique des dicos ne peut pas marcher, car j'ai des fonctions qui doivent prendre des parametres qui ne sont pas constants...

(j'arrive dans la discussion, je répond juste au dernier post, jaypalu les autres )

Fais plutôt ça:

def get_a():
    return a
a = 2
dico = {"string":get_a}
#ici, dico["string"]() retourne 2
a = 8
#ici, dico["string"]() retourne 8

C'est un bricolage, mais vu qu'apparemment tu veux pas faire de l'orienté objet...

Et pour répondre à ton post du dessus : les tuples sont TOUJOURS immuables. Ca veut dire que si mon_tuple = (x,y,z), tu pourrais JAMAIS assigner une valeur comme ça: mon_tuple[1] = .... Les strings aussi sont immuables, par exemple. En revanche, rien ne t'empeche de mettre des objets (ou référence vers des objets) dans un tuple. Ainsi si l'objet "a" possède un attribut "x", tu as le droit de faire:mon_tuple = ("lol",a,"troll") puis mon_tuple[1].x = 12.