Exercice les class (POO)

Version imprimable

Salut ,

Je commence la POO , mais j'ai énormément de mal , du au manque un peu d'explication et d’expérience en POO .
Si vous avez des liens , tuto , ... sur cette pratique je suis preneur .
Voici un exercice que je dois faire pour mon prof , mais j'ai du mal a trouver mes erreurs :

Citation:

Définissez une classe Domino() qui permette d'instancier des objets simulant
les pièces d'un jeu de dominos. Le constructeur de cette classe initialisera les
valeurs des points présents sur les deux faces A et B du domino (valeurs par
défaut = 0).
Deux autres méthodes seront définies :
●
affiche_points() qui affiche les points présents sur les deux faces.
●
valeur() qui renvoie la somme des points présents sur les 2 faces.
Exemples d'utilisation de cette classe
>>> d1 = Domino(2,6)
>>> d2 = Domino(4,3)
>>> d1.affiche_points()
face A : 2 face B : 6
>>> d2.affiche_points()
face A : 4 face B : 3
>>> print "total des points :", d1.valeur() + d2.valeur()
15
>>> liste_dominos = []
>>> for i in range(7):
liste_dominos.append(Domino(6, i))
>>> print liste_dominos
Sauvegarder ce fichier sous le nom domino.py
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Domino : # Constructeur def __init__(self): self.A = 0 self.B = 0 # Méthode def affiche_point(self,A,B): self.A = A self.B = B def valeur(self,A,B): self.res = A + B #Programme Principale d1 = Domino(2,6) d2 = Domino(4,3) d1.affiche_point() print("Face A : {} Face B : {}".format(Domino().A,Domino().B))

09/12/2011, 22h00
fred1599
C'est très difficile sans te donner les réponses à l'exercice.

Mais surtout tu devrais nous expliquer un peu ce que vous avez vu en POO (exemple, la surcharge opérateur?).

Edit:

Code:

>>> d1 = Domino(2,6)

On voit 2 arguments

Les arguments sont à intégrer dans le __init__()
Code:

1 2 3 class Domino(object): def __init__(self, A, B): self.A, self.B = A, B
ce qui donne
Code:

1 2 3 4 5 >>> d1 = Domino(2, 6) >>> d1.A 2 >>> d1.B 6
Ensuite il faut que tu crées une méthode affiche_points, et là c'est toi qui rentre en jeu ;)
09/12/2011, 22h33
malabar93

Merci pour ta réponse ,

Par POO , je vois "programmation orienté objet"
09/12/2011, 22h51
josmiley

Citation:

Envoyé par malabar93

Merci pour ta réponse ,

Par POO , je vois "programmation orienté objet"

:mouarf: , ce que vous avez vu en cours, pas ce que vous voyez ... demande fred1599
09/12/2011, 22h52
fred1599

Euh... Si tu commences comme ça on va pas s'en sortir :lol:

Je sais ce que veut dire POO, ce que j'aimerais savoir c'est ce que vous avez vu en cours de POO.

Sinon t'as vu les explications du haut? ça te parle?

Tu as fais la méthode affiche_points?

Edit : grilled par josmiley
09/12/2011, 23h16
malabar93

Merci pour vos réponses ,

Désoler par ma vite faute d’inattention , sinon , pour le moment , on as pas vu grand chose se n'est que les bases des bases je pense .
Càd comment crée une classe avec un constructeur et des méthodes .On a rien vu de plus , mais comme chaque nouvelle matière , j'ai du mal à la syntaxe .

PS : Je me lance dans la partie "affiche_points"
09/12/2011, 23h22
cFranssen

tu dosi faire un return de self.a et self.b dans affiche_point

Sa fonctionne , je vais essayer de terminer le reste

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Domino :
 
	# Constructeur
	def __init__(self, A=0, B=0):
		self.A, self.B = A, B
 
	# Méthode
	def affiche_point(self):
		return self.A, self.B
 
