Au lancement du programme la fenêtre 1 apparaît, le fenêtre 2 n'est
appellée que dans le cas ou le nom et le prénom ont été saisi, sinon la
fenêtre 3 est affichée avec un message d'erreur.
Le code :
#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
# Importation des modules
import pygtk
import gtk.glade
# On ne peut afficher la fentre rsultat que si l'utilisateur
# a bien saisi quelquechose
if TxtNom != "" and TxtPrenom != "":
WResult.show ()
else :
WErreur.show ()
# Zones de de saisie
Txtnom = gui.get_widget ("TxtNom").get_text ()
TxtPrenom = gui.get_widget ("TxtPrenom").get_text ()
#### Lancement de la boucle ###
# La fentre rsultat n'apparat que si l'utilisateur a cliqu sur le
# bouton OK
WResult.hide ()
WErreur.hide ()
# boucle gtk
gtk.main()
Je ne comprend pas pour quelle raison les fonctions doivent être
définient en premier. La structure de mon programme est elle correcte ?
Les variables TxtNom et TxtPrénom sont globales et contienent le texte
saisi par l'utilisateur, me trompe ais-je ?
Lors du lancement du programme la fenêtre 3 apparaît bien que j'ai
précisé au programme de la cacher (cf : WErreur.hide() ), si je clique
sur le bouton OK de la fenêtre 1 (WIndex) je peux lire dans la console
le message suivant :
TypeError: on_BtnOk_WIndex_clicked() takes at least 2 arguments (1 given)
Est-ce que ce message me dit que je ne passe moins d'agument à ma
fonction quelle devrais en recevoir ?
Le choix de : # -*- coding: iso-8859-15 -*- est-il judicieux ?
Si ce n'est pas le cas lequel me conseillez-vous ?
Glade :
Dans la propriété des boutons à la ligne RESPONSE ID j'ai mis 0 est-ce
une erreur ou bien dois je mettre un GTK_RESPONSE_ ?
Quel debugger/éditeur/IDE/IDE+Debugger utilisez vous ?
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles raisons un programme python doit être écrits avec ses fonctions en premier et le programme principal en dernier.
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles
raisons un programme python doit être écrits avec ses fonctions en
premier et le programme principal en dernier.
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles raisons un programme python doit être écrits avec ses fonctions en premier et le programme principal en dernier.
Laurent Pointal
Pascal Chenevas-Paule wrote:
Pascal Chenevas-Paule wrote:
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles raisons un programme python doit être écrits avec ses fonctions en premier et le programme principal en dernier.
Parce que le 'programme principal' est évalué là où il est trouvé, de même que les définitions de fonctions... et s'il est évalué avant que les fonctions ne soient définies (par leur évaluation), hé bien il ne les trouve pas.
Eventuellement tu peux faire:
def main() : # programme principal....
def f1(): # ...
def f2(): # ...
main()
Ainsi tu conserves ton code principal au début du module, et tu l'appelle quand tu veux. Avantage: un autre module peut importer ton module et appeler main() autant de fois que nécessaire.
Généralement, on fait même mieux: if __name__ == "__main__" : main()
Ainsi, si ton module est le module principal (lancé via "python lemodule.py"), alors le main est appelé, sinon le module est juste chargé - et donc ses fonctionnalités rendues disponibles pour d'autres modules.
Et enfin, le summum :-) def main(*args) : # ... if __name__ == "__main__" : main(sys.argv[1:])
Ton main peut être appelé soit directement avec les arguments en ligne de commande, soit par une fonction avec les arguments qu'elle veut.
Pascal Chenevas-Paule wrote:
Pascal Chenevas-Paule wrote:
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles
raisons un programme python doit être écrits avec ses fonctions en
premier et le programme principal en dernier.
Parce que le 'programme principal' est évalué là où il est trouvé, de
même que les définitions de fonctions... et s'il est évalué avant que
les fonctions ne soient définies (par leur évaluation), hé bien il ne
les trouve pas.
Eventuellement tu peux faire:
def main() :
# programme principal....
def f1():
# ...
def f2():
# ...
main()
Ainsi tu conserves ton code principal au début du module, et tu
l'appelle quand tu veux.
Avantage: un autre module peut importer ton module et appeler main()
autant de fois que nécessaire.
Généralement, on fait même mieux:
if __name__ == "__main__" : main()
Ainsi, si ton module est le module principal (lancé via "python
lemodule.py"), alors le main est appelé, sinon le module est juste
chargé - et donc ses fonctionnalités rendues disponibles pour d'autres
modules.
Et enfin, le summum :-)
def main(*args) :
# ...
if __name__ == "__main__" : main(sys.argv[1:])
Ton main peut être appelé soit directement avec les arguments en ligne
de commande, soit par une fonction avec les arguments qu'elle veut.
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles raisons un programme python doit être écrits avec ses fonctions en premier et le programme principal en dernier.
Parce que le 'programme principal' est évalué là où il est trouvé, de même que les définitions de fonctions... et s'il est évalué avant que les fonctions ne soient définies (par leur évaluation), hé bien il ne les trouve pas.
Eventuellement tu peux faire:
def main() : # programme principal....
def f1(): # ...
def f2(): # ...
main()
Ainsi tu conserves ton code principal au début du module, et tu l'appelle quand tu veux. Avantage: un autre module peut importer ton module et appeler main() autant de fois que nécessaire.
Généralement, on fait même mieux: if __name__ == "__main__" : main()
Ainsi, si ton module est le module principal (lancé via "python lemodule.py"), alors le main est appelé, sinon le module est juste chargé - et donc ses fonctionnalités rendues disponibles pour d'autres modules.
Et enfin, le summum :-) def main(*args) : # ... if __name__ == "__main__" : main(sys.argv[1:])
Ton main peut être appelé soit directement avec les arguments en ligne de commande, soit par une fonction avec les arguments qu'elle veut.
Pascal Chenevas-Paule
Laurent Pointal wrote:
Pascal Chenevas-Paule wrote:
Pascal Chenevas-Paule wrote:
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles raisons un programme python doit être écrits avec ses fonctions en premier et le programme principal en dernier.
Parce que le 'programme principal' est évalué là où il est trouvé, de même que les définitions de fonctions... et s'il est évalué avant que les fonctions ne soient définies (par leur évaluation), hé bien il ne les trouve pas.
Eventuellement tu peux faire:
def main() : # programme principal....
def f1(): # ...
def f2(): # ...
main()
Ainsi tu conserves ton code principal au début du module, et tu l'appelle quand tu veux. Avantage: un autre module peut importer ton module et appeler main() autant de fois que nécessaire.
Généralement, on fait même mieux: if __name__ == "__main__" : main()
Ainsi, si ton module est le module principal (lancé via "python lemodule.py"), alors le main est appelé, sinon le module est juste chargé - et donc ses fonctionnalités rendues disponibles pour d'autres modules.
Et enfin, le summum :-) def main(*args) : # ... if __name__ == "__main__" : main(sys.argv[1:])
Ton main peut être appelé soit directement avec les arguments en ligne de commande, soit par une fonction avec les arguments qu'elle veut.
Merci
Laurent Pointal wrote:
Pascal Chenevas-Paule wrote:
Pascal Chenevas-Paule wrote:
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles
raisons un programme python doit être écrits avec ses fonctions en
premier et le programme principal en dernier.
Parce que le 'programme principal' est évalué là où il est trouvé, de
même que les définitions de fonctions... et s'il est évalué avant que
les fonctions ne soient définies (par leur évaluation), hé bien il ne
les trouve pas.
Eventuellement tu peux faire:
def main() :
# programme principal....
def f1():
# ...
def f2():
# ...
main()
Ainsi tu conserves ton code principal au début du module, et tu
l'appelle quand tu veux.
Avantage: un autre module peut importer ton module et appeler main()
autant de fois que nécessaire.
Généralement, on fait même mieux:
if __name__ == "__main__" : main()
Ainsi, si ton module est le module principal (lancé via "python
lemodule.py"), alors le main est appelé, sinon le module est juste
chargé - et donc ses fonctionnalités rendues disponibles pour d'autres
modules.
Et enfin, le summum :-)
def main(*args) :
# ...
if __name__ == "__main__" : main(sys.argv[1:])
Ton main peut être appelé soit directement avec les arguments en ligne
de commande, soit par une fonction avec les arguments qu'elle veut.
C'est bon j'ai trouvé mes erreurs reste à comprendre pour quelles raisons un programme python doit être écrits avec ses fonctions en premier et le programme principal en dernier.
Parce que le 'programme principal' est évalué là où il est trouvé, de même que les définitions de fonctions... et s'il est évalué avant que les fonctions ne soient définies (par leur évaluation), hé bien il ne les trouve pas.
Eventuellement tu peux faire:
def main() : # programme principal....
def f1(): # ...
def f2(): # ...
main()
Ainsi tu conserves ton code principal au début du module, et tu l'appelle quand tu veux. Avantage: un autre module peut importer ton module et appeler main() autant de fois que nécessaire.
Généralement, on fait même mieux: if __name__ == "__main__" : main()
Ainsi, si ton module est le module principal (lancé via "python lemodule.py"), alors le main est appelé, sinon le module est juste chargé - et donc ses fonctionnalités rendues disponibles pour d'autres modules.
Et enfin, le summum :-) def main(*args) : # ... if __name__ == "__main__" : main(sys.argv[1:])
Ton main peut être appelé soit directement avec les arguments en ligne de commande, soit par une fonction avec les arguments qu'elle veut.
