Recommencer mon programme sans sauvegarder les données précédentes

Version imprimable

1 pièce(s) jointe(s)

Bonsoir je suis en première et cette années j ai pris une option ISN à mon lycée seulement nous avons un mini projet a faire mais je l ai terminé, je me suis donc lancé de nouveaux objectifs dans ce petit programme. Une fois le programme terminé je me suis dis que ce serai cool que je puisse recommencer ce petit jeu qui est : " le compte est bon " sans prendre en compte la partie précédente ainsi je pourrai rejouer sans avoir à fermer et réouvrir le programme seulement je ne trouve pas comment m' y prendre; pourriez vous m aider s il vous plait :D ;)

Pièce jointe 477923

Code:

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
from tkinter import *
import random
from tkinter.messagebox import *
 
def BouTrait1():
    global çaum
    çaum=(çaum+(Bou1.cget("text")))
    Bou1.destroy()
    çaumVal.set("Somme actuelle : " +str(çaum))
    if çaum>total:
        showwarning('Résultat','Vous avez perdu, dommage...\nVeuillez recommencer !')
    if çaum==total:
        showinfo('Résultat','Bravo vous avez gagné!\nAu revoir !')
 
def BouTrait2():
    global çaum
    çaum=(çaum+(Bou2.cget("text")))
    Bou2.destroy()
    çaumVal.set("Somme actuelle : " +str(çaum))
    if çaum>total:
        showwarning('Résultat','Vous avez perdu, dommage...\nVeuillez recommencer !')
    if çaum==total:
        showinfo('Résultat','Bravo vous avez gagné!\nAu revoir !')
 
def BouTrait3():
    global çaum
    çaum=(çaum+(Bou3.cget("text")))
    Bou3.destroy()
    çaumVal.set("Somme actuelle : " +str(çaum))
    if çaum>total:
        showwarning('Résultat','Vous avez perdu, dommage...\nVeuillez recommencer !')
    if çaum==total:
        showinfo('Résultat','Bravo vous avez gagné!\nAu revoir !')
 
def BouTrait4():
    global çaum
    çaum=(çaum+(Bou4.cget("text")))
    Bou4.destroy()
    çaumVal.set("Somme actuelle : " +str(çaum))
    if çaum>total:
        showwarning('Résultat','Vous avez perdu, dommage...\nVeuillez recommencer !')
    if çaum==total:
        showinfo('Résultat','Bravo vous avez gagné!\nAu revoir !')
 
def BouTrait5():
    global çaum
    çaum=(çaum+(Bou5.cget("text")))
    Bou5.destroy()
    çaumVal.set("Somme actuelle : " +str(çaum))
    if çaum>total:
        showwarning('Résultat','Vous avez perdu, dommage...\nVeuillez recommencer !')
    if çaum==total:
        showinfo('Résultat','Bravo vous avez gagné!\nAu revoir !')
çaum=0
total=0
recommencer=1
 
Fen=Tk()
Fen.title('ElCuentoEsBueno')
Fen.geometry("265x154+400+400")
 
Bou1=Button(Fen, text=random.randint(1,9), command=BouTrait1)
Bou1.place(x=20,y=10)
 
Bou2=Button(Fen, text=random.randint(1,9), command=BouTrait2)
Bou2.place(x=70,y=10)
 
Bou3=Button(Fen, text=random.randint(1,9), command=BouTrait3)
Bou3.place(x=120,y=10)
 
Bou4=Button(Fen, text=random.randint(1,9), command=BouTrait4)
Bou4.place(x=170,y=10)
 
Bou5=Button(Fen, text=random.randint(1,9), command=BouTrait5)
Bou5.place(x=220,y=10)
 
while total==0:
    x1=random.randint(0,1)
    if x1==0:
        total=(total+(Bou1.cget("text")))
    x2=random.randint(0,1)
    if x2==0:
        total=(total+(Bou2.cget("text")))
    x3=random.randint(0,1)
    if x3==0:
        total=(total+(Bou3.cget("text")))
    x4=random.randint(0,1)
    if x4==0:
        total=(total+(Bou4.cget("text")))
    x5=random.randint(0,1)
    if x5==0:
        total=(total+(Bou5.cget("text")))
 
 
text=StringVar()
çaumVal=StringVar()
 
çaumVal.set("Somme actuelle : 0")
 
 
totalP=StringVar()
totalP.set("Valeur à atteindre : " +str(total))
 
LabelVal=Label(Fen, textvariable=totalP, fg="black")
LabelVal.pack(padx=10,pady=60, anchor="center")
 
Labelçaum=Label(Fen, textvariable=çaumVal, fg="black")
Labelçaum.place(x=78,y=85)
 
