Discussion :

[spirzouf]

Bonsoir,

Je débute depuis quelques jours en python.
J'ai réalisé un petit programme d'essai qui fonctionne très bien dans le shell. Il demande le nom du 'joueur' et lui fait faire des additions aléatoires de 2 valeurs comprises entre 0 et 10. Ne rien entrer comme réponse fait quitter le programme.

voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#!/usr/bin/ python
# -*- coding: utf-8 -*-
 
# Programme permettant de s'entrainer au calcul mental
# en générant aléatoirement des opérations simples à
# résoudre
 
from random import randrange
 
def addition(min,max):
    max += 1 # inclure la borne supérieure pour la randomisation
    a = randrange(min, max)
    b = randrange(min, max)
    reponse = raw_input ('{0} + {1} = '.format (str(a),str(b)))
    resultat = str(a + b)
    if reponse == resultat :
        print( 'Tout bon !!' )
    elif reponse == '':
	print( 'Fini de jouer !! Va ranger ta chambre {0} !!'.format(nom) )
    else:
        print( 'NON {0} !!! la bonne réponse était {1}'.format(nom,resultat) )
    return reponse
 
nom = raw_input("Bonjour, comment t'appelles-tu ? ")
boucle = True
while boucle:
    if addition(0,10) == '':
	boucle = False

Je souhaite le porter dans une interface graphique (sous Tkinter puisque je poste ici), et là c'est la cata...

j'ai grand mal à me représenter le fonctionnement des objets / classes (j'ai lu entièrement le swaroop et feuilleté le Swinnen, mais tout est loin d'être encore clair)

voici mon code d'essai qui évidemment doit contenir des énormités... Merci d'avance de toute remarque utile voire d'exemple fonctionnel qui me permettrait de comprendre comment cela fonctionne.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#!/usr/bin/ python
# -*- coding: utf-8 -*-
 
# Programme permettant de s'entrainer au calcul mental
# en générant aléatoirement des opérations simples à
# résoudre
 
from Tkinter import *
from random import randrange
 
class Application(Tk):
    def __init__(self):
        Tk.__init__(self)
	question = Label(self)
	question.pack()
	saisie = Entry(self)
	saisie.pack()
	message = Label(self)
	message.pack()
 
        self.mainloop()
 
app = Application()
 
# intervalle de randomisation
mini, maxi = 0, 10 # les nombres aléatoire seront tirés dans l'intervalle [0,10]
maxi += 1 # inclure la borne supérieure pour la randomisation
 
while True:
    # initialisation des variables
    a = randrange(mini, maxi)
    b = randrange(mini, maxi)
    questionText = str('{0} + {1} = '.format (str(a),str(b)))
    resultat = str(a + b)
    reponse = None
    # affichage de l'opération à effectuer au niveau du Label 'question'
    app.question.config(text = questionText)
    app.question.update()
 
    # saisie de la réponse
    print(repr(reponse))
    reponse= str(app.saisie.get())
    # test de la réponse et affichage d'un message adapté au niveau du Label 'message'
    if reponse == resultat :
	app.message.config(text= "bien joué ! on essaye encore") # afficher un message de félicitation
    elif reponse == 'stop':
	app.message.config(text= "D'accord, à bientot") # afficher un message d'adieu
	app.quit()
	break
    else:
	app.message.config(text= "NON !!! la bonne réponse était {0}".format(resultat)) # afficher un message d'erreur avec le résultat

Cordialement,

Spirzouf

[PauseKawa]

Bonjour,

Pas trop de casse en fait.

Je te laisse tester cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
#!/usr/bin/ python
# -*- coding: utf-8 -*-
 
# Programme permettant de s'entrainer au calcul mental
# en générant aléatoirement des opérations simples à
# résoudre
 
from Tkinter import *
from random import randrange
 
# intervalle de randomisation
mini, maxi = 0, 10 # les nombres aléatoire seront tirés dans l'intervalle [0,10]
maxi += 1 # inclure la borne supérieure pour la randomisation
 
class Application(Tk):
    def __init__(self):
        Tk.__init__(self)
	self.question = Label(self)
	self.question.pack()
	self.saisie = Entry(self)
	self.saisie.pack()
	self.message = Label(self)
	self.message.pack()
        self.saisie.bind('<Return>', self.monevent) # La touche Entrer lance la procédure monevent
        # http://www.pythonware.com/library/tkinter/introduction/events-and-bindings.htm
        # Premiere initialisation de self.question
        self.initvariable()
 
    def initvariable(self): # L'utilisation de self permet d'utiliser initvariable en tant que procédure et non 
        # initialisation des variables
        a = randrange(mini, maxi)
        b = randrange(mini, maxi)
        self.questionText = str('{0} + {1} = '.format (str(a),str(b)))
        self.resultat = str(a + b)
        # reponse = None Inutile
        self.question.config(text = self.questionText) # Affiche la question
        self.saisie.delete(0, END) # Vide saisie
        self.saisie.focus_set() # donne le focus a saisie
 
    def monevent(self, event=None): # event ) None car bind retourne un event et nous n'en avons pas besoin ici.
        # while True: Pas besoin avec le bind
        # reponse = None Inutile
        # affichage de l'opération à effectuer au niveau du Label 'question'
        self.question.config(text = self.questionText)
        # self.question.update() Inutile
 
        # saisie de la réponse
        # print(repr(reponse))
        reponse = self.saisie.get() # Un Entry retourne toujours un str (Exception, l'utilisation d'un IntVar()/textvariable par exemple)
        # http://python.developpez.com/faq/?page=Entry#EntryGet
        # test de la réponse et affichage d'un message adapté au niveau du Label 'message'
        if reponse == self.resultat :
            # self pas app
            self.message.config(text= "bien joué ! on essaye encore") # afficher un message de félicitation
            self.initvariable()
        elif reponse == 'stop':
	    self.message.config(text= "D'accord, à bientot") # afficher un message d'adieu
	    self.quit()
            # break Pas besion puisque self.quit()
        else:
	    self.message.config(text= "NON !!! la bonne réponse était {0}".format(self.resultat)) # afficher un message d'erreur avec le resultat
            self.initvariable()
 
app = Application()
app.mainloop()
# Tout code aprés le mainloop est executer aprés la destruction de la fenètre

@+

[spirzouf]

merci beaucoup pour ce corrigé qui fonctionne comme je l'attendais

Étudier ce code m'a permis de comprendre pas mal de choses.
En particulier, j'ai compris comment utiliser le bind pour l'exécution de l'évènement dans le mainloop, en remplacement de ma tentative inefficace en boucle while.


Sinon, 2 petites questions :
- dans la procedure monevent, le 'event = None' est il indispensable et si oui pourquoi ?
- en commentaire de initvariable, ta phrase est tronquée et je n'ai pas compris ce que tu avais voulu dire au sujet du 'self'

Merci encore

Spirzouf

[PauseKawa]

Bonjour,

bind retourne un event et nous n'en avons pas besoin ici.
Si tu retire event=None Python vas te dire que monevent reçois deux informations (le self et l'event).

Oups le mauvais copier/coller...
L'utilisation de self permet d'utiliser initvariable en tant que procédure et non tant que fonction.
Une fonction retourne quelque chose

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def mafonction():
    blabla = 'que du vent'
    return blabla

Une procédure fais une action mais ne retourne rien

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def maprocedure():
    blabla = 'et encore du vent'

Donc si tu utilise self :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def maprocedure(self):
    self.blabla = 'et encore du vent'

print self.blabla donne et encore du vent

@+

[spirzouf]

donc si je comprend bien, en utilisant le self, cela permet de formaliser le fait qu'il s'agit d'une procédure, ce qui permet d'ajouter d'ajouter des objets qui appartiendront à la classe parente de ladite procédure, plutôt que de renvoyer une ou des valeurs lors de l'utilisation en tant que fonction avec return. C'est ça ?

SI c'est bien ça, on pourrait d'ailleurs faire effectivement une fonction, et dans le __init__ de la classe, on pourrait créer les objets en récupérant les valeurs du return de la fonction et ainsi obtenir la même chose mais de façon moins élégante et plus lourde ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class machin():
    def __init__(self):
        self.a = uneFonction('blabla','blibli')
    def uneFonction(chaine1,chaine2):
        a = chaine1 + chaine2 # a est une variable locale de uneFontion qui n'a rien à voir avec self.a
        return a

est équivalent a ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class machin():
    def __init__(self):
        uneProcedure('blabla','blibli')
    def uneProcedure(self,chaine1,chaine2):
        self.a = chaine1 + chaine2

[PauseKawa]

Pour rester dans le contexte la version avec une fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
#!/usr/bin/ python
# -*- coding: utf-8 -*-
 
from Tkinter import *
from random import randrange
 
mini, maxi = 0, 10
maxi += 1
 
class Application(Tk):
    def __init__(self):
        Tk.__init__(self)
	self.question = Label(self)
	self.question.pack()
	self.saisie = Entry(self)
	self.saisie.pack()
	self.message = Label(self)
	self.message.pack()
        self.saisie.bind('<Return>', self.monevent)
        # Premiere initialisation
        self.questionText, self.resultat = self.initvariable()
        self.question.config(text = self.questionText)
 
    def initvariable(self):
        a = randrange(mini, maxi)
        b = randrange(mini, maxi)
        questionText = str('{0} + {1} = '.format (str(a),str(b)))
        resultat = str(a + b)
        return questionText, resultat
 
    def monevent(self, event=None):
        self.question.config(text = self.questionText)
        reponse = self.saisie.get()
        if reponse == self.resultat :
            self.message.config(text= "bien joué ! on essaye encore")
        elif reponse == 'stop':
	    self.message.config(text= "D'accord, à bientot") # Inutile puisque self.quit() juste aprés
	    self.quit()
        else:
	    self.message.config(text= "NON !!! la bonne réponse était {0}".format(self.resultat))
        self.questionText, self.resultat = self.initvariable()
        self.question.config(text = self.questionText)
        self.saisie.delete(0, END)
        self.saisie.focus_set()
 
app = Application()
app.mainloop()