#Programme Principale
d1 = Domino(2,6)
d2 = Domino(4,3)
print(d1.affiche_point())

10/12/2011, 09h03
fred1599

Ce n'est pas ce qui est demandé pour affiche_points
10/12/2011, 13h18
malabar93

Je ne sais pas comment aire autrement du a mon manque de connaissance dans la syntaxe des classe .
10/12/2011, 16h08
fred1599

une méthode se construit à quelque chose prêt comme une fonction, réfléchit un peu... voir les formatages, return, etc... c'est toi et toi seul qui fera ce travail.

Citation:

Envoyé par malabar93

du a mon manque de connaissance dans la syntaxe des classe .

Non, juste dû à ton manque de concentration
Code:

1 2 3 4 5 6 7 8 class Domino : def affiche_point(self): print "face A:%d, face B: %d\n" % (self.A, self.B) # Programme Principal (sans "e" car "programme" est du genre masculin) d1 = Domino(2,6) d2 = Domino(4,3) d1.affiche_point()

10/12/2011, 17h40
fred1599

heureusemenr que je lui dis de le trouver lui même :)

sinon je pense plus à un manque de concentration mais en classe...

quand on arrive à la POO, c'est qu'on à assimilé des bases dans le langage, enfin censé assimilé...

Merci , je l'avais finnit y'a 2-3 heures mais j'avais oublié de posté ma solution .
Sinon , je pense avoir finnit , si se n'est que le dernier truc dans les exemples que je ne vois pas trop se qu'il faut faire .
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 #!/usr/bin/env python3 #-*- coding: utf-8 -*- # Defise Thomas 6TB # MonDomino.py - Le 27 Octobre 2011 class Domino : # Constructeur def __init__(self, A=0, B=0): self.A = A self.B = B # Méthode def affiche_point(self): print ("face A : {} face B : {}".format(self.A,self.B)) def valeur(self): somme = self.A + self.B return somme #Programme Principale d1 = Domino(2,6) d2 = Domino(4,3)
J'ai fait un autre exercice que j'ai finnit et qui fonctionne et je m'attaque au dernier qui est le plus dur .

Citation:

JeuDeCartes.py
Définissez une classe JeuDeCartes() permettant d'instancier des objets
« jeu de cartes » dont le comportement soit similaire à celui d'un vrai jeu de
cartes. La classe devra comporter au moins les quatre méthodes suivantes :
●
constructeur : création et remplissage d'une liste de 52 éléments, qui
sont eux-mêmes des tuples de 2 éléments contenant les
caractéristiques de chacune des 52 cartes. 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).
Dans une telle liste, l'élément (11, 2) désigne donc le valet de Trèfle, et
la liste terminée doit être du type : [(2,0),(3,0),...,(5,2),
(6,2), ...,(13,3),(14,3)]
Il n'est pas question d'implémenter le jeu de cartes en hard-coding !
Vous utiliserez pour cela les boucles et les alternatives.
●
nom_carte() : cette méthode renvoie sous la forme d'une chaîne
l'identité d'une carte quelconque, dont on lui a fourni le tuple
descripteur en argument.
P. ex. : print jeu.nom_carte((14,3)) => As de Pique
●
battre() : comme chacun sait, battre les cartes consiste à les
mélanger, Cette méthode sert donc à mélanger les éléments de la liste
contenant les cartes, quel qu'en soit le nombre.
●
tirer() : lorsque cette méthode est invoquée, une carte est retirée du
jeu. Le tuple contenant sa valeur et sa couleur est renvoyé au
programme appelant. On retire toujours la première carte de la liste. Si
cette méthode est invoquée alors qu'il ne reste plus aucune carte dans
la liste, il faut alors renvoyer l'objet spécial None au programme
appelant.
Exemple d'utilisation de la classe
jeu = JeuDeCarte() # Création du jeu de cartes
jeu.battre() # mélange des cartes
for n in range(52) : # Tirage des 52 cartes
carte = jeu.tirer()
if carte == None : # Il ne reste plus aucune carte
print 'Terminé!'
else :
# Affichage de la valeur et de la couleur de la carte
print jeu.nom_carte(carte)
Complément de l'exercice précédent
1. Définir deux joueurs A et B.
2. Instancier deux jeux de cartes (un pour chaque joueur) et les
mélanger.
3. Ensuite, à l'aide d'une boucle, tirer 52 fois une carte de chacun des
deux jeux et comparer leurs valeurs.
1. Si c'est la première des deux qui a la valeur la plus élevée, on
ajoute un point au joueur A.
2. Si la situation contraire se présente, on ajoute un point au joueur B.
3. Si les deux valeurs sont égales, on passe au tirage suivant. Celui qui
remportera le duel suivant remportera un point en plus.
P. ex. : Si le joueur A et joueur B tirent la même carte, on passe au
tirage suivant. Si c'est le joueur A qui remporte le duel, celui-ci
remporte 2 points à la place d'un et le joueur B aucun !
4. Au terme de la boucle, comparer les comptes de A et de B pour
déterminer le gagnant

