Exercice les class (POO)

Version imprimable

Voir 40 message(s) de cette discussion en une page

11/12/2011, 20h26
wiztricks
moins de lignes, moins de bugs.
Code:

1 2 3 def battre(self): random.shuffle(self.cartes)
- W

Citation:

Envoyé par malabar93

Code:

1
2
3
4
5
6
7
8
9
10
11
12
class JeuDeCartes :
	# Constructeur
	def __init__(self):
		self.cartes = []
		for y in range(4):
			for x in range(2, 15):
				self.cartes.append( (x, y) )
 
	def nom_carte(self,x,y):
		number = ['Un','Deux','Trois','Quatre','Cinq','Six','Sept','Huit','Neuf','Dix','Valet','Dame','Roi']
		color = ['Coeur','Carreau','Trefle','¨Pique']
		print('{} de {}'.format(number[x],color[y]))

Je ne sais pas si tu as appris les variables statiques de classes... mais ce serait pas mal utile ici...

Code:

1
2
3
4
5
6
7
8
9
10
11
class JeuDeCartes :
	# Variables statiques
	__number=(
		"deux", "trois", "quatre", "cinq", "six", "sept",
		"huit", "neuf", "dix", "valet", "dame", "roi", "as",
	)
	__color=(
		"trèfle", "carreau", "coeur", "pique",
	)
	def nom_carte(self,x,y):
		print('{} de {}'.format(JeuDeCarte.__number[x],JeuDeCarte.__color[y]))

Ce qui te permet en plus de créer un constructeur plus souple (accessoirement je ne comprends pas pourquoi tu veux absolument faire commencer la plus petite valeur à 2...)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class JeuDeCartes :
	# Variables statiques
	__number=(
		"deux", "trois", "quatre", "cinq", "six", "sept",
		"huit", "neuf", "dix", "valet", "dame", "roi", "as",
	)
	__color=(
		"trèfle", "carreau", "coeur", "pique",
	)
 
	# Constructeur
	def __init__(self):
		self.cartes = []
		for y in range(len(JeuDeCarte.__color)):
			for x in range(len(JeuDeCarte.__number)):
				self.cartes.append( (x, y) )

Qu'on peut d'ailleurs écrire en plus simple

Code:

1
2
3
# Constructeur
def __init__(self):
	self.cartes=[(x, y) for x in range(len(JeuDeCarte.__number)) for y in range(len(JeuDeCarte.__color))]

Et enfin tu remarqueras que la méthode "nom_carte" n'appartient pas à une instance de joueur en particulier (self n'y est pas utilisé). Donc tu peux la transformer en méthode statique

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
class JeuDeCartes :
	# Variables statiques
	__number=(
		"deux", "trois", "quatre", "cinq", "six", "sept",
		"huit", "neuf", "dix", "valet", "dame", "roi", "as",
	)
	__color=(
		"trèfle", "carreau", "coeur", "pique",
	)
 
        @staticmethod
	def nom_carte(x,y):
		print('{} de {}'.format(JeuDeCarte.__number[x],JeuDeCarte.__color[y]))

Pour l'utiliser, te suffira de l'appeler de cette façon: JeuDeCarte.nom_carte(...). Attention toutefois, le sujet précise que la fonction qui affiche le nom de la carte doit recevoir une carte (un tuple) et non 2 valeurs séparées...

Bugs !

Salut, voici ton code modifié, avec quelques commentaires.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#on importe le module random
import random
 
