probleme pour recuperer des valeurs avec des classes

**lg_53** · 15/02/2018, 09h14

On te l'a déjà dit il me semble, mais il faut vraiment que tu examines de plus près ce que tu fais dans cette 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
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

Fait le ne serait ce qu'à la main. Au départ z=1, et self.tour=[J1]. On rentre dans la boucle, nom_IA = 'IA1'. Dans tour_int on va avoir ['IA1']. Ensuite tu cherches à remplacer une virgule ? Qui plus est tu écrases la liste par la transformation de l'élément 0. Ensuite dans self.tour tu ajoutes le premier élément de tour_int. Pourquoi avoir fait de tour_int une liste si tu n'as besoin que d'un élément ? A ce ce stade là on a donc self.tour=[J1,'IA1']. Là ensuite tu réaffecte la 2eme valeur (z étant 1), et donc finalement self.tour=[J1, Joueur(nom_IA,"IA")].

Ok mais là t'as pas l'impression de faire tout plein de truc inutile pour arriver à cela ?

Code :

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

1
2
3
4
5
6
7
8
9
def creation_joueur(self) :
        self.tour =[Joueur('J1','humain')]
        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)
            self.tour.append(Joueur(nom_IA,"IA"))
            z=z+1

Que l'on préfère même écrire avec un for lorsque l'on connait le nombre d'itération à faire:

Code :

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

1
2
3
4
5
6
def creation_joueur(self) :
        self.tour =[Joueur('J1','humain')]
        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
        for z in range(1,n_IA+1):
            self.tour.append(Joueur('IA'+str(z),"IA"))

On pourrait encore compacter, mais déjà il faut absolument que tu comprennes comment on en arrive là, et qu'est ce qui t'as conduit à écrire de telles absurdités pour ne plus jamais en réécrire de pareilles.

**nivlem** · 17/02/2018, 22h10

Bonsoir,
Ceci est bien le jeu de uno avec les couleurs qui sont r,b,v,j. Pour simplifier le programme je ne vois pas trop comment faire car je n'ai pas la logique concernant le fonctionnement de python. Et pour le code que vous m'avez donné pour simplifier la pioche je le regarderai pour le comprendre.
Bonne continuation
Nivlem

**Sve@r** · 18/02/2018, 14h36

Envoyé par nivlem

Ceci est bien le jeu de uno avec les couleurs qui sont r,b,v,j. Pour simplifier le programme je ne vois pas trop comment faire

Commencer par créer le talon (et le mélanger)

Code python :

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

1
2
talon=list({"couleur" : c, "valeur" : v} for c in "rbvj" for v in "123456789")
random.shuffle(talon)

Ca génère un talon composé de 36 cartes. Chaque carte est un dictionnaire contenant une couleur et une valeur. Ensuite bon ben c'est pas fini (faut encore trouver un algorithme pour qu'un joueur robot puisse analyser son propre jeu en fonction de la carte posée, etc) mais bon, c'est déjà un début quoi...

**nivlem** · 18/02/2018, 19h42

Bonjour,

Je vous remercie encore pour l'aide apportée.

Bistouille et Lg53 merci pour les remarques et les explications.
Sve@r merci pour la méthode "pop" (j'ai modifié mon code) et pour la création du talons (je l'examine en détail pour le comprendre et l'insérer dans mon code ) et je vais regarder plus en détail les dictionnaires.

Avec tout ce que vous m'avez donné, je vais essayer de refaire un code plus propre et je le mettrai sur le forum afin d'avoir vos remarques.

Bon week end

Nivlem

**nivlem** · 23/02/2018, 11h54

Bonjour,

J'ai modifié mon code afin de me servir des dictionnaires dans les listes comme proposé par Sve@r.
C'est déjà plus simple pour vérifier si on peut poser une carte

Par contre je souhaiterai compter le nombre de carte que j'ai dans une certaine couleur se trouvant dans une liste (main d'une IA).puis après connaître la plus élevée dans la couleur choisie.

