Travail demandé

Activité Programmation orientée objet

Partie 1: Construire une classe et instancier des objets

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 '7','8', '9','10', 'as', 'roi', 'dame', 'valet'

La couleur est une chaîne de caractères qui peut valoir "carreau" ou "coeur" ou "trèﬂe" ou "pique".

La valeur sera représentée par un nombre entier:

Par exemple pour un valet la valeur est 2 si la carte est non atout sinon sa valeur est 20.

Le statut est un booléen qui peut valoir "True" si la carte est un Atout ou "False" si la carte est n'est pas un Atout.

Voici les pondérations possibles:

Question 1.1

Créez une classe qui s'appelle carte.

Ajoutez un constructeur qui règle les attributs nom, couleur, valeur et statut.

Remarque: lors de la création d'un objet, la carte sera toujours avec le statut = False ( donc pas Atout) et la valeur sera celle qui va avec ce statut.

class Carte:

''' permet de construire des objets carte à jouer'''

def __init__(self, à compléter):

self.à_compléter = à compléter

etc..

On pourra instancier des objets ( créer des objets) avec un code du genre:

roi_de_pique = Carte("roi", "pique", 4, False )

valet_de_carreau = Carte("valet", "carreau", 2, False )

Getters et setters

Pour connaître la valeur d'un attribut, on peut créer une méthode de lecture d'attribut ce que l'on appelle en Anglais un getter.

Voici le code du getter de la valeur d'une carte, la méthode doit être définit dans la classe à la suite de la méthode def __init__(.....) :

class Carte:

def __init__(self, à compléter):

self.à_compléter = à compléter

etc..

def get_valeur(self):

return self.valeur

Lors de l'utilisation on déclare une variable qui reçoit la valeur renvoyée par la méthode pour l'objet en question:

la_valeur_de_la_carte_valet_de_carreau = valet_de_carreau.get_valeur()

Question 1.2

Ajoutez des getters pour obtenir la valeur, le nom, la couleur et le statut d'un objet carte.

Pour modifier la valeur d'un attribut d'objet, on peut créer une méthode d'écriture ce que l'on appelle en Anglais un setter.

Voici le code de la définition du setter pour le statut d'une carte ( atout ou non atout) , la méthode doit être définie dans la classe :

def set_statut(self, etat):

self.statut = etat

La fonction s'utilise pour un objet Carte dont on doit modifier la valeur:

# carreau est maintenant atout

valet_de_carreau.set_statut(True)

Question 1.3

Ajoutez des méthodes setters pour modifier la valeur et le statut d'une carte. Pour la valeur, il faudra vérifier que la valeur donnée est bien entre 0 et 20.

Question 1.4

Créez une fonction appelée genere_atout() , qui n'appartient pas à la classe Carte, cette fonction permettra de générer aléatoirement la couleur qui est atout, elle aura comme valeur de retour cette couleur que l'on stockera dans une variable appelée atout

Rappel : le module random possède des fonctions de génération de nombres aléatoires:

import random

def genere_atout():

# affecte à la variable tirage un nombre entier entre 0 et 3 inclus généré aléatoirement

tirage = random.randint(0,3)

return à_compléter

Question 1.5

Créez une liste vide appelée liste_cartes pour stocker le nom des objets "Carte" créés

Créez quatre objets "Carte" : neuf_de_pique, neuf_de_treffle, neuf_de_coeur, neuf_de_carreau et ajoutez les à la liste liste_cartes

Créez ensuite une fonction appelée change_le_statut (....., ......) qui prend en paramètre la liste "liste_cartes"et l'atout. La fonction devra modifier le statut et la valeur d'un objet "Carte" en fonction de l'atout, cette fonction doit utiliser les méthodes setters de l'objet pour procéder à la modification du statut et de la valeur si nécessaire.

Partie 2: interface graphique ( si vous avez du temps)

Le programme ci-dessous affiche l'image d'un 9 de pique sur un canvas placé dans une fenêtre Tkinter, on indique sa valeur sur la carte à l'aide de la variable valeur_9_pique. Le canvas s'appelle fond, il est jaune, un objet canvas permet de dessiner dans une fenêtre, on peut insérer une image sur le canvas et écrire du texte. Ici on ajoute l'image 9_pique.PNG et on écrit le contenu de la variable valeur_9_pique:

# création d'une fenêtre

fen = Tk()

fen.title("cartes")

fen.geometry("800x600")

# le canvas remplit la fenêtre

fond = Canvas(fen, width=800, height=600, bg="yellow")

fond.place(x=0,y=0)

# ajout de l'image 9_pique.PNG (199 x 264 pixels) sur le canvas

pique_9 = PhotoImage(file="9_pique.PNG")

fond.create_image(100,150,image=pique_9)

# ajout du texte sur le canvas

valeur_9_pique = 0

fond.create_text( 100, 265, text="Valeur = {}".format(valeur_9_pique))

# abonnement aux événements de l'os

fen.mainloop()

Question 2.1

Téléchargez en cliquant ici l'image d'un 9 de pique appelée " 9_pique.PNG" dans le dossier qui contient votre code python, puis testez le code précédent.

Ajoutez l'image des 3 autres objets Carte créés à la question 1.5 dans le dossier qui contient votre code python puis la valeur de chaque carte en fonction de l'atout généré aléatoirement.

Partie 3: classe Joueur et distribution des cartes ( si vous avez du temps)

Vous allez maintenant ajouter à votre code, la classe Joueur et son constructeur qui initialise 3 attributs:

- le nom du joueur ( contiendra une chaîne de caractères)

- le prénom du joueur ( contiendra une chaîne de caractères)

- les cartes du joueur ( contiendra une liste d'objets Carte).

class Joueur:

def __init__(self, nom, prenom, cartes):

self.nom = nom

self.prenom = prenom

self.cartes = cartes

Lorsque l'on crée un joueur, on passe une liste vide pour l'argument cartes:

joueur1 = Joueur("Dino_le_boss","Dino", [ ] )

Question 3.1

Créez 32 objets Cartes d'un jeu de 32 cartes.

Ajoutez ces 32 objets à une liste appelée liste_cartes qui ressemblera donc à:

liste_cartes = [ sept_de_pique, huit_de_pique, neuf_de_pique, dix_de_pique, As_de_pique, Valet_de_pique, Dame_de_pique, Roi_de_pique, sept_de_treffle, huit_de_treffle, neuf_de_treffle, dix_de_treffle, etc.... , Roi_de_coeur]

Question 3.2.

Créez 4 objets joueurs et ajoutez les à une liste appelée liste_joueurs, exemple:

liste_joueurs = [ joueur1, joueur2, joueur3, joueur4]

Question 3.3

On considère maintenant une partie de contrée, chaque joueur se voit distribuer 8 cartes, écrivez le code qui distribue aléatoirement à chacun des 4 joueurs 8 cartes de la liste liste_cartes. Vous afficherez ensuite les cartes reçues par chaque joueur dans la console ( Voir remarques ci-dessous).

Exemple d'affichage après distribution:

Remarques: une carte distribuée doit être retirée de la liste liste_cartes avant de distribuer la carte suivante. La liste liste_cartes n'a donc pas de taille et contenu fixe durant la distribution.

On vous rappelle deux méthodes utiles pour la manipulation des listes:

len(liste_cartes)= renvoie le nombre d'éléments de la liste.

liste_cartes.remove(liste_cartes[1]): retire l'élément placé à l'indice 1 de la liste, l'indice 1 aurait pu être remplacé par la valeur d'une variable.

Créé avec HelpNDoc Personal Edition: Produire des livres Kindle gratuitement