Discussion :

[nivlem]

Bonjour,
désolé de vous déranger. j'essaye de faire un uno sur python mais je rencontre quelques problèmes. J'ai créé une class joueur et une class table. dans cette class table je crée une liste avec mes joueurs le problème c'est que cette liste est vide après alors qu'elle était pas vide avant.

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
class Joueur():
     def __init__(self,player_id,type_j):
        """ Notre méthode constructeur """
        self.player_id = player_id
        self.type_j = type_j
        self.main=[]
        self.score = 0
        self.manche_g=0
 
 
 
 
 
 
     def get_type (self):
        return self.type_j
 
     def get_type (self):
        return self.score
     def get_type (self):
        return self.main
 
     def afficher_nom(cls) :
        print(cls.player_id)
 
class table():
 
 
     def __init__(self, nb_joueur=2): # Notre méthode constructeur
        self.nb_joueur=nb_joueur
        self.tour=[]
##        self.joueur.append(self.creation_joueur())
##        J=Joueur()
 
        self.pioche = ['0b','1b','1b','2b','2b','3b','3b','4b','4b','5b','5b','6b','6b','7b','7b','8b','8b','9b','9b','0r','1r','1r','2r','2r','3r','3r','4r','4r','5r','5r','6r','6r','7r','7r','8r','8r','9r','9r','0v','1v','1v','2v','2v','3v','3v','4v','4v','5v','5v','6v','6v','7v','7v','8v','8v','9v','9v','0j','1j','1j','2j','2j','3j','3j','4j','4j','5j','5j','6j','6j','7j','7j','8j','8j','9j','9j']
 
        self.talus=[]
        self.affiche()
 
     def affiche(self):
        None
 
     def creation_joueur(self) :
 
    #on renseigfne la classe jouruer du joueur humain
        J1=Joueur('J1','humain')
    #on creer une liste de participant appeler tour
        self.tour =[J1]
##        nb_joueur = int(input("Combien de joueurs?"))
        z=1
        n_IA=self.nb_joueur-1 #nb de joueur - l'humain
    #boucle pour renseigner la liste tour et créer les objet de la classe joueur
        while (z<=n_IA) :
            nom_IA='IA'+str(z)
            tour_int=[]
            tour_int.append(nom_IA)
            tour_int=tour_int[0].replace("'","")
            self.tour.append(tour_int[0])
            self.tour[z]=Joueur(nom_IA,"IA")
            z=z+1
 
     def fonction_tour (self):
 
        print (self.tour)
        if (self.tour[0].type_J=='humain'):
            fonction_joueur ()
 
        else :
            fonction_IA ()

Pouvez vous m'aider s'il vous plait?
Merci d'avance

[wiztricks]

Salut,

Pouvez vous m'aider s'il vous plait?

Si vous voulez de l'aide, il faudrait aussi fournir le code qui permet de le reproduire et expliquer plus précisément en quoi le résultat n'est pas celui que vous attendiez.
note: si on instancie table et qu'on appelle la méthode .creation_joueur, la variable .tour ne sera pas vide...

- W

[nivlem]

Rebonjour,
voici le code entier avec des print :

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
class Joueur():
     def __init__(self,player_id,type_j):
        """ Notre méthode constructeur """
        self.player_id = player_id
        self.type_j = type_j
        self.main=[]
        self.score = 0
        self.manche_g=0
 
 
 
 
 
 
     def get_type (self):
        return self.type_j
 
     def get_type (self):
        return self.score
     def get_type (self):
        return self.main
 
     def afficher_nom(cls) :
        print(cls.player_id)
 
class table():
 
 
     def __init__(self, nb_joueur=2): # Notre méthode constructeur
        self.nb_joueur=nb_joueur
        self.tour=[]
 
 
        self.pioche = ['0b','1b','1b','2b','2b','3b','3b','4b','4b','5b','5b','6b','6b','7b','7b','8b','8b','9b','9b','0r','1r','1r','2r','2r','3r','3r','4r','4r','5r','5r','6r','6r','7r','7r','8r','8r','9r','9r','0v','1v','1v','2v','2v','3v','3v','4v','4v','5v','5v','6v','6v','7v','7v','8v','8v','9v','9v','0j','1j','1j','2j','2j','3j','3j','4j','4j','5j','5j','6j','6j','7j','7j','8j','8j','9j','9j']
 
        self.talus=[]
        self.affiche()
 
     def affiche(self):
        None
 
     def creation_joueur(self) :
 
    #on renseigfne la classe jouruer du joueur humain
        J1=Joueur('J1','humain')
    #on creer une liste de participant appeler tour
        self.tour =[J1]