ex :main de l'IA :[{'valeur': '7', 'couleur': 'b'}, {'valeur': '2', 'couleur': 'v'}, {'valeur': '4', 'couleur': 'v'}, {'valeur': '1', 'couleur': 'v'}, {'valeur': '6', 'couleur': 'v'}, {'valeur': '2', 'couleur': 'j'}, {'valeur': '3', 'couleur': 'v'}]
>> b :1
>> v:5
>> j:1

Je cherche mais j'ai du mal à mettre un critère (ici la couleur) dans mon comptage.

Merci encore pour l'aide apportée.

Bonne journée
Nivlem

**nivlem** · 23/02/2018, 15h35

J'ai trouvé en effectuant une boucle sur la liste.
Voici l'exemple pour compter le nombre de carte rouge et avoir la plus grande

Code :

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

1
2
3
4
5
6
7
8
9
10
11
n=0
r=0
maxi_r=0
for lettre in carte_jouable:
    if pioche[n].get("couleur") =="r" :
        r=r+1
        v= int(pioche[n].get("valeur"))
 
        if v > maxi_r :
            maxi_r = v
    n=n+1

Bonne journée
nivlem

**fred1599** · 23/02/2018, 21h20

la variable n peut-être supprimée sans doute avec

Code :

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

1
2
for n, lettre in enumerate(carte_jouable):
    # suite

Ligne 7, il y a sans doute moyen d'éviter le int en utilisant range dans ta construction de pioche.

Pour maxi_r, on peut sans doute utiliser la fonction max des fonctions built-in du langage.

On ne voit pas ce que représente carte_jouable,

On ne voit pas l'intérêt de la variable lettre,

etc...

Donc pourquoi ce code ? Si il n'y a pas de fil conducteur...

**nivlem** · 24/02/2018, 08h35

Bonjour,

Merci fred1599 pour ces renseignements.

On ne voit pas ce que représente carte_jouable,

Quand c'est à l'IA de jouer, je liste les cartes qu'elle peut poser dans la liste carte_jouable

On ne voit pas l'intérêt de la variable lettre

Novice, je ne cache pas que j'ai trouvé un code qui effectuait une boucle dans une liste et je l'ai prit et il y avait la variable lettre .

