La programmation objet : trop classe !

Un nouveau paradigme de programmation

Voici une vidéo qui explique la philosophie de la la programmation orientée objet :

Jusqu’ici, les programmes que vous avez créés l'ont été en programmation impérative (c'est-à-dire une succession d'instructions) et en programmation procédurale (c’est-à-dire que chaque programme a été décomposé en plusieurs fonctions réalisant chacune des tâches simples).

À partir des années 1960, un autre type de programmation a été rendu nécesaire par le fait que, lorsque plusieurs programmeurs travaillent simultanément sur un projet, il faut éviter les conflits entre les fonctions : la programmation orientée objet est née.
Le premier langage de programmation initiant une forme de programmation orientée objet fut Simula, créé à partir de 1962. Ce langage servait à faciliter la programmation de logiciels de simulation.
Le premier langage de programmation réellement fondé sur la programmation orientée objet fut Smalltalk 71, créé au début des années 70.

La programmation orientée objet est un paradigme de programmation, c'est-à-dire une autre manière de voir les notions en programmation.
En programmation procédurale, ce sont les fonctions qui sont au coeur du programme ; elles s'appliquent à modifier des données.
En programmation orientée objet, ce sont les données qui sont au coeur du programme : celles-ci vont désormais être protégées et c'est le développeur qui décide comment elles seront créees, accessibles, modifiées, ... Ah ! pouvoir désormais définir ses propres objets informatiques en précisant leurs types, leurs propriétés et les fonctionnalitéss agissant dessus. Que suffit-il ? Un fiat lux ? Non, il suffit de travailler le cours qui suit ! Cela s'appelle faire ses classes !

Deux exemples de classe

Voici une vidéo qui introduit le vocabulaire de la programmation orientée objet au travers de deux exemples :

Voici un premier exemple concret :

photo représentant diférents chiens

On peut réécrire les phrases précédentes avec le vocabulaire de la programmation objet :

Voici un second exemple, cette fois-ci dans le domaine informatique :

Au chapitre précédent sur les structures de données, vous avez découvert la notion de pile, c'est un type de données.

Pour rappel, voici une représentation d'une pile non vide : image d'une pile : rectangles avec vocabuleire

Vous aviez vu comme exemple de pile : image d'une pile où les éléments sont des héros de Star Wars

Cet exemple de pile peut être vu comme un objet du type pile.

L'élément au sommet d'une pile (non vide), c'est-à-dire celui du haut de la pile, est une caractéristique propre d'une pile ; cet élément peut être vu comme un attribut d'une pile.
Dans l'exemplaire de pile représenté ci-dessus, l'attribut haut prend la valeur "Anakin".

Vous avez aussi vu que la structure de données pile possède une interface, c'est-à-dire un ensemble d'opérateurs, c'est-à-dire des actions spécifiques aux piles :

Tous ces opérateurs, peuvent être appelés des méthodes.

Cet ensemble de caractéristiques et de méthodes font que le type de données structurées pile est ce que l'on appelle en programmation objet une classe.

Définition

Voici une vidéo présentant le vocabulaire essentiel de la programmation objet avec une analogie concrète pour aider à la compréhension de ce vocabulaire.

Voici un ensemble de définitions, qui vont vous paraître abstraites au départ, mais qui seront clairifées au fil des exemples de ce cours.

Une classe est une structure de données abstraite regroupant :

Un objet est un élément issu d'une classe. On parle aussi d'instance de la classe.

Voici quelques exemples :

Un chien peut être vu comme un objet de la classe Canis lupus familiaris, ayant plusieurs attributs : race, âge, taille, masse, propriétaire, ... Sur cet objet, peuvent s'appliquer plusieurs méthodes : vacciner, tatouer, tondre, ...

Médor, Fido et Pupuce sont des instances de cette classe Canis lupus familiaris.

Un pays peut être vu comme un objet de la classe État, ayant plusieurs attributs : nom, superficie, population, capitale, ... Sur cet objet, peuvent s'appliquer plusieurs méthodes : agrandir, se fractionner, fusionner, ...

La France et la Chine sont des instances de cette classe État.

Une voiture particulière peut être vu comme un objet de la classe voiture, ayant plusieurs attributs : marque, prix, propriétaire, ... Sur cet objet, peuvent s'appliquer plusieurs méthodes : acheter, faire le plein, réparer, vendre, ...

La voiture du proviseur ou de votre enseignant sont des instances de cette classe voiture.

Une autre manière de dire est qu'une classe regroupe des attributs et méthodes communs à un ensemble d'objets :

Encore quelques définitions :

La création d'un objet d'une classe s'appelle une instanciation de cette classe.

La création d'un nouveau pays revient à une nouvelle instanciation de la classe État. Ce nouveau pays est une instance de cette classe État. Cela nécessite de préciser les attributs de ce nouveau pays : donner un nom, spécifier un territoire, une superficie, préciser la capitale, ...

Concrètement, l'instanciation revient à réserver un espace mémoire puis à le remplir par du contenu.

Il existe trois principaux types de méthodes différentes :

Découvrons-les !

Un constructeur est une méthode qui permet l'instanciation. Cette méthode initialise (on dit aussi instancie) l'ensemble des attributs de l'objet.

La déclaration d'indépendance est un constructeur de la classe État. En effet, lors de cette déclaration, les attributs de ce nouveau pays sont précisé : quel nom, quel territoire, quelle superficie, quelle capitale, ...

On considère un jeu dans lequel des cartes sont manipulées. On s'intéresse à l'objet carte à jouer.

  1. Justifier que l'on peut définir une classe nommée JeuDeCartesEnMain en précisant deux attributs de cette classe.

  2. Proposer des méthodes qui peuvent s'appliquer à cette classe. (Seuls des verbes d'action sur des cartes à jouer sont attendus ici).

  3. Proposer deux instances de cette classe.

Code de déblocage de la correction :

Comme ces définitions sont assez abstraites de prime abord, voici une analogie pour se faire une image plus concrète de la notion de classe :

  • Une classe est une structure de données abstraite regroupant des données :

    • munies de caractéristiques appelées attributs,

    • sur lesquelles peuvent s'appliquer des actions appelées méthodes.

  • La création d'un objet d'une classe est appelée instanciation.
    Celle-ci initialise l'ensemble des attributs de cet objet.

  • L'instanciation se réalise à l'aide d'une méthode s'appelant un constructeur.

Si ces notions vous paraissent encore confuses, c'est normal. Mais sachez que vous les manipuler depuis le début sans le savoir car en Python, tout est objet : les fonctions, les types, ...

Création d'une classe pas à pas en Python

Vous faites partie d'une société qui crée des jeux vidéo. Dans le projet d'un nouveau jeu, vous devez gérer les personnages. Afin d'éviter tout conflit dans le code produit par les autres collaborateurs, vous écrivez votre code en utilisant le paradigme de programmation objet.

Un constructeur

Vous allez devoir commencer par créer la classe Personnage.

Une classe est définie en Python par le mot-clé class suivi du NomDeLaClasse (par convention, contrairement à une variable, l'initiale est en majuscule et la suite en CamelCase) puis de deux-points : :


class NomDeLaClasse:
    """
    Documentation
    """
            

Voici le début de la classe Personnage, avec une succincte documentation :

# pas dans la console mais dans l'éditeur
class Personnage:
    """
    Un personnage du jeu vidéo
    """
    

Pour reprendre l'analogie vue à la fin du 1.3 (pour y retourner), vous être en train de "définir" le moule général d'un personnage. Reste à définir les attributs d'un personnage.

Pour simplifier, pour l'instant, nous supposons que les personnages ont deux attributs :

Pour construire un personnage à partir (du moule général) de la classe, il vous faut utiliser un constructeur.

En Python, le constructeur est la méthode :


class NomDeLaClasse:
    ... 
    def __init__(self,val_attribut1,val_attribut2,...):
        self.nom__attribut1 = val_attribut1
        self.nom__attribut2 = val_attribut2
        ...
                

Voici le code de la classe Personnage précédente augmentée du constructeur :

# pas dans la console mais dans l'éditeur
class Personnage:                             # Définition de la classe
    """
    Un personnage du jeu vidéo              # Documentation
    """

    def __init__(self,genre,experience):    # Définition du constructeur
        self.genre=genre                    # premier attribut : le genre (féminin, masculin, autre)
        self.experience=experience          # deuxième attribut : l'expérience (évaluée par un nombre entier)

        

A-t-on maintenant le personnage ? Pas encore, il faut appeler (implicitement) le constructeur pour que l'ordinateur alloue une place au futur personnage dans sa mémoire pour y caser l'objet et ses attributs.
Pour créer un personnage, nommé ici Alex, c'est-à-dire une instance de la classe Personnage, il suffit, non pas d'appeler le constructeur __init__ mais directement la classe par son nom.

Il vous suffit donc de saisir :

# dans l'éditeur
Alex = Personnage("masculin",0)
            

Vous pouvez visualiser le code de la définition de la classe Personnage et l'instanciation de l'objet Alex ci-dessous en ramenant le curseur au début si besoin puis en faisant défiler étape par étape (avec le bouton "next >") :

Pour créer une instance d'une classe, il suffit en Python d'utiliser la syntaxe :


nouvel_objet = NomClasse(nom_attribut1,nom_attribut2,...)
        

Votre personnage Alex est désormais créé et a sa place dans l'ordinateur (si ce n'est dans le futur jeu !) comme vous pouvez le voir avec :

# dans l'éditeur
>>> print(Alex)
<__main__.Personnage object at 0x032214D0>
    

__main__.Personnage object signifie que Alex est un objet de la classe Personnage : vous avez dès lors son type.

0x032214D0 correspond à la notation héxadécimale (d'où le 0x du début) de l'adresse où est stockée l'objet dans la mémoire. L'exécution du code sur votre ordinateur conduira sûrement à une autre adresse.

Les attributs du personnage créé sont désormais toujours accessibles à l'aide de l'opérateur d'accessibilité point . :

Pour accéder aux valeurs des attributs du personnage Alex :

# dans l'éditeur
        >>> Alex.genre 
        'masculin'
        >>> Alex.experience 
        0
        

Pour accéder aux attributs d'une instance, il suffit en Python d'utiliser avec l'opérateur . en suivant la syntaxe :


            valeur = nom_objet.nom_attribut
        

  1. Créer deux personnages nommés :

    • Berenice une femme d'expérience 1254.

    • Bob de genre 'autre' et d'expérience 0

  2. Vérifier la valeur des attributs de Berenice.

Code de déblocage de la correction :

Comme a priori, tout nouveau personnage doit commencer avec une expérience nulle, il est possible de définir la valeur par défaut de cet attribut :

class Personnage:                             
        """
        Un personnage du jeu vidéo              
        """
    
        def __init__(self,genre,experience=0):  # initialisation
            self.genre=genre                    
            self.experience=experience          
    
            

Alors l'appel au constructeur peut se faire avec un seul argument : le genre .

Création simplifiée d'un personnage avec une expérience banale :

# dans l'éditeur
>>> Duc = Personnage('masculin')
>>> Duc.experience 
0

On peut encore créer un personnage avec une autre experience en rajoutant un second argument :

# dans l'éditeur
>>> Elsa = Personnage('feminin',42)
>>> Elsa.experience 
42

Résumé des bases vues au 2.1 de la programmation d'une classe en Python :

Les personnages du jeu vidéo géreront des outils au cours de leur aventure. Ces outils possèdent différents attributs :

  1. Définissez une nouvelle classe nommée Outil.

  2. Créez le constructeur de cette classe permettant de définir les trois attributs cités supra pour un outil. Par défaut, le constructeur initialise à 1 le nombre de mains nécessaires pour l'utilisation d'un objet.

  3. Créez deux outils au choix dont un nécessite plus d'une main.

  4. Pour chacun de vos outils, vérifiez la valeur de l'attribut correspondant au nombre de main.

Code de déblocage de la correction :

L'encapsulation

Content de vous, vous montrez le début de votre travail à votre chef d'équipe. Il est horrifié ! Si l'utilisateur a accès à la représentation interne des classes, il pourrait facilement tricher en donnant par exemple à un personnage une experience de 1000000 !

Il vous parle alors de la notion d'encapsulation :

L'encapsulation est un principe qui consiste à regrouper des données avec un ensemble de méthodes permettant de les lire ou de les manipuler dans le but de cacher ou de protéger certaines de ces données.

Les méthodes et données internes (celles plus ou moins "cacher" à l'utilisateur) sont dites privées.
Les méthodes et données accessibles à tout utilisateur (celles que les utilisateurs de la classe connaissent) sont dites publiques.

Certains langages, comme le PHP ou le Javascript vus en première, définissent de manière stricte cette visibilité en fournissant des mots-clés pour caractériser si chaque élément d’une classe est privé ou public.

En Python, il y a une convention de nommage : un attribut privé est toujours préfixé (c'est-à-dire précédé) de deux espaces soulignés (tiret du bas, celui du 8).

En Python, lorsque le nom d'un attribut commence par "__", celui-ci est automatiquement renommé ainsi : _nomClasse__nomAttribut. Étant ainsi renommé, il n'est plus aussi aisément accessible depuis l'extérieur de la classe.

  1. Modifiez le code suivant pour rendre l'attribut experience privé :

  2. class Personnage:                             
        """
        Un personnage du jeu vidéo              
        """
    
        def __init__(self,genre,experience=0):  
            self.genre=genre                    
            self.experience=experience          
    
            
  3. Créez un nouveau personnage au choix.

  4. Essayez d'accéder directement à son expérience avec la syntaxe : valeur = nom_objet.nom_attribut. Que remarquez-vous ?

Code de déblocage de la correction :

Il existe un niveau intermédiaire entre privé et public que l'on nomme protégé. En Python, il suffit de préfixer l'attribut (ou la méthode) d'un espace souligné (tiret du bas ou du 8). Par exemple : _attrib5 # attribut protégé.
Contrairement à d'autres langages, en Python, les données protégées sont accessibles normalement et le préfixe a pour seul objectif d’informer sur leur nature. Nous n'en parlerons pas plus dans ce cours.

Les accesseurs

Pour l'interface graphique, le niveau d'expérience doit être accessible mais le joueur ne doit pas pouvoir modifier la valeur directement. Pour pouvoir accéder à la valeur de l'attribut, on créé dans la classe une méthode appelée accesseur.

Par convention, un accesseur commence par le verbe anglais get (to get = obtenir = récupérer).
Comme toute méthode, son appel se fera suivant la syntaxe suivante :


            valeur = nom_objet.nom_accesseur()
        

Voici la classe précédente augmentée de la méthode get_experience qui permet de récupérer le niveau d'expérience (mais pas de modifier ce niveau) :

class Personnage:                             
    """
    Un personnage du jeu vidéo              
    """

    def __init__(self,genre,experience=0):  
        self.genre=genre                    
        self.__experience=experience          

    def get_experience(self):               # self toujours pour désigner l'objet auquel s'appliquera cette méthode
        return self.__experience            # return ici pour récupérer la valeur souhaitée
        

  1. Écrivez le code précédent (dans un éditeur ou dans un Jupyter).

  2. Créez un nouveau personnage Freeda ; vous pouvez lui donner le niveau d'expérience que vous voulez.

  3. Obtenez son niveau d'expérience en utilisant le code suivant : Freeda.get_experience(). Retrouvez-vous la valeur que vous aviez saisie ?

Code de déblocage de la correction :

Reprenez la classe que vous avez créé à l'exercice 3 (ici) :

  1. Rajoutez un accesseur permettant de récupérer la masse d'un objet.

  2. Utilisez cette méthode afin de récupérer la masse d'un des objets que vous avez créé lors de l'exercice 3.

Code de déblocage de la correction :

Les mutateurs

Lors du jeu, le niveau d'expérience du personnage doit évoluer : cette expérience doit être accessible en interne mais pas en externe.
Pour pouvoir modifier la valeur de l'attribut d'un objet, on créé dans la classe une méthode appelée mutateur.

Par convention, un mutateur commence par le verbe anglais set (to set = modifier).

Comme toute méthode, son appel se fera suivant la syntaxe suivante :


    nom_objet.nom_mutateur()

Voici ci-dessous la classe précédente augmentée de la méthode set_experience qui permet de modifier le niveau d'expérience.

Pour l'instant, cette méthode est publique afin que vous puissiez l'utiliser dans la console. Il est possible de rendre cette méthode privée en la nommant __set_experience. Dans ce cas, vous pourrez modifier le niveau d'expérience dans le programme (de l'éditeur) mais pas y accéder depuis la console (cf. le programme de l'exercice 9 du 2.5 accès direct).

class Personnage:                             
    """
    Un personnage du jeu vidéo              
    """

    def __init__(self,genre,experience=0):  
        self.genre=genre                    
        self.__experience=experience          

    def get_experience(self):               # self toujours pour désigner l'objet auquel s'appliquera cette méthode
        return self.__experience            # return ici pour récupérer la valeur souhaitée
    
    def set_experience(self,valeur):        # valeur sera le niveau niveau de l'experience
        self.__experience = valeur         
        

Remarquez qu'aucun return n'est nécessaire ici pour le mutateur ; la valeur de l'expérience est changée sans être renvoyée. Un peu comme si vous modifiiez une variable globale.

  1. Écrivez le code précédent (dans un éditeur ou dans un Jupyter).

  2. Créez un nouveau personnage Garou ; vous pouvez lui donner le niveau d'expérience que vous voulez.

  3. Vérifier son niveau d'expérience en utilisant l'accesseur get_experience().

  4. Modifier son niveau d'experience en le mettant à 10, par exemple, en utilisant la syntaxe suivante : Garou.set_experience(10).

  5. Vérifier son niveau d'expérience en utilisant la méthode adéquate.

Code de déblocage de la correction :

Reprenez la classe que vous avez créé à l'exercice 3 (ici) :

  1. Rajoutez un mutateur permettant de diminuer de 1 le nombre de mains nécessaire à la manipulation d'un objet, si ce nombre n'est pas 1.

  2. Créez un outil dont l'utilisation nécessite initialement 3 mains.

  3. Utilisez le mutateur pour modifier le nombre de mains nécessaire pour la manipulation de cet outil.

  4. Vérifiez, avec une nouvelle méthode à créer, le nombre de mains nécessaires désormais nécessaire à la manipulation de cet objet.

Code de déblocage de la correction :

Résumé des informations vues du 2.2 au 2.4 de la programmation d'une classe en Python :

D'autres méthodes

Il est possible d'insérer dans une classe toute méthode jugée utile.

Dans notre exemple, il serait intéressant :

On peut supposer que chaque rencontre augmente l'expérience d'un nombre aléatoire compris entre 10 et 20. En Python, cela nécessitera l'utilisation de la bibliothèque random. Ainsi, le début du programme devra désormais commencer par l'habituel :

from random import * 

La méthode rencontre conduit au tirage aléatoire du gain d'expérience puis à l'appel de la méthode désormais rendue privée __set_experience.

from random import *                             
class Personnage:

    ...                                     # le début n'est pas modifié : il est à reprendre des exemples précédents par copier-coller.
            
    def __set_experience(self,valeur):      # méthode désormais privée car seul le programme y accède pour modifier la valeur : d'où le nom commençant par __
        self.__experience = valeur                       
    
    # Autre méthode :
    def rencontre(self):  
        """"fait évoluer aléatoirement l'expérience lors d'une """                 
        n = randint(10,20)                  # tirage aléatoire d'un entier entre 10 et 20 (inclus)  
        self.__set_experience(self.get_experience()+n)      # appel de la méthode __set_experience, agissant sur l'objet sur lequel elle s'appliquera (self). 
                                            # Le nouveau niveau d'expérience est l'ancien (obtenu avec self.get_experience() ) augmenté de n.
 
  1. Complétez puis exécuter le programme complet définissant la classe Personnage.

  2. Créez un nouveau personnage sans expérience initiale puis faites lui vivre une première rencontre.

  3. Observez l'évolution de son expérience.

  4. Faites vivre au personnage une seconde rencontre et observez l'évolution de son expérience.

  5. Pouvez-vous par un appel direct au mutateur __set_experience() modifier l'expérience de ce personnage ?

Code de déblocage de la correction :

Méthode __str__

nous avons déjà vu précédemment que lorsque l'on essaie d'afficher un objet créé à l'aide de la fonction print, on obtient surtout l'adresse mémoire en hexadécimal de l'objet.

Pour redéfinir le comportement de la fonction print, il suffit d'utiliser la méthode native __str__.
Cette méthode doit :

  1. comporter comme seul paramètre self qui désigne l'objet concerné par cet appel,

  2. renvoyer une chaîne de caractères.

Nous avons déjà vu qu'après avoir créé un personnage Alex comme objet de la classe Personnage, alors print(Alex) renvoie que c'est un objet d'une certaine classe ainsi que son emplacement mémoire.

Nous voulons désormais que cette fonction print affiche une chaîne de caractères précisant le genre et le niveau d'expérience du personnage.

Par exemple : après avoir créé le personnage Alex avec :

Alex = Personnage("masculin",0)

On obtient l'affichage suivant avec print(Alex)

Personnage de genre masculin et de niveau d'expérience 0
  1. Dans la classe Personnage, créer la méthode __str__ permettant l'affichage voulu.

  2. Tester cette méthode.

Code de déblocage de la correction :

TP : gestion d'un compte bancaire

Le but est de définir une classe CompteBancaire qui permette :

  1. Créez la classe CompteBancaire.

  2. Créez le constructeur de cette classe en faisant en sorte qu'un nouveau compte s'ouvre par défaut avec 0 euro dessus.

  3. Créez les accesseurs à chacun des deux attributs des objets de la classe.

  4. Créez un mutateur privé qui permet de faire évoluer la somme placée sur un compte de variation euros.

  5. Rajoutez à ce mutateur un test qui permet d'afficher un message si le compte est à découvert à l'issue de la modification.

  6. Créez une méthode depot qui utilise le mutateur privé précédent pour ajouter une certaine somme sur un compte bancaire.

  7. Créez une méthode retrait qui utilise le mutateur privé précédent pour retirer une certaine somme sur un compte bancaire.

  8. Testez cette méthode retrait de sorte qu'un compte passe dans le négatif. Est-ce que l'affichage prévu dans le mutateur privé gérant l'attribut solde s'affiche lors de l'utilisation de cette méthode publique ?

  9. Créez une méthode afficher qui affiche le nom du titualire et le solde de son compte.

  10. Code de déblocage de la correction :

    1. Créez un mutateur privé qui permette de changer le nom du titulaire.

    2. Créez une méthode protégée _pirater qui utilise le mutateur précédent et qui permet de changer le nom du titulaire d'un compte bancaire.

    3. Utilisez cette méthode _pirater pour vous attribuer un compte bancaire. Oh ! Ce n'est pas bien du tout !

    4. Utiliser l'instruction help(CompteBancaire) afin de visualiser l'ensemble des méthodes visibles facilement par l'utilisateur du code. Un client peut-il facilement être au courant de la présence de cette méthode protégée _pirater ?

    5. Code de déblocage de la correction :

Projets

Cahier des charges

Par groupe, vous devez développer un projet libre dans lequel vous utiliserez la programmation objet.

Pour ceux n'ayant aucune idée pour réaliser un projet : un jeu de carte

Un jeu de 52 cartes est constitués de

Le but est de créer une classe, nommée Carte, qui contient le constructeur et les accesseurs nécessaires à modéliser un jeu de 52 cartes.

  1. Par quel mot-clé débute toute classe ?

  2. Voici le début d'un script pour cette classe. De nombreuses méthodes sont incomplètes.

  3. class Carte:                             
        """
        Un jeu de 52 cartes            
        """
                
         def __init__(self,valeur,couleur):         # toujours self pour désigner l'objet auquel s'appliquera cette méthode
        """constructeur de la classe""" 
        # À compléter                               # penser qu'il y a deux attributs
          
        # ensembles des accesseurs
        def get_valeur(self):                       
            # À compléter                           # penser à utiliser un return afin de récupérer la valeur souhaitée
        
        def get_couleur(self):                       
            # À compléter                           # penser à utiliser un return afin de récupérer la valeur souhaitée
     

    Complétez le constructeur de la classe en écrivant une ligne pour chaque attribut.

  4. Compléter les deux méthodes correspondant aux accesseurs liés à chaque attribut.

  5. Testez votre code en construisant une première carte, nommée carte_en_main, qui est une instance de la classe Carte et qui devra être ici le 7 de carreau.

  6. Rajouter au code précédent deux mutateurs nommé set_couleur et set_valeur ; ces méthodes ont deux paramètres : self et nouvelle

  7. .
  8. On suppose que désormais la carte en main n'est plus le 7 de carreau mais le 10 de coeur. Utiliser les deux mutateurs créés afin de changer les attributs de l'instance carte_en_main.

  9. On veut construire une méthode trier_hasard dans la classe Carte ayant pour seul paramètre self qui permet de modifier la couleur et la valeur d'une carte pour simuler le tirage aléatoire d'une carte du jeu.
    Pour cela :

    1. Rajouter en première ligne de code : from random import *.

    2. Voici ci-dessous le début de la méthode trier_hasard à insérer dans la classe Carte :

    3.                 
          def tirer_hasard(self):
              """
              choix au hasard de la couleur et de la valeur
              """
              # pour la couleur
              coul = choice(['carreau','coeur','pique','trefle'])   # choix au hasard d'un élément de la liste
              # ligne à rajouter pour modifier la couleur de la carte (utilisez le mutateur set_couleur())
          

      En utilisant le mutateur set_couleur(), compléter la dernière ligne de la méthode trier_hasard.

    4. On modélise le tirage aléatoire de la valeur par le tirage aléatoire d'un nombre entier entre 1 et 13 où :

      • le 1 correspond à l''As',

      • le 11 correspond au 'Valet',

      • le 12 correspond à la 'Dame',

      • le 13 correspond au 'Roi'.

      On simule le tirage aléatoire grâce à randint(1,13).
      Voici la suite de cette méthode trier_hasard (à ajouter en dessous des lignes précédentes) :

    5. 
              # pour la valeur
              n = randint(1,13)   # # tirage aléatoire de la valeur
              if n==1:
                  # ligne à rajouter pour modifier la valeur de la carte en 'As' (utilisez le mutateur set_valeur())
              elif n==11:
                  # poursuivre en traitant chaque cas
              

      Compléter la fin de la méthode trier_hasard.

  10. Utiliser cette méthode trier_hasard pour modifier carte_en_main. Après chaque nouveau lancer, découvrez la nouvelle valeur et la nouvelle couleur en utilisant les accesseurs,

  11. Modifier le code de la méthode trier_hasard afin de remplacer le traitement des différents par des if, elif et else par l'utilisation d'un dictionnaire.

  12. Libre à vous de développer davantage ce projet en rajoutant votre propres idées.

Prolongements

Ce prolongement sera repris dans le chapitre lp3 sur la modularité.

Pour l'instant deux classes ont été créées de manière indépendante : la classe Personnage et celle Outil. L'objectif est désormais de faire un lien entre ces deux classes.

Pour cela, nous allons utilisé ces classes comme un module simple utilisable par différents programmes, tout comme vous utilisiez des bibliothèques déjà construites à l'intérieur de programme. On parle alors de modularité.

En pratique, vous pouvez :

Pour lier les deux classes déjà construites, nous allons successivement :

  1. Construire la classe Outil à l'intérieur d'un fichier spécifique,

  2. Importer cette classe Outil dans un nouveau programme qui correspondra à la classe Personnage précédente modifiée.
    Ce programme correspondra à un nouveau fichier,

  3. Créer un programme principal qui importera la seule classe Personnage.
    Ce programme correspondra grosso modo au programme accessible à l'utilisateur.

Voici le détail de ce qui est à faire :

  1. Créez un fichier nommée outil.py qui contient le code de la classe Outil. Il vous suffit d'y mettre comme contenu le code obtenu à la fin de l'exercice 8 (cf. lien direct).

    1. Créez un nouveau fichier nommé personnage_avec_outil.py.

    2. Y mettre le contenu de la classe Personnage obtenu à la fin de l'exercice 9 (cf. lien direct).

    3. Comme quelques modifications sont nécessaires pour lier les deux classes, afin d'éviter les confusions, renommer la classe comme PersonnageAvecOutil.

    4. Rajouter en deuxième ligne le code suivant :

      
      from outil import *
                              

      Ce code permet d'importer les fonctions présentes dans le fichier outil.py, c'est-à-dire d'utiliser les méthodes de la classe Outil. Désormais, les deux classes sont liées.

    1. Créez un fichier main.py. Ce fichier sera le programme que l'utilisateur exécutera directement.

    2. Dans ce fichier main.py, coller le code suivant :

      
      # importation des fonctions présentes dans le fichier personnage_avec_outil.py, c'est-à-dire des méthodes de la classe PersonnageAvecOutil                          
      from personnage_avec_outil import * 
      
      # gestion de l'affichage de la saisie du genre par l'utilisateur
      genre = input("""
                  Saisir la lette correspondant au genre désiré pour votre personnage :
                      M : si vous voulez une héros de genre masculin,
                      F : si vous voulez une héroïne de genre féminin,
                      A : si vous désirez un personnage sans genre déterminé
                  """)
      
      genre = genre.upper()  # pour s'assurer que la lettre saisie est en majuscule
      
      # Création du nouveau personnage, appelé ici par défaut hero
      if genre=='F':
          hero = PersonnageAvecOutil('feminin')
      elif genre=='M':
          hero = PersonnageAvecOutil('masculin')
      elif genre=='A':
          hero = PersonnageAvecOutil('autre')
      else :
          print("erreur de saisie dans le choix du genre")
      
      # Affichage d'une caractéristique du personnage créé :
      print("Votre personnage a comme niveau d'expérience {}.".format(hero.get_experience()))
                              

      Remarquez que la méthode get_experience() de la classe PersonnageAvecOutil est directement utilisable.
      L'utilisateur peut ainsi utiliser les méthodes sans savoir comment elles ont été écrites.

    3. En exécutant le programme de ce fichier, vous devez voir apparaître dans la console :

      
      >>> 
      Votre personnage a comme niveau d'expérience 0.
                                                          

Code de déblocage de la correction :

Voici une vidéo pour aider à la réalisation de l'exercice précédent ainsi que du suivant :

Maintenant que les deux classes sont liées, il est possible de modifier ou de créer des méthodes.

On veut désormais que tout personnage possède un objet, unique pour simplifier pour l'instant.
Pour cela, on considère que le personnage possède un nouvel attribut, nommé objet, qui correspond à l'outil en main.
On veut désormais que tout personnage nouvellement créé commence avec un seul outil : un simple bâton de marche, de masse 0.5 kg et que l'on peut tenir à une seule main.

  1. Pour cela, modifiez comme ci-dessous le script de la méthode __init__ de la classe PersonneAvecOutil du fichier personnage_avec_outil.py :

    
        def __init__(self,genre,experience=0):
            self.genre=genre
            self.__experience=experience
            self.objet = Outil(0,0.5)    # ligne à rajouter     
            

    Cette ligne rajoutée fait appel au constructeur de la classe Outil, constructeur importé grâce au code de la première ligne from outil import *.

  2. On désire maintenant obtenir un accesseur pour ce nouvel attribut objet. On veut qu'il nous renvoie la masse et le nombre de mains nécessaires à son utilisation.
    Pour le créer dans la classe PersonneAvecOutil (donc dans le fichier fichier personnage_avec_outil.py), il suffit d'utiliser les méthodes déjà existantes dans la classe Outil.

    Le script suivant, qui permet d'obtenir un tel accesseur, est à copier en fin de fichier personnage_avec_outil.py :

    
        # méthode faisant appel à la classe Outil :
        def get_objet(self):
            """accesseur des caractéristiques masse et nombre de mains de l'objet"""
            masse = self.objet.get_masse()
            main = self.objet.get_main()
            return masse,main   
                        

    Notez bien que :

    • les méthodes get_masse() et get_main() sont celles de la classe Outil importée.

    • elles s'appliquent sur l'instance self.objet qui correspond à l'attribut objet du personnage courant (appelé avec le mot-clef self).

  3. On désire que lors de la création d'un nouveau personnage, s'affiche le nom de l'objet avec la valeur de ces attributs de masse et de nombre de mains nécessaires.

    Pour cela, il suffit de rajouter les deux lignes suivantes en fin du programme principal (du fichier main.py) :

    
    # Découverte des caractéristiques de l'objet en main du héros ou de l'héroïne :
    print("Vous commencez avec un bâton de marche de masse {} que vous pouvez tenir à {} main.".format(hero.get_objet()[0],hero.get_objet()[1]))
                    

    Notez bien que :

    • bien que la classe Outil ne soit pas directement importée dans la fichier main.py, on peut accéder aux attributs de l'outil.

    • cet accès se fait grâce à l'accesseur nouvellement créé, qui lui est importé de la classe PersonnageAvecOutil grâce à la ligne déjà présente : from personnage_avec_outil import *.

  4. Si vous exécutez ce programme main.py, vous verrez s'afficher dans la console :

    
    >>> 
    Votre personnage a comme niveau d'expérience 0. 
    Vous commencez avec un bâton de marche de masse 0.5 que vous pouvez tenir à 1 main.
                    

Code de déblocage de la correction :

Résumé de cette partie :

  1. Vous devez créer une nouvelle méthode, nommée decouverte dans la classe PersonnageAvecOutil qui modélise la découverte d'une nouvel objet par le joueur, objet dont le niveau requis, la masse et la nombre de mains sont donnés comme paramètres de cette méthode.
    Cette méthode conduira au remplacement de l'outil en main (celui de l'attribut objet) par le nouveau dans le seul cas où le personage possède un niveau d'exprérience suffisant pour cela.
    De plus, deux affichages différents sont attendus dans la console :

    • Nouvel objet s'il y a eu changement d'outil,

    • Dommage, il faut encore progresser en niveau sinon.

  2. Testez votre code en lançant le programme main.py puis en saisissant, par exemple, dans la console :

    
    >>> hero.decouverte(10,1.23,2)
                    

    Vous devez obtenir comme affichage :

    
    >>> hero.decouverte(10,1.23,2)
    Dommage, il faut encore progresser en niveau
                    

  3. Testez le cas de la découverte d'un objet que votre personnage peut posséder vu son niveau d'expérience.

  4. Vous pouvez vous amuser à rajouter d'autres méthodes (voire même des attributs) pour poursuivre le jeu.

    Vous pouvez avoir un personnage avec plusieurs outils possédés. Pour cela, il vous suffit de modifier ou rajouter des attributs de votre personnage et d'instancier autant de fois la classe Outil que le nombre d'outils que votre personnage peut avoir. Évidemment, vos aurez sûrement alors à modifier les méthodes liées à ces attributs.

Code de déblocage de la correction :

Retour sur les piles et files

Maintenant que vous maîtrisez la programmation objet, vous allez pouvoir implémenter ces deux notions de piles et de files à l'aide de ce paradigme de programmation.

Dans cet exercice, vous allez créer progressivement une implémentation de la notion de pile accompagnée de son interface vue au chapitre précédent sous forme de méthode s'appliquant à un objet pile.
La notion de liste Python sera utilisée pour créer la classe Pile.

  1. Voici ci-dessous un début de code, mais erroné, pour cette classe Pile.
    Corriger le code proposé afin que le constructeur permette de créer un objet pile, vide par défaut, ou dont le contenu est imposé.

    class Pile:
        def __init__(self,valeurs=[]):
            return self.contenu = valeurs
  2. Pour faciliter les tests par simple affichage, insérer la méthode __str__ suivante dans la classe en cours de création :

        def __str__(self):
            """permet l'affichage des valeurs de la pile
            les unes au-dessus des autres, la dernière étant au sommet"""
            l = self.contenu
            l.reverse()
            ch =""
            for valeur in l:
                ch = ch +"\n" + str(valeur)
            return ch

    Tester le constructeur déjà codé.

  3. Créer la méthode est_vide qui renvoie True si la pile est vide, False sinon

    Tester cette méthode.

  4. Créer la méthode empiler qui prend en paramètre un entier elt et qui place cet élément au sommet de la pile.

    Tester cette méthode.

  5. Créer la méthode depiler qui supprime l'élément placé au sommet de la pile sous peu qu'elle soit non vide et qui renvoie l'élément dépilé.

    Utiliser une précondition.

    Tester cette méthode.

Code de déblocage de la correction :

Nous allons rajouter d'autres méthodes à la classe Pile définie à l'exercice précédent.

  1. Créer l'accesseur sommet qui renvoie la valeur du sommet de la pile, sous peu que celle-ci soit non vide, sans la retirer.

  2. Créer la méthode hauteur qui renvoie le nombre d'éléments de la pile sur laquelle s'applique cette méthode.

  3. Créer la méthode vider qui vide la pile sur laquelle s'applique cette méthode.

Code de déblocage de la correction :

Dans cet exercice, vous allez créer progressivement une implémentation de la notion de file accompagnée de son interface vue au chapitre précédent sous forme de méthode s'appliquant à un objet file.
La notion de liste Python sera utilisée pour gérer le corps de la file.

Lorsque nous aurons vu comme structures de données les listes chaînées, nous pourrons améliorer la classe créée dans cette exercice, en particulier au niveau du coût de la méthode defiler.

  1. Voici ci-dessous le début de code pour cette classe File.

    class File:
        def __init__(self,tete=None,queue=None,corps=[]):
            self.tete = tete
            self.corps = corps
            self.queue = queue
    
        def __str__(self):
            """permet l'affichage des valeurs de la file
            les unes à côté des autres, la tête apparaissant en premier,
            la queue en dernier"""
            ch =""
            if self.tete != None:
                ch = str(self.tete)
            if self.corps != []:
                for elt in self.corps :
                    ch = ch +" | "+str(elt)
            if self.queue != None:
                ch =  ch +" | "+str(self.queue)
            return ch
    

    Pour permettre l'affichage du contenu de la file, insérer la méthode __str__ a été modifiée.

    1. Quels sont les attributs de la classe File ?

    2. Quel est le type de l'attribut corps ?

  2. Créer la méthode est_vide qui renvoie True si la file est vide, False sinon

    Tester cette méthode.

  3. Créer la méthode enfiler qui prend en paramètre un entier elt et qui place cet élément à la queue de la file.

    Tester cette méthode.

  4. Créer la méthode defiler qui supprime l'élément en tête de la file sous peu qu'elle soit non vide et qui renvoie l'élément défilé.

    Utiliser une précondition.

    Tester cette méthode.

  5. Créer un accesseur get_tete qui renvoie l'élément en tête de la file, sans le supprimer.

  6. Créer une méthode longueur qui renvoie la taille de la file.

Code de déblocage de la correction :

L'implémentation réalisée sur les files à l'exercice précédent n'est qu'une implémentation parmi d'autres.
On poyrait aussi, entre autres :

  1. utiliser une liste chaînée,

  2. la classe Pile créé lors de cet exercice pour implémentée une file comme le couple de deux piles entree et sortie comme vu lors de cet exercice du chapitre précédent.

Sitographie

Voici une liste de sites traitant de la programmation orientée objet :

Voici une video sur le site lumni qui traite de la programmation objet : programmer-avec-des-objets

Savoir faire et Savoir

Licence Creative Commons
Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International