##        nb_joueur = int(input("Combien de joueurs?"))
        z=1
        n_IA=self.nb_joueur-1 #nb de joueur - l'humain
    #boucle pour renseigner la liste tour et créer les objet de la classe joueur
        while (z<=n_IA) :
            nom_IA='IA'+str(z)
            tour_int=[]
            tour_int.append(nom_IA)
            tour_int=tour_int[0].replace("'","")
            self.tour.append(tour_int[0])
            self.tour[z]=Joueur(nom_IA,"IA")
            z=z+1
        print (self.tour)
     def fonction_tour (self):
 
        print (self.tour)
        if (self.tour[0].type_J=='humain'):
            fonction_joueur ()
 
        else :
            fonction_IA ()
a=table()
a.creation_joueur()

le print(self.tour) de la méthode creation_joueur indique quelque chose mais le print (self.tour) est une liste vide alors que c'est la même variable qui n'est en aucun cas modifié. Pourquoi devient-elle une liste vide ? Et comment parer ce problème ?
avez-vous besoin d'autres informations?

[lg_53]

Il y a plein de problème dans votre code.

Ici :

Code :

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

1
2
3
4
5
6
7
8
 
     def get_type (self):
        return self.type_j
 
     def get_type (self):
        return self.score
     def get_type (self):
        return self.main

La fonction get_type, vous voulez quel fasse quoi ? Vous ne pouvez pas avoir 3 fois le même nom de fonction. Elles n'existeront pas toutes les 3, seule 1 seule existera !



Ensuite (cf commentaire dans le code) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
        J1=Joueur('J1','humain')
        self.tour =[J1]
        z=1
        n_IA=self.nb_joueur-1 #nb de joueur - l'humain
        while (z<=n_IA) :
            nom_IA='IA'+str(z)
            tour_int=[]
            tour_int.append(nom_IA)                ### donc  tour_int = [nom_IA]
            tour_int=tour_int[0].replace("'","")  
            self.tour.append(tour_int[0])           ### à la premiere iteration, self.tour vaut donc [J1,nom_IA]
            self.tour[z]=Joueur(nom_IA,"IA")     ### et là vous écrasez tous le boulot que vous avez fait pour nom_IA ...
            z=z+1

Donc cette fonction elle n'est pas claire du tout !

Enfin la fonction creation_joueur, vous l'appelez à quel endroit ? Il faut l'appeler si vous voulez que le bloc de code qu'elle contient s'éxécute, sinon ce sont des lignes de code mortes !

[wiztricks]

le print(self.tour) de la méthode creation_joueur indique quelque chose mais le print (self.tour) est une liste vide alors que c'est la même variable qui n'est en aucun cas modifié. Pourquoi devient-elle une liste vide ?

.creation_joueur n'étant pas appelé lors de la création de la classe, self.tour sera vide et l'appel à a.fonction_tour() plantera à l'instruction

Code :

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

 if (self.tour[0].type_J=='humain')

avec in IndexError.

Et comment parer ce problème ?
avez-vous besoin d'autres informations?

Si vous écrivez du code, vous devez essayer d'en comprendre la logique par vous même. Ici, la liste est initialisée à vide et si vous ne la remplissez pas en appelant la méthode ad hoc, elle restera vide.
Normalement, cette logique là c'est quelque chose que vous devez avoir acquis bien avant de vous lancer dans les classes. La seule solution que vous avez est de prendre le temps d'apprendre les bases en travaillant avec un tuto.

- W

[bistouille]

Au passage, une petite démonstration de comment générer ta liste avec un générateur.

Code :

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

1
2
3
4
5
6
lettres = ('b', 'r', 'v', 'j')
pioche = [
    str(i)+l for l in lettres 
    for i in range(0, 10)
    for _ in range(1 if i == 0 else 2)
]

Cela nécessite du temps de réfkexion, mais une fois qu'on a compris comment ça marche, ça ouvre de nombreuses possibilités, python arrive parfois à me donner la larme à l'oeil quand je fais ce genre de choses, je dois être trop émotif

[nivlem]

bonsoir à tous,
merci de votre aide. Je me suis trompé pour la fin en réécrivant le code : à la place de :

Code :

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

a.fonction_tour()

c'est :

Code :

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

