• Un chien domestique quelconque peut être vu comme un représentant de l'espèce Canis lupus familiaris.
• Médor, Fido ou Pupuce, sont des représentants de cette espèce Canis lupus familiaris.
• De plus, les chiens domestiques diffèrent les uns des autres : il existe des éléments variables entre eux qui permettent de les caractériser.
  Par exemple : la race, l'âge, la taille, la masse, la couleur du pelage, la longueur du pelage, un propriétaire, ...
• Sur chaque chien, on peut appliquer plusieurs actions : vacciner, tatouer, tondre, ...

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

• Cette espèce Canis lupus familiaris peut être appelée classe.
• N'importe quel chien, par exemple Médor, Fido ou Pupuce, sont des représentants de cette espèce Canis lupus familiaris : ils peuvent être appelés objets de cette classe. (Attention ! Le mot objet est un terme spécifique à l'informatique, il n'y a pas ici de chosification d'un animal !)
• Les caractéristiques variables peuvent être appellées attributs d'un chien.
• Enfin, il est possible de connaître ou de modifier certains de ces caractéristiques (=attributs ). Par exemple :
  • "tatouer" permet de retrouver le propriétaire d'un chien : c'est un attribut d'un chien domestique.
  • "tondre" revient à modifier l'attribut "longueur du pelage".

  Ces actions possibles sur n'importe quel représentant de la classe seront appelées méthodes.

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 :

Vous aviez vu comme exemple de pile :

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 :

• vide()

• est_vide(P)

• empiler(a,P)

• depiler(P)

• ...

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.

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.

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

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

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

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)

        

Il vous suffit donc de saisir :

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

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

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

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

• attrib1 et attrib2 sont deux attributs publics.
• __attrib3 et __attrib4 sont deux attributs privés.

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

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

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