NSI - Terminale - Programmation Orientée Objet
Travail demandé
Partie 1: Construire et instancier une classe
Vous allez créer un classe qui permet de construire des objets carte à jouer d'un jeu de 32 cartes. On définit les attributs d'une carte par: son nom, sa couleur, sa valeur et son statut.
- Le nom est une chaîne de caractères qui peut valoir "sept", "huit", "neuf", "dix", "as", "valet", "roi", "dame".
- La couleur est une chaîne de caractères qui peut valoir "carreau" ou "coeur" ou "trèfle" ou "pique".
- La valeur de chaque carte est représentée par un nombre entier naturel:
Par exemple pour un "valet" la valeur est 2 si la carte est Non Atout sinon la valeur est 20 si la carte est Atout. - Le statut est un booléen qui peut valoir True si la carte est un Atout ou False si la carte est Non Atout.
Voici les pondérations possibles:
Information: cette façon d'accorder les points est celle de la belote. Dans ce jeu de 4 joueurs ( 2 contre 2), un des joueurs appelé le donneur est choisi au hasard pour la distribution des cartes. Les cartes sont disposées en un tas avec faces non visibles ( on ne voit pas la couleur, le nom et la valeur des cartes). Le Donneur prend le tas et distribue une carte à chaque joueur en commençant par le joueur situé à sa gauche, personne ne doit voir quelle carte reçoit les autres. Le donneur recommence 4 fois, chaque joueur reçoit donc 5 cartes. Après la distribution, le donneur retourne la carte suivante du tas de cartes restantes pour la rendre visible, la couleur de la carte qui apparait devient l'Atout ce qui change la pondération ( valeur des cartes) pour les cartes de cette couleur. Par exemple si la carte qui apparait est un "as" de "trèfle", la couleur "trèfle" devient Atout, ce qui change la valeur du "neuf" de "trèfle" et du "valet" de "trèfle" (voir l'image ci-dessus ). La suite du déroulement du jeu est sans importance pour cette activité.
Question 1.1
-
Avec un éditeur python comme Thony ou autre coder une classe qui s'appelle Carte.
-
Ajoutez à cette classe la méthode constructeur __ init__(...) qui règle les attributs nom, couleur, valeur et statut lors de la construction d'un objet Carte. Vous avez le début du code ci-dessous:
Remarque: lors de la création d'un objet, la carte sera toujours avec le statut = False ( donc pas Atout) et la valeur de la carte sera celle qui va avec le statut non Atout.
# ***************************************************************** #
# DEFINITION #
# ***************************************************************** #
# La classe Carte
class Carte:
'''Lors de la construction d'un objet, les variables n,c et v
vont recevoir la valeur à donner aux attributs:
n pour l'attribut nom, c pour l'attibut couleur
et v pour l'attribut valeur'''
def __init__(self, n, c, v):
# l'attribut nom reçoit la valeur de n
self.nom = n
self.couleur = .....
self.valeur = .....
self.statut = False
# ***************************************************************** #
# UTILISATION #
# ***************************************************************** #
# création d'un objet Carte ( instance de la classe Carte)
# ici self = neuf_de_pique, n = "neuf", c = "pique" et v = 0
neuf_de_pique = Carte("neuf", "pique", 0)
Information: Lors de la création de l'objet Carte assigné à la variable neuf_de_pique, la méthode _ init _ est automatiquement appelée. Le premier argument self de _init _ représente l'objet qui recevra les valeurs, si on confond l'objet et sa variable, on peut dire que l'objet est neuf_de_pique et donc self = neuf_de_pique, l'expression self.nom devient neuf_de_pique.nom, l'attribut nom reçoit la valeur du deuxième argument n passé à _init _ lors de la construction de l'objet soit "neuf" ainsi neuf_de_pique.nom = "neuf", de même neuf_de_pique.couleur = "pique", neuf_de_pique.valeur = 0 et neuf_de_pique.statut = False.
Comprendre: le processus d'initialisation est automatique, vous codez neuf_de_pique = Carte("neuf", "pique", 0) ce qui appelle automatiquement _init _ de Carte avec self = neuf_de_pique
Question 1.2
-
Coder la création des objets: valet_de_pique, valet_de_coeur, valet_de_trèfle et valet_de_carreau ( dit autrement créer une instance de la classe Carte associée à la variable valet_de_carreau)
Remarque: pour afficher dans la console la valeur d'un attribut, on utilise la notation pointée objet.attribut.
Par exemple pour afficher la valeur de l'attribut nom de la carte neuf_de_pique, on code:
print("le nom de la carte neuf de pique est: ", neuf_de_pique.nom)
ou print(f"le nom de la carte neuf de pique est: {neuf_de_pique.nom}") -
Afficher la valeur de tous les attributs de votre objet valet_de_pique
- Créez un objet liste vide et l'assigner à la variable valets, ajouter vos 4 objets valet_de_pique, valet_de_coeur, valet_de_trèfle et valet_de_carreau dans la liste valets.
Question 1.3
- Compléter la définition de la fonction appelée genere_atout(), ce n'est pas une méthode, la fonction n'appartient pas à la classe Carte. Cette fonction permettra de générer aléatoirement la couleur qui est Atout, elle renverra cette couleur que l'on stockera dans une variable appelée atout.
# ***************************************************************** #
# DEFINITION #
# ***************************************************************** #
from random import randint
# définition de la fonction genere_atout() (à compléter)
def genere_atout():
# liste des couleurs
couleurs = ["coeur","carreau","pique","trèfle"]
# randint(0,3) génère aléatoirement un nombre entier entre 0 et 3 et le renvoie
# la variable tirage reçoit la valeur renvoyée par randint
tirage = randint(0,3)
# à compléter
.........
# La classe Carte
class Carte:
# etc..
# ***************************************************************** #
# UTILISATION #
# ***************************************************************** #
# la variable atout est assignée avec la couleur renvoyée par genere_atout()
atout = genere_atout()
# affichage de la couleur de l'atout
print(f"la couleur de l'Atout est {atout}")
# création d'un objet Carte ( instance de la classe Carte)
neuf_de_pique = Carte("neuf", "pique", 0)
# Création de l'objet valet de pique
# à compléter
valet_de_pique =.................
# Création de l'objet valet de coeur
# à compléter
valet_de_coeur =.................
# Création de l'objet valet de trèfle
# à compléter
valet_de_trèfle =.................
# Création de l'objet valet de carreau
# à compléter
valet_de_carreau =.................
# Création de le liste vide assignée à valets
# à compléter
valets = ...
# ajout des objets valets à la liste
# à compléter
valets........
Question 1.4
- Compléter la définition de la méthode change_statut(self), c'est une méthode, la définition est dans la classe Carte. Cette méthode change le statut d'une carte qui est Atout, l'attribut statut devient True au lieu de False.
# ***************************************************************** #
# DEFINITIONS #
# ***************************************************************** #
# définition de la fonction genere_atout() (à compléter)
def genere_atout():
# liste des couleurs
couleurs = ["coeur","carreau","pique","trèfle"]
# randint(0,3) génère aléatoirement un nombre entier entre 0 et 3
#et le renvoie
tirage = randint(0,3)
# à compléter
.........
# La classe Carte
class Carte:
'''Lors de la construction d'un objet, les variables n,c et v
vont recevoir la valeur à donner aux attributs:
n pour l'attribut nom, c pour l'attibut couleur
et v pour l'attribut valeur'''
def __init__(self, n, c, v):
# l'attribut nom reçoit la valeur de n
self.nom = n
self.couleur = .....
self.valeur = .....
self.statut = False
def change_statut(self):
# utiliser la variable atout définie en dehors de la classe
global atout
# si la couleur de l'objet self est bien Atout
if self.couleur == atout:
# l'attribut statut reçoit la valeur True
# à compléter
self..............
# ***************************************************************** #
# UTILISATION #
# ***************************************************************** #
# utilisation de la fonction genere_atout()
# remarquez que l'on génère l'atout avant de construire les cartes
atout = genere_atout()
# affichage de la couleur de l'atout
print(f"la couleur de l'Atout est {atout}")
# création d'un objet Carte ( instance de la classe Carte)
neuf_de_pique = Carte("neuf", "pique", 0)
# changement du statut de l'objet neuf_de_pique
# la méthode n'agira que si atout = "pique"
neuf_de_pique.change_statut()
# Création de l'objet valet de pique
# à compléter
valet_de_pique =.................
# Création de l'objet valet de coeur
# à compléter
valet_de_coeur =.................
# Création de l'objet valet de trèfle
# à compléter
valet_de_trèfle =.................
# Création de l'objet valet de carreau
# à compléter
valet_de_carreau =.................
# Création de le liste vide assignée à valets
# à compléter
valets = ...
# ajout des objets valets à la liste
# à compléter
valets........
- Compléter la méthode set_valeur_atout(self), c'est une méthode la définition est dans la classe Carte. Cette méthode donne une nouvelle valeur à l'attribut valeur d'une carte dont la couleur est Atout.
from random import randint
# ***************************************************************** #
# DEFINITIONS #
# ***************************************************************** #
# définition de la fonction genere_atout() (à compléter)
def genere_atout():
# liste des couleurs
couleurs = ["coeur","carreau","pique","trèfle"]
# randint(0,3) génère aléatoirement un nombre entier entre 0 et 3
# et le renvoie
tirage = randint(0,3)
# à compléter
.........
# La classe Carte
class Carte:
'''Lors de la construction d'un objet, les variables n,c et v
vont recevoir la valeur à donner aux attributs:
n pour l'attribut nom, c pour l'attibut couleur
et v pour l'attribut valeur'''
def __init__(self, n, c, v):
# l'attribut nom reçoit la valeur de n
self.nom = n
self.couleur = .....
self.valeur = .....
self.statut = False
def change_statut(self):
# utiliser la variable atout définie en dehors de la classe
global atout
# si la couleur de l'objet est bien l'atout
if self.couleur == atout:
# l'attribut statut reçoit la valeur True
# à compléter
self..............
def set_valeur_atout(self):
# utiliser la variable atout définie en dehors de la classe
global atout
# si la couleur de l'objet est bien l'atout
if self.couleur == atout:
if self.nom == "valet":
# à compléter
# l'attribut valeur reçoit la valeur 20
self..............
......................
# ***************************************************************** #
# UTILISATION #
# ***************************************************************** #
# utilisation de la fonction genere_atout()
# remarquez que l'on génère l'atout avant de construire les cartes
atout = genere_atout()
# affichage de la couleur de l'atout
print(f"la couleur de l'Atout est {atout}")
# création d'un objet Carte ( instance de la classe Carte)
# ici self = neuf_de_pique, n = "neuf", c = "pique" et v = 0
neuf_de_pique = Carte("neuf", "pique", 0)
# Changement du statut et de la valeur du neuf de pique
# les méthodes n'agiront que si atout = "pique"
neuf_de_pique.change_statut()
neuf_de_pique.set_valeur_atout()
# etc..
Question 1.5
- Compléter le code qui applique les méthodes change_statut et set_valeur_atout aux objets Carte de la liste valets.
- Afficher les attributs statut et valeur des quatre objets valet... pour vérifier que la couleur qui est Atout a bien changé de statut et de valeur.
# pour chaque objet Carte e de la liste valets
for e in valets:
# changement de statut
# à compléter
e....
# changement de valeur
# à compléter
e......
# affichage du statut et de la valeur de la carte e
print(f"la carte {e.nom} de de {e.couleur} a le statut ..... ")
Partie 2: classe Joueur
A traiter uniquement si vous êtes en avance
Question 2.1
Ajouter à votre code la classe Joueur et son constructeur _ init _ (self, n, p) qui initialise les 2 attributs: nom et prenom.
La classe possède 3 attributs
- l'attribut nom du joueur (recevra la valeur de n une chaîne de caractères).
- l'attribut prenom du joueur (recevra la valeur de p une chaîne de caractères).
- l'attribut cartes du joueur qui est associé à une liste vide.
Lorsque l'on crée un objet joueur ( une instance de la classe Joueur ), on code par exemple:
joueur1 = Joueur( "Dino_le_boss", "Dino" )
Question 2.2
Créez 4 objets joueurs, exemple:
Dino_le_boss = Joueur( "Dino_le_boss", "Dino" )
Dédé_la_magouille = Joueur( "Dédé_la_magouille", "Dédé" )
Fifi_la_ruse = Joueur( "Fifi_la_ruse", "Fifi" )
Toni_le_filou = Joueur( "Toni_le_filou", "Toni" )
Question 3.3
Vous disposez de la définition d'une fonction genere_cartes() qui permet de génèrer et renvoyer un dictionnaire avec un jeu de 32 objets cartes.
def genere_cartes():
couleurs = ["coeur","carreau","pique","trèfle"]
noms = ["sept", "huit", "neuf", "dix", "as", "valet", "roi", "dame"]
valeur = {"sept":0, "huit":0, "neuf":0, "dix":10, "as":11, "valet":2, "roi":4, "dame":3}
# dictionnaire des cartes
cartes = {}
# pour chaque couleur c de la liste couleurs
for c in couleurs:
# pour chaque nom n de la liste noms
for n in noms:
# construit la chaine nom de la carte
nom_carte = f"{n}_de_{c}"
# le nom de la carte sera une clé du dictionnaire
# la valeur de la clé est un objet Carte
cartes[nom_carte] = Carte(n, c, valeur[n])
# après les boucles, on renvoie le dictionnaire
return cartes
-
Adaptez le code ci-dessous pour qu'il distribue 8 cartes à chacun de vos 4 joueurs.
-
Affichez les cartes de chacun des quatre joueurs
import random
# la fonction prend en argument un dictionnaire d'objets cartes
def distribuer(cartes):
# on crée 4 listes vides associées à des variables
joueur1, joueur2, joueur3, joueur4 = [], [], [], []
# on met chaque liste vide dans une liste joueurs
joueurs = [joueur1, joueur2, joueur3, joueur4]
# pour chaque joueur de la liste joueurs
for joueur in joueurs:
# répéter 8 fois
for _ in range(8): # 8 cartes par joueur
# prendre une clé au hasard parmi la liste des clés du dico cartes
cle = random.choice(list(cartes.keys()))
# donner la carte au joueur
joueur.append(cartes[cle])
# retirer la paire clé, valeur du dictionnaire
del cartes[cle]
# renvoyer les 4 listes de cartes
return joueur1, joueur2, joueur3, joueur4