a.creation_joueur()

Je l'ai changé dans le message précédant. Avec cela je l'appelle et la liste tour est remplie puis devient vierge comment est possible?
bonne soirée et bonne continuation

[wiztricks]

Salut,

Avec cela je l'appelle et la liste tour est remplie puis devient vierge comment est possible?

J'ai testé et la liste n'est pas vide (même si çà plante après le "print" pour d'autres soucis).
Donc pour l'instant, vous avez sans doute un problème mais vous n'avez toujours pas posté le code qui permet de le reproduire (et vous donner des explications).

- W

[nivlem]

Bonjour, désolé pour cette réponse tardive et encore merci pour vos réponses précédentes. Je tiens à vous dire que je vous est donné tout mon code la dessus car le reste du code ne peux pas fonctionner sans cet liste. Je vous remet le code qui code complet avec les modification de la dernière fois pour le faire fonctionner :

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
class Joueur():
     def __init__(self,player_id,type_j):
        """ Notre méthode constructeur """
        self.player_id = player_id
        self.type_j = type_j
        self.main=[]
        self.score = 0
        self.manche_g=0
 
 
 
 
 
 
     def get_type (self):
        return self.type_j
 
     def get_type (self):
        return self.score
     def get_type (self):
        return self.main
 
     def afficher_nom(cls) :
        print(cls.player_id)
 
class table():
 
 
     def __init__(self, nb_joueur=2): # Notre méthode constructeur
        self.nb_joueur=nb_joueur
        self.tour=[]
 
 
        self.pioche = ['0b','1b','1b','2b','2b','3b','3b','4b','4b','5b','5b','6b','6b','7b','7b','8b','8b','9b','9b','0r','1r','1r','2r','2r','3r','3r','4r','4r','5r','5r','6r','6r','7r','7r','8r','8r','9r','9r','0v','1v','1v','2v','2v','3v','3v','4v','4v','5v','5v','6v','6v','7v','7v','8v','8v','9v','9v','0j','1j','1j','2j','2j','3j','3j','4j','4j','5j','5j','6j','6j','7j','7j','8j','8j','9j','9j']
 
        self.talus=[]
        self.affiche()
 
     def affiche(self):
        None
 
     def creation_joueur(self) :
 
    #on renseigfne la classe jouruer du joueur humain
        J1=Joueur('J1','humain')
    #on creer une liste de participant appeler tour
        self.tour =[J1]
##        nb_joueur = int(input("Combien de joueurs?"))
        z=1
        n_IA=self.nb_joueur-1 #nb de joueur - l'humain
    #boucle pour renseigner la liste tour et créer les objet de la classe joueur
        while (z<=n_IA) :
            nom_IA='IA'+str(z)
            tour_int=[]
            tour_int.append(nom_IA)
            tour_int=tour_int[0].replace("'","")
            self.tour.append(tour_int[0])
            self.tour[z]=Joueur(nom_IA,"IA")
            z=z+1
        print (self.tour)
     def fonction_tour (self):
 
        print (self.tour)
        ##if (self.tour[0].type_J=='humain'):
            ##fonction_joueur ()
 
        ##else :
            ##fonction_IA ()
a=table()
a.creation_joueur()
a.fonction_tour()

La fonction joueur et la fonction IA a besoin de cette liste qui quand j'appelle la fonction_tour est vide. vous en avez donc pas besoin car mon problème est juste cette liste self.tour
Bonne continuation à tous

[wiztricks]

La fonction joueur et la fonction IA a besoin de cette liste qui quand j'appelle la fonction_tour est vide. vous en avez donc pas besoin car mon problème est juste cette liste self.tour

Si on fait tourner votre code, on voit bien que les "print" affichent la liste self.tour avec 2 éléments dedans.
Donc elle n'est pas vide... Et si c'est le problème, je ne le reproduis toujours pas.

- W

[nivlem]

bonjour,
le programme je vous est envoyé fonctionne et je ne comprends pas comment j'ai fait pour le résoudre. Sinon j'ai une autre question à quoi sert les "def get_"?
encore merci pour votre aide qui ma permis de résoudre mon problème

[Sve@r]

Bonjour

le programme je vous est envoyé fonctionne et je ne comprends pas comment j'ai fait pour le résoudre.

Ben... ça fait peur.
Comme disait Edgar Grospiron, ce sont les jambes qui font tourner les skis et non pas les skis qui font tourner les jambes. Ici c'est pareil. C'est le codeur qui écrit un code correspondant à ce qu'il veut faire et non le code qui indique au codeur ce qu'il va faire.

Code python :

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

1
2
3
4
5
6
7
nom_IA='IA'+str(z)
tour_int=[]
tour_int.append(nom_IA)
tour_int=tour_int[0].replace("'","")
self.tour.append(tour_int[0])
self.tour[z]=Joueur(nom_IA,"IA")
z=z+1

Punaise, je n'arrive même pas à comprendre ta logique. Tu définis un tableau vide, que tu remplis avec une chaine, puis finalement le tableau ne sert plus donc tu le remplaces par la chaine précédemment insérée un peu modifiée, puis tu ajoutes le premier caractère de cette chaine à un autre tableau, et enfin tu remplaces l'élément "z" (qui, soit dit en passant, a commencé à 1 et non 0) de ce tableau par une instance de "Joueur"
Bref comme je l'ai dit, ça fait vraiment peur !!!

Sinon j'ai une autre question à quoi sert les "def get_"?

"def": définir une fonction.
"get_xxx": nom de la fonction définie
Pareil. C'est toi qui a écrit ce code donc quand tu as écrit def get_type tu devais avoir une petite idée en tête de ce que ça fait et ce que tu voulais faire avec non ?

[nivlem]

bonjour,
merci pour votre message pour la parti du code que vous venez de mettre dans votre message sert a créer les joueurs du moins les IA car le uno sera qu'avec un joueur réel :

je crée le nom de l'IA or celui ci a des cotes je veux les enlevé donc je crée un liste vide juste pour les supprimer puis je crée mes joueurs avec ma fonction joueur.
Pour le Get c'est une personne dans mon entourage qui a essayé de m'aider mais cette personne bloque un peu sur les class comme moi. donc je sais pas si c'est utile ou non

[Sve@r]

pour la parti du code que vous venez de mettre dans votre message sert a créer les joueurs du moins les IA car le uno sera qu'avec un joueur réel

Non, je ne te demande pas ce que fait le code, je te demande comment tu l'as pensé. Tu ne peux pas écrire var=trucA puis juste en dessous var=trucB sans te dire "mince, le yahourt que j'ai dans la tête semble périmé !!!". De même si tu écris var=truc puis juste en dessous var=travail(var) ben ça devrait te sembler évident que tu peux résumer le tout en écrivant var=travail(truc).

je crée le nom de l'IA or celui ci a des cotes je veux les enlevé donc je crée un liste vide juste pour les supprimer puis je crée mes joueurs avec ma fonction joueur.

Mouais, super. Et ça ne te dérange pas le moins du monde d'utiliser une "liste" pour traiter "une" information. Remarque oui, pourquoi pas. Après-tout, ce qui compte c'est le résultat.
PS: ce n'est pas parce que tu as utilisé des quotes pour remplir une variable que les quotes sont dans la variable. Les quotes sont une symbologie signifiant "chaine". La symbologie étant traitée par Python, les quotes ne vont pas dans la variable.

Pour le Get c'est une personne dans mon entourage qui a essayé de m'aider mais cette personne bloque un peu sur les class comme moi. donc je sais pas si c'est utile ou non

http://dicocitations.lemonde.fr/cita...ion-135351.php

[nivlem]

rebonjour,
je vous l'accorde, il peux y avoir mieux pour faire la même chose or j'essaye de le faire avec les connaissances que j'ai or elles sont assez restreintes. C'est vrai si un aveugle suit un autre aveugle alors ils risquent de tomber tous les deux dans un trou et c'est pour cela que je demande.

[fred1599]

Ce que je ne comprend pas c'est qu'on s'évertue à utiliser des syntaxes pour niveau avancé alors qu'on a pas les bases.
C'est quasiment impossible de s'en sortir dans une situation pareille.

Faire un Uno sans classe, avec juste des fonctions... non ?

[Sve@r]

rebonjour,

Pas la peine. Une fois suffit dans une discussion.

je vous l'accorde, il peux y avoir mieux pour faire la même chose or j'essaye de le faire avec les connaissances que j'ai or elles sont assez restreintes.

Alors il y a les connaissances, et là wiztricks l'a bien dit... On commence par les acquérir avec un tuto.
Ensuite il y a la logique de la choses. Comment manipuler "une" chaine ? Ben on range la chaine dans "une" variable et on traite "la" variable. Et ça, ce n'est pas une question de connaissances.

et c'est pour cela que je demande.

Ben oui mais c'est ça que les gens ne semblent pas comprendre: on ne peut ni t'implanter les connaissances que tu n'as pas, ni les apprendre à ta place. Va faire un tour dans les autres discussions, ceux qui "demandent" on déjà un bagage suffisant pour comprendre la réponse et ce qu'elle engendre en interne Python. On ne s'attaque pas aux classes quand on ne sait pas ce que c'est, ce qu'est une méthode, etc...


fred1599 n'a pas tort. Tu peux très bien faire ton jeu sans classes. Un tableau des joueurs, puis une boucle de "jeu" qui traite chaque joueur. Chaque joueur fera appel à une fonction destinée à évaluer son jeu et choisir la meilleure carte à jouer etc...

Tiens, un début de code qui crée "n" joueurs

Code python :

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

1
2
3
4
5
6
7
8
9
10
tabJoueurs=[]
for i in xrange(1, n+1):
	tabJoueur.append(
		{
			"nom" : "joueur: %d" % i,
			"cartes" : [],
			"human" : False,
		}
	)
# for

Voilà. Je suis parti de l'idée qu'un joueur ce serait un dictionnaire qui contiendrait un nom, des cartes ("des" donc là ici une liste) et un flag humain/pas humain. Ensuite, une fonction "distribuer()" qui remplira chaque tabJoueur[i]["cartes"] puis on démarre le truc quoi. Avec quelques print() pour vérifier que tout se fait correctement et roule...

[nivlem]

Bonjour,
Merci pour votre et c'est gentil de me proposer des alternatives pour contourner mon problème.
Voici ce que j'ai fait et j'en suis plutôt content car le jeu fonctionne mais s'il manque des choses. Mon programme est le suivant :

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
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
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
from random import*
class Joueur():
     def __init__(self,player_id,type_j):
        """ Notre méthode constructeur """
        self.player_id = player_id
        self.type_j = type_j
        self.main=[]
        self.score = 0
        self.manche_g=0
        self.tour = []
        self.nb_tentative = 0
 
 
 
 
     def afficher_nom(cls) :
        print(cls.player_id)
 
class table():
 
     def __init__(self, nb_joueur=2): # Notre méthode constructeur
        self.nb_joueur=nb_joueur
        self.tour=[]
##        self.joueur.append(self.creation_joueur())
 
 
        self.pioche = ['0b','1b','1b','2b','2b','3b','3b','4b','4b','5b','5b','6b','6b','7b','7b','8b','8b','9b','9b','0r']
        self.talus=[]
        self.affiche()
 
     def affiche(self):
        None
 
     def creation_joueur(self) :
 
    #on renseigfne la classe jouruer du joueur humain
        J1=Joueur('J1','humain')
    #on creer une liste de participant appeler tour
        self.tour =[J1]
##        nb_joueur = int(input("Combien de joueurs?"))
        z=1
        n_IA=self.nb_joueur-1 #nb de joueur - l'humain
    #boucle pour renseigner la liste tour et créer les objet de la classe joueur
        while (z<=n_IA) :
            nom_IA='IA'+str(z)
            tour_int=[]
            tour_int.append(nom_IA)
            tour_int=tour_int[0].replace("'","")
            self.tour.append(tour_int[0])
            self.tour[z]=Joueur(nom_IA,"IA")
            z=z+1
 
 
     def fonction_distribution (self) :
 
        # melange le jeu
 
        shuffle(self.pioche)
 
        #distribue 7 cartes par joueurs
 
        #initialise les mains des joueurs et le talus
 
 
        #fait une boucle
        n=0
        while (n<7) :
            v=0
 
            while(v<self.nb_joueur):
               self.tour[0].main.append(self.pioche[0])# donne la premiere carte de la pioche
               del(self.pioche[0]) #supprime la premiere carte de la pioche
               a.fonction_ordre()
               v=v+1
 
 
            n=n+1
        # met la premiere carte au talus
        self.talus.append (self.pioche[0]) # donne la premiere carte de la pioche
        del(self.pioche[0]) #supprime la premiere carte de la pioche
 
 
     def fonction_ordre(self) :
 
        self.tour.append(self.tour[0])
        del(self.tour[0])
 
 
 
 
 
 
     def fonction_joueur (self) :
 
#regarde le nombre de fois que le joueur a tenté de poser une mauvaise carte. Si ça fait 2 fois passe à l'IA
        if(self.tour[0].nb_tentative<2) :
#on recupere la carte du talus
            self.tour[0].main
            print (self.talus[-1])
            print(self.tour[0].main)
            carte_talus = self.talus[-1]
            T_chiffre = carte_talus[0]
            T_couleur = carte_talus[-1]
            pioche_q = str(input('voulez vous piocher (n ou o)?'))
 
            #on regarde si le joueur veut poser ou non
            if (pioche_q== "n") :
              #recupere la carte choisie
                carte_select = [] #chercher carte dans la liste par rapport au n° choisit
                n=(int(input('veuillez selectioner une carte :')))
                carte_select=self.tour[0].main[n]
 
                carte_select_chiffre = carte_select[0]
                carte_select_couleur = carte_select[-1]
 
                if (carte_select_chiffre == T_chiffre) or (carte_select_couleur == T_couleur) :
 
                    #pose la carte
                    self.talus.append(self.tour[0].main[n])
                    del(self.tour[0].main[n])
 
                else:
                    #la carte ne peut être posée
                    print ('cette carte ne peut pas être posée !)')
 
                    self.tour[0].nb_tentative=self.tour[0].nb_tentative+1
                    a.fonction_joueur()
            else :
                a.fonction_pioche()
        else :
            print("Vous avez essayé 2 fois, votre tour se termine et vous piochez !")
            print(tour[0].player_id)
            a.fonction_pioche()
            self.nb_tentative=0
 
     def fonction_IA(self) :
    #on recupere la carte du talus
        carte_talus = self.talus[-1]
        T_chiffre = carte_talus[0]
        T_couleur = carte_talus[-1]
 
        #on verifie si l'IA peut poser
        c=0
 
        #creation d'une liste des cartes que l'IA peut jouer
        carte_jouable = []
        carte_jouable_couleur =[]
        carte_jouable_chiffre =[]
        while (c<len(self.tour[0].main)):
          #On va regarder carte par carte et créer des listes de cartes jouables
            IA_choisi = self.tour[0].main
            carte_IA= IA_choisi[c]
            IA_chiffre = carte_IA[0]
            IA_couleur = carte_IA[-1]
 
            if (T_chiffre==IA_chiffre) and (T_couleur != IA_couleur) : # prend les cartes avec le même chiffre mais pas la même couleur afin de ne pas rehitere le comptage de la carte de meme chiffre et de meme couleur que celle du talus
                #ajouter les cartes a differentes listes
                carte_jouable.append(carte_IA)
                carte_jouable_chiffre.append(carte_IA)
 
            elif (T_couleur ==IA_couleur) : #prendre les cartes de la meme couleur que le talus
                #ajouter les cartes a differentes listes
                carte_jouable.append(carte_IA)
                carte_jouable_couleur.append(carte_IA)
 
            c=c+1
    #la regle de pose pour l'Ia est : poser là ou il y a le plus de cartes par couleur, si il y a une égalité prendre en priorité la couleur du talus
        #on verifie si il y a des cartes dans la liste
        if(len(carte_jouable)>0) :
            nb_bleu =0
            nb_jaune =0
            nb_rouge =0
            nb_vert =0
            #on va compter le nombre de carte par couleur depuis la liste carte_jouable_couleur
 
            if (len(carte_jouable_couleur)>0) :
                couleur=carte_jouable_couleur[0]
 
                #recherche la couleur des cartes jouables*********** par couleur*************** afin de les compter
                if (couleur[-1] == 'b') : #compte le nb de cartes jouable  de couleur bleu
                    nb_bleu = len(carte_jouable_couleur)
 
                elif (couleur[-1] == 'v') : #compte le nb de cartes jouable de couleur vert
                    nb_vert = len(carte_jouable_couleur)
 
                elif (couleur[-1] == 'r') : #compte le nb de cartes jouable de couleur rouge
                    nb_rouge = len(carte_jouable_couleur)
 
                elif (couleur[-1] == 'j') : #compte le nb de cartes jouable de couleur jaune
                    nb_jaune = len(carte_jouable_couleur)
 
            #on va faire une boucle des cartes jouables ********par chiffre ************pour compter le nombre par couleur
 
            if (len(carte_jouable_chiffre)>0) :
                x=0
                while (x<len(carte_jouable_chiffre)) :
                    #on prend la couleur des cartes une a une
                    couleur_chiffre = carte_jouable_chiffre[x]
 
                    #recherche la couleur des cartes jouables afin de les compter
 
                    if (couleur_chiffre[-1] == 'b') :
                        y=0
                        while (y<len(IA_choisi)) :
                            couleur_carte_IA =  IA_choisi[y]
                            if (couleur_carte_IA [-1] == couleur_chiffre[-1]) :
                                nb_bleu =nb_bleu +1
                            y=y+1
                    elif (couleur_chiffre[-1] == 'v') :
                         y=0
                         while (y<len(IA_choisi)) :
                            couleur_carte_IA =  IA_choisi[y]
                            if (couleur_carte_IA [-1] == couleur_chiffre[-1]) :
                                nb_vert =nb_vert +1
                            y=y+1
 
                    elif (couleur_chiffre[-1] == 'r') :
 
                        y=0
                        while (y<len(IA_choisi)) :
                            couleur_carte_IA =  IA_choisi[y]
 
                            if (couleur_carte_IA [-1] == couleur_chiffre[-1]) :
                                nb_rouge =nb_rouge +1
                            y=y+1
 
                    elif (couleur_chiffre[-1] == 'j') :
                        y=0
                        while (y<len(IA_choisi)) :
                            couleur_carte_IA =  IA_choisi[y]
                            if (couleur_carte_IA [-1] == couleur_chiffre[-1]) :
                                nb_jaune =nb_jaune +1
                            y=y+1
                    x=x+1
 
            z=0 #z sert de variable afin de connaitre la plus grande valeur des couleurs
            #cherche la valeur la plus élevée
            if (nb_bleu>z):
                z=nb_bleu
 
            if (nb_jaune>z):
                z=nb_jaune
 
            if (nb_vert>z):
                z=nb_vert
 
            if (nb_rouge>z):
                z=nb_rouge
 
            #on regarde si c'est dans la couleur du talus
            if (z==len(carte_jouable_couleur)) :
                #prend la carte la plus grande
                carte_a_jouer= max(carte_jouable_couleur)
 
                #on recherche la carte dans la liste du joueur
                rang=IA_choisi.index(carte_a_jouer)
                self.talus.append(IA_choisi[rang])
                del(IA_choisi[rang])
 
 
            elif (z==nb_bleu) :
                carte_talus = self.talus[-1]
                chiffre_talus =carte_talus[0]
                carte_a_jouer = str(chiffre_talus)+'b'
                #on recherche la carte dans la liste du joueur
                rang=IA_choisi.index(carte_a_jouer)
                self.talus.append(IA_choisi[rang])
                del(IA_choisi[rang])
 
 
            elif (z==nb_jaune) :
                carte_talus = self.talus[-1]
                chiffre_talus =carte_talus[0]
                carte_a_jouer = str(chiffre_talus)+'j'
                #on recherche la carte dans la liste du joueur
                rang=IA_choisi.index(carte_a_jouer)
                self.talus.append(IA_choisi[rang])
                del(IA_choisi[rang])
 
 
            elif (z==nb_vert) :
                carte_talus = self.talus[-1]
                chiffre_talus =carte_talus[0]
                carte_a_jouer = str(chiffre_talus)+'v'
                #on recherche la carte dans la liste du joueur
                rang=IA_choisi.index(carte_a_jouer)
                self.talus.append(IA_choisi[rang])
                del(IA_choisi[rang])
 
 
            elif (z==nb_rouge) :
                carte_talus = self.talus[-1]
                chiffre_talus =carte_talus[0]
                carte_a_jouer = str(chiffre_talus)+'r'
                #on recherche la carte dans la liste du joueur
                rang=IA_choisi.index(carte_a_jouer)
                self.talus.append(IA_choisi[rang])
                del(IA_choisi[rang])
 
        else :
 
           a.fonction_pioche()
 
 
     def fonction_tour (self):
 
        if (self.tour[0].type_j=='humain'):
            a.fonction_joueur ()
 
        else :
            a.fonction_IA ()
 
     def fonction_pioche(self) :
 
        if (len(self.pioche)<2):
            print("test")
       #ajoute les cartes du talus sauf la derniere
            talus_inter = self.talus[-1] #sauvegarde la carte visible du talus
            del(self.talus[-1]) #supprime du talus cette meme carte
            self.pioche.extend(self.talus) #met du talus dans la pioche
            print(self.pioche)
            self.talus =[] #supprime les cartes du talus
            self.talus.append(talus_inter[0]) #recupere la carte prealablement sauvegardée
            talus_inter=[]#supprime la sauvegarde
 
#prend la premiere carte de la pioche et la met dans la liste du joueur qui est entrain de jouer
 
        self.tour[0].main.append(self.pioche[0])
        del(self.pioche[0])
 
     def fonction_jeu (self) :
        k=1
        while(k>0):
 
 
            a.fonction_tour()
            if(len(self.tour[0].main)==0):
                print(self.tour[0].player_id , "a gagné")
                break
            a.fonction_ordre()
            k=k+1
 
 
 
a=table()
a.creation_joueur()
a.fonction_distribution()
a.fonction_jeu()

Dites moi ce que vous en pensez s'il vous plait.
Ps: il manque des commentaire et c'est ce que je sui en train de faire actuellement sur mon programme.

Pour le faire en fonction je l'ai deja fait puis retranscrit en class car le uno est mon projet d'ISN et mon prof ma conseiller les class même en connaissant mon niveau actuel (j'ai fait un cours sur les class en cours d'ISN).

[Sve@r]

Voici ce que j'ai fait et j'en suis plutôt content car le jeu fonctionne
Dites moi ce que vous en pensez s'il vous plait.

Oui, il fonctionne. Mais effectivement il peut être amélioré. Principalement cette question "voulez-vous piocher o/n" perpétuelle et bien chiante ; alors qu'elle pourrait être déduite de la réponse à la question suivante "veuillez sélectionner une carte".
Sinon me semble que le jeu "Uno" contient des chiffres mais aussi des couleurs. Mais bon, peut-être que ce n'est pas le même...

Pour le faire en fonction je l'ai deja fait puis retranscrit en class car le uno est mon projet d'ISN et mon prof ma conseiller les class même en connaissant mon niveau actuel (j'ai fait un cours sur les class en cours d'ISN).

Oui pas de souci. Effectivement le travail par l'objet simplifie les traitements mieux que le travail par fonctions...

PS: ces deux instructions

Code python :

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

1
2
self.tour[0].main.append(self.pioche[0])# donne la premiere carte de la pioche
del(self.pioche[0]) #supprime la premiere carte de la pioche

peuvent se simplifier en self.tour[0].main.append(self.pioche.pop(0)).

[bistouille]

Dites moi ce que vous en pensez s'il vous plait.

Bonsoir,

Je ne connais pas ce jeu, donc je ne peut juger le fonctionnement, en revanche je peux tout de même faire quelques commentaires divers sur le code, et la logique.

- On n'utilise pas le * sur les imports de modules, on garde l'espace du nom du module (ou un autre espace de nom), et si on a besoin que d'une ou 2 fonctions on les importe directement, par pitié respecte cette régle, tu iras ainsi au-devant de futurs problèmes.

class Joueur :
- On évite le frangliche tant que c'est possible.
- afficher_nom n'a pas de sens, player_id est un attribut d'instance, et non une variable de classe, tant qu'à faire, et tant que possible, on utilise les properties python, ou alors des assesseurs avec des noms génériques.

class table
- Problème de conception : La table ne doit pas créer les joueurs, mais les accueillir, ce n'est pas à elle de créer des joueurs, c'est comme en réalité, par exemple une table de poker, etc, ce sont les joueurs qui s'assoient à la table.
Idem pour la distribution, cela ne devrait pas être fait dans cette classe, inspire toi encore d'une table de poker, celui qui distribue, c'est le croupier, ce n'est pas la table qui fait la distribution de cartes, la table doit recevoir les joueurs en paramètres, le croupier, et appeler les méthodes de tous ces objets, en gros elle s'occupe uniquement de gérer le tour à tour de tout ce beau petit monde.

Tes joueurs que ce soit des joueurs virtuels ou réels devraient tous avoir un même schéma (classe abstraite), c'est-à-dire que la table devrait pouvoir appeler les méthodes spécifiques communes à tous ces objets qu'ils doivent obligatoirement implémenter.
1 - Le jeu crée les joueurs, le distributeur de cartes (croupier)
2 - Le jeu crée la table en lui passant en paramètres, les joueurs et le croupier.
3 - La table gère tout ça, tours, appels des méthodes des joueurs, du croupier.

Dit comme ça, c'est sûr que ça a l'air simple, évidemment niveau code, c'est bien plus difficile et encore plus lorsqu'on débute.

Je pense également que tes fonctions joueur et ia peuvent sûrement être simplifiées, et surtout, je le répète, ne devraient pas être dans ta class table.

Voilà quelques commentaires en vrac