Discussion :

[PythonJaune]

Bonjour,

Je n'arrives pas à remplir des tableaux à l'aide d'une fonction en appelant celle-ci depuis une autre classe. J'ai lu pas mal de théorie, mais je rame total. Pourriez-vous, svp, m'indiquer concrètement ce qu'il faut que je change ? Parfois je comprends mieux à l'aide de code qu'à l'aide de la théorie...

Voici mon 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
import random
 
moves = ['rock', 'paper', 'scissors', 'lizard', 'spock']
 
class Player:
	def __init__(self):
		self.record1 = []
		self.record2 = []
 
	#fonction qui joue un mouvement au hasard	
	def move1(self):
		return random.choice(moves)
 
	#Function pour stocker les mouvements des deux joueurs
	def learn(self, move1, move2):
		self.record1.append(move1)
		self.record2.append(move2)
		return self.record1
 
#Class qui joue le mouvement précédent du joueur adverse
class ReflectPlayer(Player):
	def __init__(self):
		super().__init__()
		self.record1 = []
		self.record2 = []		
		self.move = None		
 
	#Function joue le mouvement précédent du joueur adverse	
	def ReflectMove(self):
		move = ""
		l = len(self.record1)
		if l == 0:
			move = "rock"
		else:
			move = self.record1[len(self.record1) - 1]
		self.move = move
		return self.move 
 
	#Function pour stocker les mouvements des deux joueurs
	def learn(self, move1, move2):
		self.record1.append(move1)
		self.record2.append(move2)
		return self.record1
 
 
class Game(ReflectPlayer):
	def __init__(self, p1, p2):
		super().__init__()
		self.p1 = p1
		self.p2 = p2
 
	def play_round(self):
		move1 = self.p1.move1()
		move2 = self.p2.ReflectMove()		
		print(f"You played : {move1}")
		print(f"Your opponent played : {move2}")
		self.p1.learn(move1, move2) # appel fonctions pour remplir les tableaux dans les autres classes
		self.p2.learn(move2, move1) # appel fonctions pour remplir les tableaux dans les autres classes
		print(ReflectPlayer().record1)
		print(ReflectPlayer().record1)
 
	#Function for playing multiple games
	def play_game(self):					
		print("\nGame start! \n")
		for round in range(3):
			print(f"Round {round}: \n")
			self.play_round()					
		print("Game over! \n")
 
 
# programme principal
 
g = Game(Player(), ReflectPlayer())
g.play_game()

[wiztricks]

Salut,

Relisez attentivement les lignes 59, 60:

Code :

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

1
2
	print(ReflectPlayer().record1)
	print(ReflectPlayer().record1)

Et si vous ne comprenez pas pourquoi c'est n'importe quoi, ouvrez un tuto.

- W

[PythonJaune]

Salut,

Relisez attentivement les lignes 59, 60:

Code :

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

1
2
	print(ReflectPlayer().record1)
	print(ReflectPlayer().record1)

Et si vous ne comprenez pas pourquoi c'est n'importe quoi, ouvrez un tuto.

- W

J'ai mis ces deux print pour voir le contenu de mes tableaux en test, mais la fonction "learn" ne fonctionne pas. Cela dit, merci pour votre réponse, elle m'aide énormément !!

[wiztricks]

J'ai mis ces deux print pour voir le contenu de mes tableaux en test, mais la fonction "learn" ne fonctionne pas.

Ben c'est la que çà affiche des listes vides non?

- W

[PythonJaune]

Je crois qu'on ne s'est pas compris. Je sais bien que les tableaux ne sont pas remplis, c'est exactement le problème que j'ai. Ils devraient se remplir à l'aide de la fonction "learn" qui se trouve dans les deux autres classes qui sont : Player et ReflectPlayer. Je pense qu'il s'agit d'un problème de liaison des classes ou d'héritage qui fait que lorsque j'appelle la fonction "learn", depuis ma classe Game, elle ne s'exécute pas. J'ai beau parcourir les tutos, je planche totalement. C'est pourquoi je pose la question. Si vous exécutez le code, vous verrez que la classe qui est sensée répliquer les mouvements de l'autre joueur, à partir du second tour, ne le fait pas.

je reposte le code sans les deux prints :

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
import random
 
moves = ['rock', 'paper', 'scissors', 'lizard', 'spock']
 
class Player:
	def __init__(self):
		self.record1 = []
		self.record2 = []
 
	#fonction qui joue un mouvement au hasard	
	def move1(self):
		return random.choice(moves)
 
	#Function pour stocker les mouvements des deux joueurs
	def learn(self, move1, move2):
		self.record1.append(move1)
		self.record2.append(move2)
		return self.record1
 
#Class qui joue le mouvement précédent du joueur adverse
class ReflectPlayer(Player):
	def __init__(self):
		super().__init__()
		self.record1 = []
		self.record2 = []		
		self.move = None		
 
	#Function joue le mouvement précédent du joueur adverse	
	def ReflectMove(self):
		move = ""
		l = len(self.record1)
		if l == 0:
			move = "rock"
		else:
			move = self.record1[len(self.record1) - 1]
		self.move = move
		return self.move 
 
	#Function pour stocker les mouvements des deux joueurs
	def learn(self, move1, move2):
		self.record1.append(move1)
		self.record2.append(move2)
		return self.record1
 
 
class Game(ReflectPlayer):
	def __init__(self, p1, p2):
		super().__init__()
		self.p1 = p1
		self.p2 = p2
 
	def play_round(self):
		move1 = self.p1.move1()
		move2 = self.p2.ReflectMove()		
		print(f"You played : {move1}")
		print(f"Your opponent played : {move2}")
		self.p1.learn(move1, move2) # appel fonctions pour remplir les tableaux dans les autres classes
		self.p2.learn(move2, move1) # appel fonctions pour remplir les tableaux dans les autres classes
 
 
	#Function for playing multiple games
	def play_game(self):					
		print("\nGame start! \n")
		for round in range(3):
			print(f"Round {round}: \n")
			self.play_round()					
		print("Game over! \n")
 
 
# programme principal
 
g = Game(Player(), ReflectPlayer())
g.play_game()

[wiztricks]

Je pense qu'il s'agit d'un problème de liaison des classes ou d'héritage qui fait que lorsque j'appelle la fonction "learn", depuis ma classe Game, elle ne s'exécute pas.

Quand vous faites ce genre d'hypothèse, ajoutez un "print" dans le corps de la méthode: c'est facile à tester et vous aurez la réponse à votre question.
Profitez en pour afficher ce qu'elle reçoit en paramètre et vérifier que c'est cohérent (avec ce que vous attendez).
Puis si çà vous dépasse encore, simplifiez: virez tout ce qui ne sert à rien (et il y en a des tonnes).
Python ne fait que ce que vous lui avez demandé d'exécuter et si çà ne se passe pas comme vous l'attendez, c'est que quelque part, vous avez une erreur de logique (la logique du jeu qui est dans votre tête).

- W

[Sve@r]

Bonjour

moves = ['rock', 'paper', 'scissors', 'lizard', 'spock']

Ah ? tu as suivi mon idée et rajouté les coups "à la Sheldon"

Code python :

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

1
2
3
	#fonction qui joue un mouvement au hasard	
	def move1(self):
		return random.choice(moves)

C'est effectivement le meilleur choix. En effet, la meilleure stratégie pour gagner au shifoumi est de jouer au hasard

#Class qui joue le mouvement précédent du joueur adverse

Ca je comprends moins. Ok adopter comme stratégie de jouer le dernier coup du joueur adverse je veux bien (mais s'il s'en aperçoit t'es mort) mais créer une classe pour ça ???
T'as la liste des coups des deux joueurs. Tu veux jouer le dernier coup adverse tu joues simplement record2[-1] !!!

Une classe c'est un truc qui doit pouvoir faire des actions. Là quelle action tu veux faire à part "sortir le dernier coup stocké" qui est un truc directement accessible via son indice ?

[PythonJaune]

Salut Steve@r et merci pour ta réponse.

En fait, je le fais dans le cadre d'un projet pour un cours. On me demande de créer 4 classes pour 4 stratégies, et la seule que je n'arrive pas à faire fonctionner c'est celle-là (reflect player). Cette classe (un peu con certes) est sensée jouer ou répliquer le coup antérieur de l'adversaire. Mais je n'y arrives pas. Je planche dessus depuis très longtemps... si tu exécutes le code, tu verras que le joueur "oponent" devrait jouer la première fois rock et ensuite répliquer ton mouvement. Et ça ne fonctionne pas. Je suis débutant..... J'ai mis des "print" partout dans ma fonction pour essayer de voir ce qui ne va pas, mais que dalle....

[PythonJaune]

Et au fait, oui, j'ai suivi ta recommendation car à la fin de l'énoncé du projet il est écrit que l'on peut faire varier le jeu pour une meilleure appréciation.

[wiztricks]

Et au fait, oui, j'ai suivi ta recommendation car à la fin de l'énoncé du projet il est écrit que l'on peut faire varier le jeu pour une meilleure appréciation.

Si vous avez ajouté un "print" à learn vous devriez constater qu'à chaque appel c'est "rock" s'ajoute à la liste self.record1: comme le coup suivant est donné par le dernier de la liste, çà joue toujours "rock", normal! Mais ce n'est pas (toujours) ce qu'à joué l'adversaire.

Python, lui, ne fait qu'exécuter des instructions ce que vous pensez/voulez, il s'en fout.
Et le gros travail du programmeur, c'est pas écrire des lignes mais savoir se relire et questionner son code pour s'assurer qu'il va bien faire ce qu'il attend.

- W

[Sve@r]

Ok, j'ai testé ton code.
Déjà il faut que ton objet "Player" hérite de "object". Ou alors c'est parce que mon Python (3.4.2) est trop ancien que chez-moi ça ne veut pas le faire sans ça.

Ensuite tu dis que "learn" de ReflectPlayer n'est pas appelé => moi j'ai mis un "print" et je vois le print s'afficher donc il est bien appelé.

Maintenant, puisque ReflectPlayer hérite de Player et que Player possède déjà une méthode "learn" pourquoi tu la redéfinis à l'identique dans "ReflectPlayer" ? Supprime-là puisqu'elle fait la même chose (ça sert à ça l'héritage). Idem pour "record1" et "record2" qui existent déjà dans la classe mère "Player".

Sinon tu as raisonné à l'envers (enfin d'après ce que je comprends). Parce que du point de vue du joueur adverse (donc celui qui est de la classe "ReflectPlayer"), le coup de son adversaire est stocké dans "record2", pas "record1" !!!
Donc la méthode "ReflectMove" doit renvoyer le dernier coup stocké dans "record2". Ca t'apprendra à choisir tes noms de variable avec plus d'intelligence (tu aurais appelé ça "myMove" et "opponentMove" tu aurais de suite trouvé !!!)

Maintenant les trucs inutiles

• inutile de stocker le coup joué dans "self.move"
• inutile que "learn" renvoie un truc
• pas besoin d'un __init__ dans ReflectPlayer qui ne fait juste qu'appeler le __init__ de Player => on le supprime et l'héritage fait le reste
• la fonction "ReflectMove" de la classe "ReflectPlayer" pourrait s'appeler "move" pour uniformiser (quand tu auras 4 objets ayant chacun leur stratégie et que tu en choisiras une, tu n'auras pas besoin de changer le nom de la méthode appelée)
• Game n'a pas besoin d'hériter de Player ou de ReflectPlayer. L'héritage c'est un peu comme dire "ceci est un cas particulier de cela" => une voiture est un cas particulier de véhicule. Le jeu n'est certainement pas un cas particulier d'un joueur (à la limite tu aurais dit qu'un joueur était un cas particulier du jeu j'aurais mieux accepté)

Il y a aussi des trucs dont je m'explique mal l'utilité

• pourquoi stocker ses propres coups
• pourquoi stocker tous les coups joués (tous les siens et tous ceux de l'adversaire)
• pourquoi chaque joueur stocke tous les coups (redondance) alors que les coups pourraient être stockés par le jeu lui-même (donc une seule fois) et les deux joueurs y auraient librement accès

Mais bon, pour les deux premiers je me dis que peut-être ça pourra servir plus tard et pour le 3° ça devient un trop grand changement (surtout que si on supprime ça alors l'objet "Player" ne contient plus rien du tout) donc j'ai laissé ces points inchangés. Ce qui donne donc ceci

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import random
 
# Objet qui gère le joueur principal
class Player(object):
	def __init__(self):
		self.record1=[]
		self.record2=[]
	# __init__()
 
	# Fonction qui gère le mouvement du joueur principal => un mouvement au hasard	
	def move(self):
		return random.choice(Game.moves)
 
	# Fonction pour stocker les mouvements des deux joueurs
	def learn(self, move1, move2):
		self.record1.append(move1)
		self.record2.append(move2)
	# __learn__()
# class Player
 
# Objet qui gère un adversaire ayant pour stratégie de répéter le dernier coup du joueur principal
class ReflectPlayer(Player):
	# Fonction qui joue le mouvement correspondant à la stratégie de l'objet (dernier coup joué par l'adversaire)
	def move(self):
		return self.record2[-1] if self.record2 else Game.moves[0]
# class ReflectPlayer
 
# Objet qui gère le jeu
class Game(object):
	moves=['rock', 'paper', 'scissors', 'lizard', 'spock']
 
	def __init__(self, p1, p2):
		super(Game, self).__init__()
		self.p1 = p1
		self.p2 = p2
	# __init__()
 
	def play_round(self):
		move1 = self.p1.move()
		move2 = self.p2.move()		
		print("You played : %s" % move1)
		print("Your opponent played : %s" % move2)
		self.p1.learn(move1, move2) # appel fonctions pour remplir les tableaux dans les autres classes
		self.p2.learn(move2, move1) # appel fonctions pour remplir les tableaux dans les autres classes
	# play_round()
 
	# Function for playing multiple games
	def play_game(self):					
		print("\nGame start! \n")
		for round in range(3):
			print("Round %d: \n" % round)
			self.play_round()					
		# for
		print("Game over! \n")
	# play_game()
# class Game
 
# Programme principal
g = Game(Player(), ReflectPlayer())
g.play_game()

[PythonJaune]

Salut Steve@r et merci pour ta réponse.

En effet, je constate que je me suis bien trop compliqué la vie, et que du coup j'ai ajouté plein de trucs inutiles. En gros, je me suis bien paumé. Et sincèrement, si tu ne m'avais pas éclairé sur ces sujets, j'aurais pu tourner en boucle très longtemps.

Merci pour la lumière apportée sur tous les points.

Meilleures salutations.

[PythonJaune]

P.S. je suis sur python 3.7.1 donc, en effet, il n'est plus nécessaire d'ajouter "objet" a la classe mère.

meilleures salutations.

[Sve@r]

Je me suis amusé à coder ce truc. Déjà j'ai compris pourquoi chaque joueur doit stocker les coups joués => parce qu'un joueur ne sait pas qu'il est "1" ou "2". Si les coups sont stockés dans le Game, lorsque le joueur reflet doit jouer il ne sait pas s'il doit prendre les coups dans la liste 1 ou la liste 2

Voici ce que ça donne

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#!/usr/bin/env python3
# coding: utf-8
 
import random
 
# Objet qui gère le jeu
class cGame(object):
	RCK=0x01
	PPR=0x02
	SCS=0x03
	LZD=0x04
	SPK=0x05
	pieces={
		RCK : {
			"label" : "Rock",
			"win" : (SCS, LZD),
		},
		PPR : {
			"label" : "Paper",
			"win" : (SPK, RCK),
		},
		SCS : {
			"label" : "Scissors",
			"win" : (LZD, PPR),
		},
		LZD : {
			"label" : "Lizard",
			"win" : (SPK, PPR),
		},
		SPK : {
			"label" : "Spock",
			"win" : (SCS, RCK),
		},
	}
 
	def __init__(self, p1, p2, rnd):
		super(cGame, self).__init__()
		self.__p1=p1
		self.__p2=p2
		self.__rnd=rnd
	# __init__()
 
	def debug_rules(self):
		for v in cGame.pieces.values():
			yield "%s éclate %s" % (
				v["label"],
				", ".join(cGame.pieces[x]["label"] for x in v["win"]),
			)
		# for
	# debug_rules()
 
	# Evaluation résultat
	def __evaluate(self, m1, m2):
		if m2 in cGame.pieces[m1]["win"]: return m1
		if m1 in cGame.pieces[m2]["win"]: return m2
		return 0
	# __evaluate()
 
	def play_round(self):
		move1 = self.__p1.move()
		move2 = self.__p2.move()		
		self.__p1.learn(move1, move2)
		self.__p2.learn(move2, move1)
		print("Player1 played : %s" % cGame.pieces[move1]["label"])
		print("Player2 played : %s" % cGame.pieces[move2]["label"])
		e=self.__evaluate(move1, move2)
		if e == move1:
			print("Player1 win")
			self.__p1.win()
		elif e == move2:
			print("Player2 win")
			self.__p2.win()
		else:
			print("Draw")
		print("Player 1: %d" % self.__p1.score)
		print("Player 2: %d" % self.__p2.score)
	# play_round()
 
	# Function for playing multiple games
	def play_game(self):					
		print("\nGame start! \n")
		for rnd in range(1, self.__rnd + 1):
			print("\nRound %d/%d:" % (rnd, self.__rnd))
			self.play_round()					
		# for
		print("Game over! \n")
		print("Score p1 : %d" % self.__p1.score)
		print("Score p2 : %d" % self.__p2.score)
	# play_game()
# class Game
 
# Objet qui gère un joueur
class cJoueur(object):
	score=property(lambda self: self.__score)
	moves=property(lambda self: self.__moves)
	def __init__(self):
		self.__score=0
		self.__moves=[]
 
	def win(self):
		self.__score+=1
 
	def learn(self, m1, m2):
		self.__moves.append((m1, m2))
# class cJoueur()
 
# Objet qui joue aléatoirement
class cJoueurRandom(cJoueur):
	def move(self):
		return random.choice(tuple(cGame.pieces.keys()))
# class cJoueurRandom()
 
# Objet qui joue le dernier coup de son adversaire
class cJoueurReflect(cJoueurRandom):
	def move(self):
		return self.moves[-1][1] if self.moves else super(cJoueurReflect, self).move()
# class cJoueurReflect()
 
# Programme principal
import sys
g=cGame(cJoueurRandom(), cJoueurReflect(), int(sys.argv[1]))
g.play_game()

On lance le programme en lui donnant le nombre de rounds qu'il doit jouer.
Ce qui est amusant, c'est que si on lui demande d'évaluer deux joueurs reflet, alors soit le score final est 0/0 parce que les deux ont choisi par hasard le même truc et ensuite chacun répète le choix de l'autre ; soit n/n (n étant la moitié du nombre de rounds) parce que chacun choisit à chaque round ce que l'autre a choisi.

Je vais m'amuser à coder d'autre stratégies pour voir ce que ça donne...