IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

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


Sujet :

Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Nouveau candidat au Club
    Homme Profil pro
    Lycéen
    Inscrit en
    Mai 2019
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Dordogne (Aquitaine)

    Informations professionnelles :
    Activité : Lycéen

    Informations forums :
    Inscription : Mai 2019
    Messages : 2
    Par défaut Recommencer mon programme sans sauvegarder les données précédentes
    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

    ElCuntoEsBueno.py
    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
    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)

  2. #2
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 840
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 840
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par Guillaume2418 Voir le message
    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
    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 python : 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
    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 python : Sélectionner tout - Visualiser dans une fenêtre à part
    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).
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  3. #3
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 762
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 762
    Par défaut
    Salut,

    Citation Envoyé par Guillaume2418 Voir le message
    je ne trouve pas comment m' y prendre; pourriez vous m aider s il vous plait
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  4. #4
    Nouveau candidat au Club
    Homme Profil pro
    Lycéen
    Inscrit en
    Mai 2019
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Dordogne (Aquitaine)

    Informations professionnelles :
    Activité : Lycéen

    Informations forums :
    Inscription : Mai 2019
    Messages : 2
    Par défaut 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

Discussions similaires

  1. Sauvegarder les données d'un programme
    Par dalfred dans le forum Pascal
    Réponses: 11
    Dernier message: 24/11/2012, 16h38
  2. Sauvegarder les données d'un FormPage
    Par couetbis dans le forum SWT/JFace
    Réponses: 3
    Dernier message: 05/06/2006, 13h30
  3. Réponses: 6
    Dernier message: 30/05/2006, 22h41
  4. Sauvegarder les données dans un fichier CSV
    Par beb30 dans le forum MFC
    Réponses: 5
    Dernier message: 08/03/2006, 13h06

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo