La programmation objet : trop classe !

Un nouveau paradigme de programmation

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 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 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.

On 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 :

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 horifié ! 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 :

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 liez 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.
                                                          

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.
                    

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 difé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.

Sitographie

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

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