Quand l'IA joue, on doit regarder si elle peut poser et si oui elle doit poser en priorité là où il y a le plus de cartes dans une couleur et celle qui est la plus grande dans cette couleur.
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
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
#on recupere la carte du talus
        carte_talus = self.talus[-1]
 
 
        #on verifie si l'IA peut poser
        c=0
 
        #creation d'une liste des cartes que l'IA peut jouer
        carte_jouable = list({})
        carte_jouable_couleur =list({})
        carte_jouable_chiffre =list({})
        while (c<len(self.tour[0].main)):
          #On va regarder carte par carte et créer des listes de cartes jouables
 
            if (self.tour[0].main[c]["valeur"] == self.talus[-1]["valeur"] or self.tour[0].main[c]["couleur"] == self.talus[-1]["couleur"])  :
                 self.tour[0].main[c]
            IA_choisi = self.tour[0].main
            carte_IA= IA_choisi[c]
 
            if (self.tour[0].main[c]["valeur"] == self.talus[-1]["valeur"] and self.tour[0].main[c]["couleur"] != self.talus[-1]["couleur"]) :
 
                #ajouter les cartes a differentes listes
                carte_jouable.append(carte_IA)
                #carte_jouable_chiffre.append(carte_IA)
            elif self.tour[0].main[c]["couleur"] == self.talus[-1]["couleur"] :
 
                #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
        print (carte_jouable)
        if(len(carte_jouable)>0) :
            nb_bleu =0
            nb_jaune =0
            nb_rouge =0
            nb_vert =0
            max_bleu =0
            max_jaune =0
            max_vert =0
            max_rouge =0
            #on va compter le nombre de carte par couleur depuis la liste carte_jouable_couleur
 
 
            #fait un passage pour la couleur rouge
 
            for n, lettre in enumerate(carte_jouable):
 
 
                v=0
                pos_rouge=0
 
                if carte_jouable[n].get("couleur") =="r" :
                    nb_rouge=nb_rouge+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_rouge :
                        max_rouge = v
                        pos_rouge = n
 
 
        #fait un passage pour la couleur bleu
 
            for n, lettre in enumerate(carte_jouable):
 
 
                v=0
                pos_bleu=0
                if carte_jouable[n].get("couleur") =="b" :
                    nb_bleu=nb_bleu+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_bleu :
                        max_bleu = v
                        pos_bleu =n
            #fait un passage pour la couleur jaune
            for n, lettre in enumerate(carte_jouable):
 
                v=0
                pos_jaune=0
                if carte_jouable[n].get("couleur") =="j" :
                    nb_jaune=nb_jaune+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_jaune :
                        max_jaune = v
                        pos_jaune = n
            #fait un passage pour la couleur vert
            for n, lettre in enumerate(carte_jouable):
 
                v=0
                pos_vert=0
                if carte_jouable[n].get("couleur") =="v" :
                    nb_vert=nb_vert+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_vert :
                        max_vert = v
                        pos_vert =n
 
 
            z=0 #z sert de variable afin de connaitre la plus grande valeur des couleurs
            #cherche la valeur la plus élevée
            pos=0
            carte_talus = self.talus[-1]
            if (nb_bleu>z):
                z=nb_bleu
                pos=pos_bleu
 
            if (nb_jaune>z):
                z=nb_jaune
                pos=pos_jaune
            elif (nb_jaune == z) and carte_jouable[pos_jaune].get("couleur") == carte_talus.get("couleur"):
                 z=nb_jaune
                 pos=pos_jaune
            elif (nb_jaune == z) and carte_jouable[pos_jaune].get("couleur") > carte_jouable[pos].get("couleur"):
                 z=nb_jaune
                 pos=pos_jaune
            if (nb_vert>z):
                z=nb_vert
                pos=pos_vert
            elif (nb_vert ==z) and carte_jouable[pos_vert].get("couleur") == carte_talus.get("couleur"):
                z=nb_vert
                pos=pos_vert
            elif (nb_vert ==z) and carte_jouable[pos_vert].get("couleur") > carte_jouable[pos].get("couleur"):
                z=nb_vert
                pos=pos_vert
            if (nb_rouge>z):
                z=nb_rouge
                pos=pos_rouge
            elif (nb_rouge ==z) and carte_jouable[pos_rouge].get("couleur") == carte_talus.get("couleur"):
                z=nb_vert
                pos=pos_vert
            elif (nb_rouge ==z) and carte_jouable[pos_rouge].get("couleur") > carte_jouable[pos].get("couleur"):
                z=nb_vert
                pos=pos_vert
 
 
            carte_a_jouer= carte_jouable[pos]
#on recherche la carte dans la liste du joueur
            rang=IA_choisi.index(carte_a_jouer)
 
            self.talus.append(IA_choisi.pop(rang))
 
        else :
 
           a.fonction_pioche()
 
 
     def fonction_tour (self):
 
        if (self.tour[0].type_j=='humain'):
            a.fonction_joueur ()
 
        else :
            a.fonction_IA ()

Je sais que mon code est vraiment pas propre mais grâce à vos conseils je l'améliore (et moi au passage

)

Bon weekend

nivlem

**fred1599** · 24/02/2018, 09h06

Si il y a du self, c'est qu'il y a une classe, et ... je ne là vois pas !

Je ne sais donc pas par exemple en 1ère ligne ce qu'est la variable self.talus et comment elle a été construite, je perds le fil...

Mettre des blocs de code à l'arrache ne va pas nous aider pour qu'on comprenne les problèmes liés à ton code.