class JeuDeCartes :
	# Constructeur
    def __init__(self):
        self.cartes = []
        for y in range(4):
            for x in range(2, 15):
                self.cartes.append( (x, y) )
 
    def nom_carte(self,x,y):
        number = ['Un','Deux','Trois','Quatre','Cinq','Six','Sept','Huit','Neuf','Dix','Valet','Dame','Roi']
        #il y avait un caractere bizarre devant Pique
        color = ['Coeur','Carreau','Trefle','Pique']
        print('{} de {}'.format(number[x],color[y]))
 
    def battre(self):
        used = []
        cartesmel = []
        #on cree une botte qui est une copie du jeu
        botte = self.cartes[:]
        #on tire les cartes tant qu'il en reste dans la botte en evitant de faire des tours pour rien
        while len(botte) > 0:
            #on fait un choix au hasard dans la nouvelle liste
            carte = random.choice(botte)
            botte.remove(carte) 
            #pourqoi deux listes identiques?
            cartesmel.append(carte)
            used.append(carte)
		#on retourne une liste  nouvellement initialisee
        return cartesmel
 
#Programme Principal
 
jdc1 = JeuDeCartes()
print jdc1.battre()

PS : entre le temps ou j'ai commencé a éditer le sujet et ou j'ai posté , j'ai vu un random.shuffle() que je ne connaissais pas. merci !

Citation:
Envoyé par utopman
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class JeuDeCartes : # Constructeur def __init__(self): self.cartes = [] for y in range(4): for x in range(2, 15): self.cartes.append( (x, y) ) def nom_carte(self,x,y): number = ['Un','Deux','Trois','Quatre','Cinq','Six','Sept','Huit','Neuf','Dix','Valet','Dame','Roi'] #il y avait un caractere bizarre devant Pique color = ['Coeur','Carreau','Trefle','Pique'] print('{} de {}'.format(number[x],color[y]))
Salut
As-tu remarqué qu'avec des valeurs de cartes qui vont de 2 à 14... et un tableau de noms dont les noms sont en position de 0 à 12 ça risque de ne pas coller ??? C'est quand-même pas pour rien que j'ai demandé 2 fois à malabar pourquoi il tenait absolument à faire commencer son tableau à 2 (accessoirement, au jeu de la bataille, l'as est la plus forte carte comme le montre l'exemple qui donne à l'as la valeur 14)
Citation:
Envoyé par utopman
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def battre(self): used = [] cartesmel = [] #on cree une botte qui est une copie du jeu botte = self.cartes[:] #on tire les cartes tant qu'il en reste dans la botte en evitant de faire des tours pour rien while len(botte) > 0: #on fait un choix au hasard dans la nouvelle liste carte = random.choice(botte) botte.remove(carte) #pourqoi deux listes identiques? cartesmel.append(carte) used.append(carte) #on retourne une liste nouvellement initialisee return cartesmel
Mmmoui. Mais ta méthode ne mélange pas le jeu initial. Elle ne fait que renvoyer un autre jeu...

Citation:

Envoyé par utopman

PS : entre le temps ou j'ai commencé a éditer le sujet et ou j'ai posté , j'ai vu un random.shuffle() que je ne connaissais pas. merci !

Et connais-tu copy.copy et copy.deepcopy ? Pratique pour créer des copies d'objets. Parce que ta méthode botte = self.cartes[:] ne fait qu'une copie superficielle. c.a.d. que si ton tableau contient des objets complexes, botte ne contiendra que l'adresse de ces objets. Donc toute modification dans carte se répercutera dans botte
Exemple
Code:

1 2 3 4 5 6 7 8 9 10 >>> class toto: pass >>> >>> a=[toto(), toto()] >>> b=a[:] >>> a [<__main__.toto instance at 0x01214F80>, <__main__.toto instance at 0x01214F58>] >>> b [<__main__.toto instance at 0x01214F80>, <__main__.toto instance at 0x01214F58>]

13/12/2011, 11h07
wiztricks
Citation:

Envoyé par Sve@r

As-tu remarqué qu'avec des valeurs de cartes qui vont de 2 à 14... et un tableau de noms dont les noms sont en position de 0 à 12 ça risque de ne pas coller ???

L'énoncé disant:

Citation:

Pour chacune d'elles, il faut
en effet mémoriser séparément un nombre entier indiquant la valeur
(2, 3, 4, ..., 11, 12, 13, 14, les 4 dernières valeurs étant celles des
valet, dame, roi et as), et un autre nombre entier pour indiquer la
couleur de la carte (c'est-à-dire 3, 2, 1, 0 pour Coeur, Carreau, Trèfle,
Pique).