BouRecom=Button(Fen,text="Recommencer")
BouRecom.place(x=90,y=115)

Bonjour

Citation:

Envoyé par Guillaume2418

ainsi je pourrai rejouer sans avoir à fermer et réouvrir le programme seulement je ne trouve pas comment m' y prendre; pourriez vous m aider s il vous plait :D ;)

Encapsuler tout ton jeu dans un objet lequel aurait des méthodes permettant de le réinitialiser et qui resterait affiché à l'écran jusqu'à ce qu'on le quitte par un bouton spécialement dédié à cet effet.

Et si tu veux en plus que ton jeu te donne la solution, tu peux alors utiliser cet objet (un des premiers que j'ai créé quand j'apprenais Python)

Code:

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
# Chercher la solution de "le compte est bon"
 
# Objet pour gérer le résultat
class cRes(object):
	# Fonction de recherche (récursive)
        @staticmethod                                                   # Méthode statique
	def __cherche(but, liste, calc, sol, prof=0):
		# La fonction est par défaut sans solution
		trouve=False
 
		# Parcours de chaque couple de nombres
		for ((x, y), tabOp) in cRes._makeCalc(liste):
			# Parcours de chaque opération et son résultat associé
			for (op, res) in tabOp:
				# Ajout calcul à la liste des calculs précédents
				calc.append(cRes._cCalc(x, op, y, res))
				#print "%s%d %s: %d %s %d = %d" % ("\t" * prof, but, liste, x, op, y, res)
 
				# Si le résultat est trouvé et que tous les calculs sont utilisés
				if res == but and cRes._cSol._check(calc):
					# La fonction a réussi
					trouve=True
 
					# Les calculs sont ajoutés au tableau des solutions
					sol.append(cRes._cSol(calc))
				else:
					# S'il y a encore des nombres dans la liste
					if len(liste) > 2:
						# Création nouvelle liste sans les nombres testés
						tmp=tuple(k for k in (res, ) + liste if k not in (x, y))
 
						# Si l'appel récursif trouve
						if cRes.__cherche(but, tmp, calc, sol, prof + 1):
							# L'appel récursif a réussi
							trouve=True
						# if
					# if
				# if
 
				# Suppression dernier calcul inutile
				del(calc[-1])
			# for
		# for
 
		# Renvoi booléen
		return trouve
	# __cherche()
 
	# Création couples calculs
        @staticmethod                                                   # Méthode statique
	def _makeCalc(liste):
		# Initialisation tableaux
		tabTuple=list()
		tabOper=list()
 
		# Tri de la liste de nombres pour éviter les calculs en double
		liste=sorted(liste)
 
		# Parcours de chaque élément de la liste
		for i in range(len(liste)):
			# Parcours de chaque élément de la liste placés après i
			for j in range(i + 1, len(liste)):
				# Elimination doublons
				if (liste[i], liste[j]) in tabTuple: continue
 
				# Création liste opérations
				oper=list()
 
				# Addition - Rien à éviter (aucun nombre ne vaut 0)
				oper.append(('+', liste[i] + liste[j]))
 
				# Multiplication - Si aucun des nombres ne vaut 1
				if 1 not in (liste[i], liste[j]):
					oper.append(('*', liste[i] * liste[j]))
 
				# Soustraction - Si les nombres ne sont pas égaux
				if liste[i] != liste[j]:
					oper.append(('-', liste[j] - liste[i]))
 
				# Division - Si résultat entier et diviseur différent de 1
				x=divmod(liste[j], liste[i])
				if liste[i] != 1 and x[1] == 0:
					oper.append(('/', x[0]))
 
				# Ajout tableau opérations
				tabOper.append(oper)
 
				# Création tuple anti doublon
				tabTuple.append((liste[i], liste[j]))
			# for
		# for
 
		# Renvoi tableaux
		return zip(tabTuple, tabOper)
	# _makeCalc()
 
	# Constructeur
	def __init__(self, *args):
		self.__liste=tuple(x for x in args if x != 0)
		self.__tabSol=list()
	# __init__()
 
	def __call__(self):
		return self.__tabSol
 
	# Affichage
	def __str__(self):
		return (
			"liste: %s\nSolution\n%s" % (
				self.__liste,
				"".join("%s\n" % s for s in self.__tabSol),
			)
		)
	# __str__()
 
	# Longueur
	def __len__(self):
		return len(self.__tabSol)
	# __len__()
 
	# Nombre de doublons
	def getDoublon(self):
		return tuple(x for x in self.__tabSol if x.isDoublon())
	# getDoublon()
 
	# Recherche de la solution
	def crawler(self, but):
		# Recherche récursive
		if not cRes.__cherche(
			but,
			self.__liste,
			list(),
			self.__tabSol,
		): return False
 
		# Tri des solutions
		self.__tabSol.sort()
 
		# Positionnement des solutions en double
		for i in range(1, len(self.__tabSol)):
			if self.__tabSol[i] == self.__tabSol[i - 1] or self.__tabSol[i - 1] in self.__tabSol[i]:
				self.__tabSol[i].setDoublon()
		# for
		return True
	# crawler()
 
	# Objet pour gérer un calcul
	class _cCalc(object):
		# Constructeur
		def __init__(self, o1, op, o2, res):
			self._o1=o1
			self.__op=op
			self._o2=o2
			self._res=res
		# __init__()
 
		# Affichage
		def __str__(self):
			return "%d %s %d = %d" % (self._o2, self.__op, self._o1, self._res)
		# __str__()
 
		# Comparaison de 2 calculs
		def __cmp__(self, other):
			if self._res < other._res: return -1
			if self._res > other._res: return 1
			return 0
		# __cmp__()
	# _cCalc
 
	# Objet pour gérer une solution
	class _cSol(object):
		# Vérification solution: tout calcul doit être utilisé
                @staticmethod                                                   # Méthode statique
		def _check(tabCalc):
			tmp=[tabCalc[-1],]
 
			# Balayage du tableau des calculs en partant de la fin
			for i in range(len(tabCalc) - 2, -1, -1):
				# Balayage des calculs conservés
				for s in tmp:
					# Si le résultat de la solution courante est utilisé dans les suivantes
					if tabCalc[i]._res in (s._o1, s._o2): break
 
				# Si résultat pas utilisé, solution rejetée
				else:
					return False
				# for
 
				# Le résultat est mémorisé pour valider les autres calculs
				tmp.append(tabCalc[i])
			# for
 
			return True
		# _check()
 
		# Constructeur
		def __init__(self, calc):
			self._tabLig=tuple(calc)
			self.__fl_doublon=False
		# __init__()
 
		# Affichage
		def __str__(self):
			return "%s%s" % (
				"".join("%s\n" % x for x in self._tabLig),
				"(double)\n" if self.__fl_doublon else "",
			)
		# __str__()
 
		# Longueur
		def __len__(self):
			return len(self._tabLig)
		# __len__()
 
		# Comparaison de 2 solutions
		def __cmp__(self, other):
			if len(self) < len(other): return -1
			if len(self) > len(other): return 1
			for (x, y) in zip(
				sorted(x for x in self._tabLig),
				sorted(x for x in other._tabLig),
			):
				if x < y: return -1
				if x > y: return 1
			return 0
		# __cmp__()
 
		# Check si une solution est incluse dans une autre
		def __contains__(self, other):
			if len(other) < len(self): return False
 
			for calc in self._tabLig:
				if calc not in other._tabLig:
					return False
			return True
		# __contains__()
 
		# Vérification doublon
		def isDoublon(self):
			return self.__fl_doublon
		# isDoublon()
 
		# Mise à jour flag doublon
		def setDoublon(self, flag=True):
			self.__fl_doublon=flag
		# setDoublon()
	# _cSol