Prends une petite partie de code représentant ton problème et que tu peux tester.

**nivlem** · 24/02/2018, 10h06

Voila tout le code que j'utilise :

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
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 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.talus=list({})
 
#créer la pioche et la mélange
 
        self.pioche=list({"valeur" : v, "couleur" : c} for v in "0123456789" for c in "rbvj" )
        shuffle(self.pioche)
 
        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]
 
        z=1
        n_IA=self.nb_joueur-1 #nb de joueur - l'humain
        print (n_IA)
    #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 get_pioche (self):
        return self.pioche
 
     def get_talus (self):
        return self.talus
 
     def get_tour (self):
        return self.tour
 
 
     def fonction_distribution (self) :
 
        #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.pop(0))
 
                a.fonction_ordre()
                v=v+1
 
 
            n=n+1
        # met la premiere carte au talus
        self.talus.append (self.pioche.pop(0))
        print (self.talus[-1])
 
     def fonction_ordre(self) :
        self.tour.append(self.tour.pop(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]
            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
 
                n=(int(input('veuillez selectioner une carte :')))
                print(self.tour[0].main[n]["valeur"])
                print(self.talus[-1])
 
 
                if (self.tour[0].main[n]["valeur"] == self.talus[-1]["valeur"] or self.tour[0].main[n]["couleur"] == self.talus[-1]["couleur"])  :
 
                    #pose la carte
                    self.talus.append(self.tour[0].main.pop(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) :
        print("IA")
        print (self.tour[0].main)
        print ("talus ia",self.talus[-1])
    #on recupere la carte du talus
        carte_talus = self.talus[-1]
 
 
        #on verifie si l'IA peut poser
        c=0
 
        #creation d'une liste des cartes que l'IA peut jouer
        carte_jouable = list({})
        carte_jouable_couleur =list({})
        carte_jouable_chiffre =list({})
        while (c<len(self.tour[0].main)):
          #On va regarder carte par carte et créer des listes de cartes jouables
 
            if (self.tour[0].main[c]["valeur"] == self.talus[-1]["valeur"] or self.tour[0].main[c]["couleur"] == self.talus[-1]["couleur"])  :
                 self.tour[0].main[c]
            IA_choisi = self.tour[0].main
            carte_IA= IA_choisi[c]
 
            if (self.tour[0].main[c]["valeur"] == self.talus[-1]["valeur"] and self.tour[0].main[c]["couleur"] != self.talus[-1]["couleur"]) :
 
                #ajouter les cartes a differentes listes
                carte_jouable.append(carte_IA)
                #carte_jouable_chiffre.append(carte_IA)
            elif self.tour[0].main[c]["couleur"] == self.talus[-1]["couleur"] :
 
                #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
            max_bleu =0
            max_jaune =0
            max_vert =0
            max_rouge =0
            #on va compter le nombre de carte par couleur depuis la liste carte_jouable_couleur
 
 
            #fait un passage pour la couleur rouge
 
            for n, lettre in enumerate(carte_jouable):
 
 
                v=0
                pos_rouge=0
 
                if carte_jouable[n].get("couleur") =="r" :
                    nb_rouge=nb_rouge+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_rouge :
                        max_rouge = v
                        pos_rouge = n
 
 
        #fait un passage pour la couleur bleu
 
            for n, lettre in enumerate(carte_jouable):
 
 
                v=0
                pos_bleu=0
                if carte_jouable[n].get("couleur") =="b" :
                    nb_bleu=nb_bleu+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_bleu :
                        max_bleu = v
                        pos_bleu =n
            #fait un passage pour la couleur jaune
            for n, lettre in enumerate(carte_jouable):
 
                v=0
                pos_jaune=0
                if carte_jouable[n].get("couleur") =="j" :
                    nb_jaune=nb_jaune+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_jaune :
                        max_jaune = v
                        pos_jaune = n
            #fait un passage pour la couleur vert
            for n, lettre in enumerate(carte_jouable):
 
                v=0
                pos_vert=0
                if carte_jouable[n].get("couleur") =="v" :
                    nb_vert=nb_vert+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_vert :
                        max_vert = v
                        pos_vert =n
 
 
            z=0 #z sert de variable afin de connaitre la plus grande valeur des couleurs
            #cherche la valeur la plus élevée
            pos=0
            carte_talus = self.talus[-1]
            if (nb_bleu>z):
                z=nb_bleu
                pos=pos_bleu
 
            if (nb_jaune>z):
                z=nb_jaune
                pos=pos_jaune
            elif (nb_jaune == z) and carte_jouable[pos_jaune].get("couleur") == carte_talus.get("couleur"):
                 z=nb_jaune
                 pos=pos_jaune
            elif (nb_jaune == z) and carte_jouable[pos_jaune].get("couleur") > carte_jouable[pos].get("couleur"):
                 z=nb_jaune
                 pos=pos_jaune
            if (nb_vert>z):
                z=nb_vert
                pos=pos_vert
            elif (nb_vert ==z) and carte_jouable[pos_vert].get("couleur") == carte_talus.get("couleur"):
                z=nb_vert
                pos=pos_vert
            elif (nb_vert ==z) and carte_jouable[pos_vert].get("couleur") > carte_jouable[pos].get("couleur"):
                z=nb_vert
                pos=pos_vert
            if (nb_rouge>z):
                z=nb_rouge
                pos=pos_rouge
            elif (nb_rouge ==z) and carte_jouable[pos_rouge].get("couleur") == carte_talus.get("couleur"):
                z=nb_vert
                pos=pos_vert
            elif (nb_rouge ==z) and carte_jouable[pos_rouge].get("couleur") > carte_jouable[pos].get("couleur"):
                z=nb_vert
                pos=pos_vert
 
 
            carte_a_jouer= carte_jouable[pos]
#on recherche la carte dans la liste du joueur
            rang=IA_choisi.index(carte_a_jouer)
 
            self.talus.append(IA_choisi.pop(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):
 
       #ajoute les cartes du talus sauf la derniere
            talus_inter=list({})
            print("talus_pioche_vide",self.talus)
            #talus_inter = self.talus[-1] #sauvegarde la carte visible du talus
            talus_inter.append (self.talus.pop(-1))
            self.pioche.extend(self.talus) #met du talus dans la pioche
            del(self.talus[:])
            self.talus = talus_inter #recupere la carte prealablement sauvegardée
            talus_inter=list({})#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.pop(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()

Je dois encore l'améliorer en prenant en compte les remarques données (classe...)

**wiztricks** · 24/02/2018, 10h21

Salut,

Quand je lis:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
for n, lettre in enumerate(carte_jouable):
 
                v=0
                pos_rouge=0
 
                if carte_jouable[n].get("couleur") =="r" :
                    nb_rouge=nb_rouge+1
                    v= int(carte_jouable[n].get("valeur"))
 
                    if v > max_rouge :
                        max_rouge = v
                        pos_rouge = n

3 trucs me font bondir juste sur l'instruction v= int(carte_jouable[n].get("valeur"))

pourquoi ne pas stocker des entiers plutôt que de convertir un str à chaque fois?
pourquoi ne pas créer une classe Carte et écrire: v= carte_jouable[n].valeur ?
pourquoi ne pas ranger les différentes cartes dans des listes adhoc de l'objet Joueur et sortir le max via Joueur.get_max(ROUGE) ?

L'idée étant de faire en sorte que vos données soient un peu plus "alignées" avec les traitements que vous allez faire i.e. trouver un équilibre entre un tas de boue où il va falloir souker pour trier convertir et une structure plus adaptée.

- W

**fred1599** · 24/02/2018, 10h29

Donc ça confirme ce que je disais avant, mieux vaut

Code :

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

self.pioche = [{"valeur": v, "couleur": c} for v in range(10) for c in "rbvj"]

Tu travailles déjà avec des entiers comme valeurs et non des chaînes, pas besoin de conversion à coup de int.

P.S : Je pense que le code devrait ne pas êtres des parties de code recopiées par ci par là, mais un code venant de toi et bien pensé (exprimant ta pensée et non celles de plusieurs).

**nivlem** · 24/02/2018, 11h21

Merci Fred1599.
Les valeurs ne seront pas toujours que des entiers, en effet plus tard il faudra que je rajoute les cartes d'actions +2, inversion, passer, joker, super joker.
J'ai déjà pensé au code pour créer cette pioche mais avant je préfère arriver à faire tourner le jeu sans puis après ajouter ces cartes.

Le fait de mon faible niveau fait que je cherche des solutions pour faire telle ou telle chose et donc je cherche et lorsque je trouve un code qui convient je le prend et essai de l'adapter pour mon code.

L'inconvénient c'est que nous devons présenter un projet en fin d'année mais c'est dur avec le peu de cours qu'on nous a dispensés (et pas qu'en python)

donc malheureusement je n'ai pas "le temps" de reprendre les bases.

Merci wiztricks je vais prendre en compte les remarques afin d'améliorer le code
Pour les entiers, comme dis à Fred1599, ce ne sera pas toujours des entiers.
Pour la classe, je vais voir comment le faire.
Je vais chercher ce qu'est des listes adhoc car je ne connais pas

Je vois vraiment mes lacunes et grâce à vos aides, je progresse de jour en jour.
Désolé de vous piquer les yeux avec mon code.

Nivlem

**fred1599** · 24/02/2018, 11h29

Voilà une architecture sur laquelle t'appuyer,

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
from random import shuffle
 
class Joueur:
    def __init__(self, pseudo):
        self.infos = ''
        self.pseudo = pseudo
        self.points = 0
        self.cartes = []
 
    def piocher(self, pioche):
        pass
 
    def melanger(self, jeu):
        shuffle(jeu.cartes)
 
class Jeu:
    def __init__(self):
        self.nb_cartes = 108
        self.cartes = self.creer()
        shuffle(self.cartes)
        self.sens = '+' # sens du jeu (sens des aiguilles d'une montre)
 
    def distribuer(self, joueur):
        pass
 
    def creer(self):
        pass
 
    def __str__(self):
        infos_cartes = ''
        for carte in self.cartes:
            infos_cartes += '{}: {}\n'.format(carte.valeur, carte.couleur)
        return infos_cartes
 
class Carte:
    def __init__(self, couleur, valeur):
        self.couleur = couleur
        self.valeur = valeur
 
jeu = Jeu()
print(jeu)

Pour le reste on peut t'aider, mais la manière de penser doit venir de toi... comme tu vois ci-dessus c'est moins brouillon, je connais pas trop le Uno, j'ai juste lu sa règle pour comprendre.

**wiztricks** · 24/02/2018, 13h46

Envoyé par nivlem

Merci wiztricks je vais prendre en compte les remarques afin d'améliorer le code
Pour les entiers, comme dis à Fred1599, ce ne sera pas toujours des entiers.

Raison de plus pour ne pas appliquer int à ce qui pourrait être autre chose!

Envoyé par nivlem

Pour la classe, je vais voir comment le faire.
Je vais chercher ce qu'est des listes adhoc car je ne connais pas

ad hoc est une locution latine.

- W

**nivlem** · 24/02/2018, 14h14

Envoyé par wiztricks

Raison de plus pour ne pas appliquer int à ce qui pourrait être autre chose!

ad hoc est une locution latine.

- W

Merci wiztricks pour ces explications.

Merci fred1599 pour l'architecture.
J'ai essayé de la comprendre. Donc elle est composée des classes joueur, carte et jeu.
Dans la classe joueur on initie les informations du joueurs (point, son jeu...), puis elle contient la fonction pioche (qui faut créer) et il y a aussi la fonction mélanger. Pourquoi la fonction mélanger n'est pas mise dans la classe jeu puisque les cartes ne sont mélangées qu'après leur création et avant de les distribuer?
Puis la classe jeu qui comprend les informations des cartes (nb et la liste des cartes créées) et aussi les informations sur le sens du jeu. Elle comprend les fonctions distribution et créer qui reste à renseigner et aussi une fonction __str__ qui je pense sert à avoir le bon format pour les cartes.
Il y a aussi la classe carte contenant un constructeur de classe pour les cartes.

Je pense que dans la classe joueur je peux ajouter la fonction jeu pour l'IA et la fonction vérification pour contrôler la carte jouée par l'humain.

J'ai voulu mettre la fonction créer mais j'ai une erreur avec la fonction __str__ . Voici les deux fonctions avec la fonction créer renseignée :

Code :

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

1
2
3
4
5
6
7
8
9
  def creer(self):
        #pass
        self.creer=list({"valeur" : v, "couleur" : c} for n in range(0,2) for v in "0123456789" for c in "rbvj" )
        return self.creer
    def __str__(self):
        infos_cartes = ''
        for carte in self.cartes:
            infos_cartes += '{}: {}\n'.format(carte.valeur, carte.couleur)
        return infos_cartes

Et voici l'erreur :

Traceback (most recent call last):
File "<string>", line 420, in run_nodebug
File "C:\Users\nivlem\OneDrive\Documents\module2.py", line 43, in <module>
print(jeu)
File "C:\Users\melvi\OneDrive\Documents\module2.py", line 33, in __str__
infos_cartes += '{}: {}\n'.format(carte.valeur, carte.couleur)
AttributeError: 'dict' object has no attribute 'valeur'

Merci encore pour le temps consacrer à m'expliquer.

Bonne journée

Nivlem

**Sve@r** · 24/02/2018, 14h19

Envoyé par nivlem

Par contre je souhaiterai compter le nombre de carte que j'ai dans une certaine couleur se trouvant dans une liste (main d'une IA).puis après connaître la plus élevée dans la couleur choisie.
ex :main de l'IA :[{'valeur': '7', 'couleur': 'b'}, {'valeur': '2', 'couleur': 'v'}, {'valeur': '4', 'couleur': 'v'}, {'valeur': '1', 'couleur': 'v'}, {'valeur': '6', 'couleur': 'v'}, {'valeur': '2', 'couleur': 'j'}, {'valeur': '3', 'couleur': 'v'}]
>> b :1
>> v:5
>> j:1

J'ai pas trop vu si la réponse à cette question avait été donnée (vu la masse de code présentée dans les réponses).

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
# Extrait toutes les cartes d'une certaine couleur
extract_couleur=lambda main, couleur: tuple(x["valeur"] for x in main if x["couleur"] == couleur)
 
# Retourne les extrêmes (min/max) d'un tableau de valeurs
def extreme_valeur(valeur):
	# Pour personnaliser la comparaison de deux valeurs (sera utile quand on aura des valeurs comme "joker", etc)
	def comp(x, y):
		if int(x) < int(y): return -1
		if int(x) > int(y): return 1
		return 0
	# comp()
 
	# Tri du tableau des valeurs selon la fonction de comparaison
	res=sorted(valeur, comp)
 
	# Renvoie le min et le max
	return (res[0], res[-1])
# extreme_valeur()
 
main_ia=[{'valeur': '7', 'couleur': 'b'}, {'valeur': '2', 'couleur': 'v'}, {'valeur': '4', 'couleur': 'v'}, {'valeur': '1', 'couleur': 'v'}, {'valeur': '6', 'couleur': 'v'}, {'valeur': '2', 'couleur': 'j'}, {'valeur': '3', 'couleur': 'v'}]
 
# Test (nb de cartes d'une certaine valeur)
print len(extract_couleur(main_ia, "b"))
print len(extract_couleur(main_ia, "j"))
print len(extract_couleur(main_ia, "v"))
 
# Les extrèmes d'une couleur
print extreme_valeur(extract_couleur(main_ia, "v"))

**fred1599** · 24/02/2018, 15h28

Pourquoi la fonction mélanger n'est pas mise dans la classe jeu puisque les cartes ne sont mélangées qu'après leur création et avant de les distribuer?

Qui mélange ? le joueur ou le jeu ?

La fonction créer, permet de construire le jeu, ça pourrait être

Code :

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

1
2
3
4
5
6
7
def creer(self):
    res = []
    for c in 'rjbv':
        for v in range(10):
            for _ in range(2):
                res.append(Carte(c, str(v)))
    return res

**nivlem** · 25/02/2018, 10h35

Bonjour,

Merci Sve@r pour le code. J'ai réussi a comprendre et a faire fonctionner pour compter les cartes par couleur par contre je n'ai pas compris ni réussi a faire fonctionner l'extraction des extrêmes.

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
	# Retourne les extrêmes (min/max) d'un tableau de valeurs
def extreme_valeur(valeur):
	# Pour personnaliser la comparaison de deux valeurs (sera utile quand on aura des valeurs comme "joker", etc)
	def comp(x, y):
		if int(x) < int(y): return -1
		if int(x) > int(y): return 1
		return  0
    #comp()
 
	# Tri du tableau des valeurs selon la fonction de comparaison
	res=sorted(valeur, comp)
 
	# Renvoie le min et le max
	return (res[0], res[-1])
    #extreme_valeur()
 
main_ia=[{'valeur': '7', 'couleur': 'b'}, {'valeur': 'jocker', 'couleur': 'r'}, {'valeur': '4', 'couleur': 'v'}, {'valeur': '1', 'couleur': 'v'}, {'valeur': '6', 'couleur': 'v'}, {'valeur': '2', 'couleur': 'j'}, {'valeur': '3', 'couleur': 'v'}]
 
#extreme_valeur()
# Les extrèmes d'une couleur
print (extreme_valeur(extract_couleur(main_ia, "b")))

A quoi correspondent les x et y, est-ce la couleur et la valeur?
Pourquoi on retourne 0?
Les comp() et extreme_valeur() en comentaire, c'est pour si j'ai besoin de les appeler d'une autre fonction (je les prendrai)?

Envoyé par fred1599

Qui mélange ? le joueur ou le jeu ?

Dans la vie, c'est le joueur mais pour le jeu, je pensai que ce serait lui qui mélangerait et distribuerait.
fred1599 dans l'architecture proposée, j'ai vu que pour les cartes, il n'y avait plus de dictionnaire et que c'était une fonction qui donnait l'information des cartes. Est-ce bien ça?
J'aime bien me servir du dictionnaire pour les cartes mais peut être que ça alourdi mon code.

Merci encore pour votre patience.

nivlem

**fred1599** · 25/02/2018, 11h21

fred1599 dans l'architecture proposée, j'ai vu que pour les cartes, il n'y avait plus de dictionnaire et que c'était une fonction qui donnait l'information des cartes. Est-ce bien ça?
J'aime bien me servir du dictionnaire pour les cartes mais peut être que ça alourdi mon code.

Ce n'est pas une fonction, mais une classe dont la construction de l'instance représente la carte créée avec ses attributs couleur et valeur.

On peut le faire avec le dictionnaire, pas de problème ! On peut aussi faire sans classe, etc. l'essentiel étant d'exprimer clairement à l'aide de ton code ce que tu souhaites faire pour résoudre ta problématique. Chacun ici à sa manière de penser comme tu as pu le voir, mais chacun est resté cohérent quand à résoudre le problème. Il suffit d'analyser tout ça à tête reposée.

Dans la vie, c'est le joueur

C'est le but du langage OO (orienté objet)... se rapprocher le plus possible de la réalité.