Si on veut que:
Code:

1 2 3 @staticmethod def nom_carte(x,y): print('{} de {}'.format(JeuDeCarte.__number[x],JeuDeCarte.__color[y]))
fonctionne, il pourra suffire de définir __number comme:
Code:

1 2 3 4 __number=(None, None, "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "valet", "dame", "roi", "as", )
- W
13/12/2011, 11h20
wiztricks

Citation:

Envoyé par Sve@r

Et connais-tu copy.copy et copy.deepcopy ? Pratique pour créer des copies d'objets. Parce que ta méthode botte = self.cartes[:] ne fait qu'une copie superficielle. c.a.d. que si ton tableau contient des objets complexes, botte ne contiendra que l'adresse de ces objets. Donc toute modification dans carte se répercutera dans botte

Remarque intéressante mais le prof a pris la précaution de représenter les cartes sous forme de tuple. Sans doute pour parler de tout cela plus tard.
- W
13/12/2011, 18h22
Sve@r
Citation:

Envoyé par wiztricks

L'énoncé disant:

Citation:

Pour chacune d'elles, il faut
en effet mémoriser séparément un nombre entier indiquant la valeur
(2, 3, 4, ..., 11, 12, 13, 14, les 4 dernières valeurs étant celles des
valet, dame, roi et as), et un autre nombre entier pour indiquer la
couleur de la carte (c'est-à-dire 3, 2, 1, 0 pour Coeur, Carreau, Trèfle,
Pique).

J'avais noté. Mais j'ai considéré qu'il ne s'agissait que d'un modèle explicatif et non à suivre au pied de la lettre et opté pour la simplicité.
Citation:
Envoyé par wiztricks

Si on veut que:

Code:

1 2 3 @staticmethod def nom_carte(x,y): print('{} de {}'.format(JeuDeCarte.__number[x],JeuDeCarte.__color[y]))

fonctionne, il pourra suffire de définir __number comme:

Code:

1 2 3 4 __number=(None, None, "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "valet", "dame", "roi", "as", )
Mouais. Ca marche. Ou alors on peut demander number[x-2]. Mais ça me met quand-même mal à l'aise...

Citation:

Envoyé par wiztricks

Remarque intéressante mais le prof a pris la précaution de représenter les cartes sous forme de tuple. Sans doute pour parler de tout cela plus tard.
- W

C'est vrai que quand j'ai créé l'exemple, j'avais d'abord essayé avec des tuples ce qui ne démontrait rien et ai dû créer un objet pour avoir une démo visuelle.
Mais c'était surtout pour montrer à utopman qui peut-être ne connait pas cet outil pratique et non à malabar. De toute façon dans la solution de l'exercice, il n'est pas besoin de copier le tableau...
13/12/2011, 18h43
wiztricks

Citation:

Envoyé par Sve@r

J'avais noté. Mais j'ai considéré qu'il ne s'agissait que d'un modèle explicatif et non à suivre au pied de la lettre et opté pour la simplicité.

En fait, "l'enseignant" peut ici jouer un peu le rôle "d'architecte".
Les exercices peuvent être le support d'un cours et être aussi conçus pour réaliser un petit projet "par petits bouts". Les élèves ne sont peut être pas encore assez calés pour qu'on leur raconte cela mais ils seront peut être ravis de découvrir la construction au fil des cours.

Citation:

Mouais. Ca marche. Ou alors on peut demander number[x-2]. Mais ça me met quand-même mal à l'aise...

Une des raisons pour ranger ainsi est que çà pourrait simplifier la récupération du "poids" de chaque cartes dans un jeu de bataille contre l'ordi.

Mais je prête à "l'enseignant" des intentions qu'il n'a peut être pas.
- W

Voir 40 message(s) de cette discussion en une page