Et voila ou j'en suis , je n'arrive pas a faire les tuples et ma première boucle ne veut pas commencer a 1
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class JeuDeCartes : # Constructeur def __init__(self): tuple = () carte = [] color = ['Coeur','Carreau','Trefle','Pique'] i = 1 for i in range(15): o = 0 for o in range(4): tuple = (i,color[o]) carte += tuple print (carte) #Programme Principale jdc1 = JeuDeCartes() jdc1

10/12/2011, 17h57
Sve@r
Citation:

Envoyé par fred1599

heureusemenr que je lui dis de le trouver lui même :)

Tu as mille fois raison. Généralement sur les gros trucs je ne donne pas la solution. Mais sur ce genre de petit truc, donner la solution en y rajoutant une petite claque verbale a, selon moi, plus d'effet. Normalement, si ton interlocuteur a qqchose dans la tête, il est tellement vexé de n'avoir pas trouvé un truc aussi simple qu'il se remotive et se reconcentre pour te montrer qu'il n'est pas aussi idiot que ce que tu le sous-entend. Et, si tu réfléchis bien, quelle que soit sa motivation, l'important est qu'il se reconcentre non ???

Citation:

Envoyé par malabar93

Merci , je l'avais finnit y'a 2-3 heures mais j'avais oublié de posté ma solution .
Sinon , je pense avoir finnit , si se n'est que le dernier truc dans les exemples que je ne vois pas trop se qu'il faut faire .

Cet exemple te montre comment utiliser la classe et ses méthodes pour créer et utiliser un tableau de dominos allant de 6,0 à 6,6

Citation:

Envoyé par malabar93

Et voila ou j'en suis , je n'arrive pas a faire les tuples
Code:

1 2 3 4 def fct_tuple(x, y): return (x, y) print fct_tuple(2, 3), type(fct_tuple(2, 3))
Citation:

Envoyé par malabar93

et ma première boucle ne veut pas commencer a 1

Mmmoui et alors ? C'est primordial ????

Citation:

Envoyé par malabar93

#Programme Principale

Ca fait plaisir de voir comme tu tiens compte de ce qu'on t'écrit. Ca donne super envie de te répondre...
10/12/2011, 18h15
wiztricks
Salut,
Dans:
Code:

1 2 3 4 5 class JeuDeCartes : # Constructeur def __init__(self): tuple = () carte = []
vous écrasez a définition de tuple qui est un "mot réservé" pour construire des tuple... Commencez plutôt par initialiser la liste de "cartes" comme çà:
Code:

1 2 3 4 class JeuDeCartes : # Constructeur def __init__(self): self.cartes = []
Relisez l'énoncé: on vous demande d'utiliser des nombres pour coder les figures puis de traduire ces nombres en As, Coeur, Carreau, Trèfle,
Pique,... De plus, "la liste terminée doit être du type : [(2,0),(3,0),...,(5,2),
(6,2), ...,(13,3),(14,3)]"
=> Pas question de mettre dedans 'Coeur','Carreau','Trefle','Pique' même si çà pourrait aider...
stricto sensu l'initialisation de self.cartes pourrait être faite ainsi:
Code:

1 2 3 for y in range(4): for x in range(2, 15): self.cartes.append( (x, y) )
- W

Merci de ton aide wiztricks ,j'ai finit les le contructeur et nom_carte .
Code:

1 2 3 4 5 6 7 8 9 10 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): chiffre = ['Un','Deux','Trois','Quatre','Cinq','Six','Sept','Huit','Neuf','Dix','Valet','Dame','Roi'] color = ['Coeur','Carreau','Trefle','¨Pique'] print('{} de {}'.format(chiffre[x],color[y]))
Je suis entrain de faire la fonction battre ou je cherche ou se trouve mon bug .
Sinon , quelqu'un pourrait me dire comment tester mes scripte rapidement ,
car la , je code avec Notepad++ .
Pour tester mon script je dois aller dans le dossier ou se trouve le script , puis l'ouvre avec l'éditeur de python que je ne supporte pas et pour finir le lancer .

10/12/2011, 20h24
utopman

python

C'est cool que votre prof vous fasse travailler en python :D

pour tester ton script tu peux lancer la commande

Code:

python nom_du_script.py

si tu es dans le repertoire du script
sous windows il faut ajouter le chemin de l'exe python en variable d'environnement (dans les propriétés du poste de travail)
tu fais une référence a l'interpréteur python

Code:

ex : c:\python2.7\python.exe

et tu mets un alias comme python
ensuite tu lance les commandes windows et tu te mets dans le répertoire de ton script :

Code:

cd c:\chemin\du\script

tu peux alors lancer ton script en tapant

Code:

%nom_de_l_alias% nom_du_script.py

(ici l'alias c'est python qu'on a indiqué dans les variables d'environnement)
ton script doit alors s'exécuter

PS: Sve@r, si tes méthode d'éducation/management sont basées sur le répressif, c'est pas pour autant que ça marche mieux avec tel ou tel individu. Malabar ne semble que vouloir apprendre...

Salut
Ecrire:
chiffre = [ 'Un','Deux','Trois','Quatre','Cinq','Six','Sept','Huit','Neuf','Dix','Valet','Dame','Roi']
color = ['Coeur','Carreau','Trefle','¨Pique']
n'est pas cohérent avec l'énoncé qui dit:

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)

Ni avec le copie&coller de:

Pour:
Code:

1 2 3 4 def nom_carte(self,x,y): chiffre = ['Un','Deux','Trois','Quatre','Cinq','Six','Sept','Huit','Neuf','Dix','Valet','Dame','Roi'] color = ['Coeur','Carreau','Trefle','¨Pique'] print('{} de {}'.format(chiffre[x],color[y]))
chiffre et color étant des "constantes", inutile de les redéfinir à chaque fois.
Soyez consistant pour le globish: "chiffres" et "couleurs" ou "numbers" et "colors".
- W

Merci utopman , j’arrive a tester mes scripts plus rapidement .

Voila la suite du code , mais j'ai un bug à la dernière méthode .Il me met "list index out of range"

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
from random import randrange
 
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]))
 
	def battre(self):
		used = []
		cartesmel = []
		while len(used) <= 54:
			x = randrange(0,54)
			if self.cartes[x] in used:
				pass
			else :
				cartesmel.append(self.cartes[x])
				used.append(self.cartes[x])
		print (cartesmel)
 
#Programme Principal
 
jdc1 = JeuDeCartes()
jdc1.battre()

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