# cRes

On s'en sert de cette façon

Code:

1
2
3
res=cRes(1, 2, 3, ... (autant de chiffres que tu veux mais plus y en aura plus ce sera long))
res.crawler(nombre_a_trouver)
print(res)

Et si tu veux traiter chaque solution: for s in res(): traitement_de_ton_choix(s).

25/05/2019, 10h31
wiztricks
Salut,

Citation:

Envoyé par Guillaume2418

je ne trouve pas comment m' y prendre; pourriez vous m aider s il vous plait :D ;)

Pour pouvoir recommencer, il faut mettre le programme dans un "état initial" qui dépend de ce qui est utilisé.

Mais avant de vous lancer là dedans, il serait préférable de simplifier votre code:
un truc comme:
Code:

1 2 3 4 5 6 Bou1=Button(Fen, text=random.randint(1,9), command=BouTrait1) Bou1.place(x=20,y=10) Bou2=Button(Fen, text=random.randint(1,9), command=BouTrait2) Bou2.place(x=70,y=10) ...
c'est deux instructions qui se répètent...
Et "répéter" des instructions, c'est juste arriver à écrire une boucle.
Cela fait "redémarrer" sera sans doute moins difficile.

- W
25/05/2019, 16h26
Guillaume2418

Merci beaucoup pour vos réponses

Merci beaucoup je pense que grace à vos conseils je vais être débloqué je vais essayer de ce pas