Langage et programmation _ Programmation Orientée Objet

I. Première approche de la programmation orientée objet (POO)

Jusqu’à maintenant, l’élaboration d’un programme consiste à définir des variables en utilisant les types
prédéfinis en python (int, float, dict, string, liste), puis à définir des fonctions qui vont changer l’état de
ces variables.

On parle de programmation procédurale.

Pourquoi ne pas rajouter d’autres types de variables ?

Par exemple, une liste en Python possède des instructions propres :

Longueur de la liste, accès à un élément de la liste, etc.

Comme les listes, il serait intéressant de pouvoir définir une variable de type Arbre, qui nous permettrait
d’accéder rapidement à certaines propriétés : taille, hauteur, profondeur, ….

En Python, c’est possible car c’est un langage qui permet la programmation orientée objet.

La POO est un paradigme de programmation, au même titre que la programmation impérative (que nous
pratiquons déjà) ou la programmation fonctionnelle (qui sera étudiée cette année en Terminale).
Un paradigme de programmation pourrait se définir comme une philosophie dans la manière de
programmer : c'est un parti-pris revendiqué dans la manière d'aborder le problème à résoudre. Une fois
cette décision prise, des outils spécifiques au paradigme choisi sont utilisés.

Imaginons 3 menuisiers qui ont pour mission de fabriquer chacun un meuble.

Le premier pourra décider d'utiliser du collé-pointé : il assemblera les morceaux de bois en les collant
puis utilisera des pointes. Ses outils seront le marteau et le pistolet à colle.
Le deuxième pourra décider de visser les morceaux de bois entre eux : son outil principal sera une
visseuse.
Le troisième pourra décider de faire de l'assemblage par tenons et mortaises : son outil principal sera une
défonceuse.
Pour la réalisation de sa mission, chaque menuisier utilise un paradigme différent. Qui utilise la meilleure
méthode ? Cette question n'a pas vraiment de réponse : certaines méthodes sont plus rapides que d'autres,
d'autres plus robustes, d'autres plus esthétiques...
Et pourquoi ne pas mélanger les paradigmes ? Rien n'interdit d'utiliser des pointes ET des vis dans la
fabrication d'un meuble.

La Programmation Orientée Objet sera (surtout à notre niveau) mélangée avec de la programmation
impérative, de la programmation fonctionnelle... d'ailleurs vous avez déjà manipulé des objets sans le
savoir, en leur appliquant des fonctions qui leur était propres :

Exemple 1 : les listes en 1ère

>>> ma_liste = [12, 24, 28] #création d'un objet (instance) de la classe list

>>> type(ma_liste)
<class 'list'>

>>> ma_liste.append(31) #méthode append appliquée à l'instance ma_liste

>>> ma_liste
[12, 24, 28, 31]
On peut créer un nouveau type avec le mot clé class

De la même manière que le mot clé def permet de créer une fonction et de l’affecter à une variable, le mot
clé class permet de créer un type (une classe) et de l’affecter à une variable.

Une classe est un modèle qui permet de créer des objets de ce type.

• Les objets de cette classe sont appelés instances.

• Les variables propres à chaque élément de cette classe sont appelés attributs.
• Les fonctions propres à chaque élément de cette classe sont appelées méthodes.

L’ensemble des méthodes accessibles à un utilisateur définit l’interface de la classe.

Charger le fichier python cours_complement.py

Exemple 2 : Création d'une classe Rectangle.

class Rectangle: # permet de créer des objets de type Rectangle

def __init__(self, longueur, largeur):
self.longueur = longueur
self.largeur = largeur

Commentaires :

Lors de la création de la classe, on ne connait pas à l’avance le nom des objets qui seront créés. D’où la
nécessité de représenter le futur objet créé à l’aide d’un mot-clé self.

Le constructeur __init__ permet de définir des attributs aux futurs objets créés ainsi que de leur affecter
les valeurs désirées.

Pour créer une instance d’une classe, on fait suivre le nom de la classe de la liste des arguments attendus
par __init__ :

rectangle1 = Rectangle(6, 4) # création de rectangle1, un objet de type Rectangle dont

# les attributs longueur et largeurs sont égaux à 6 et 4

Le code présent dans le constructeur est exécuté et le mot-clé self dans le constructeur représente
l’instance de la classe en cours de création. On peut ensuite vérifier que notre instance de classe possède
bien les deux attributs.

Entrer dans la console et compléter :

>>> rectangle1.longueur
………
>>> rectangle1.largeur
………

Mais cette façon de faire est à éviter. On verra plus tard pourquoi et comment faire pour accéder aux
attributs.

Les méthodes sont définies à la suite, dans la création de la classe :

def calcule_aire(self):
return self.longueur * self.largeur
Dans la définition d’une méthode, le premier argument, appelé self par convention, représente l’objet sur
lequel la méthode est appliquée. Voici un exemple à l’aide de la console, où l’on retrouve les usages des
méthodes rencontrées en première sur les listes :

Entrer dans la console et compléter :

>>> rectangle1.calcule_aire()
………

À ce stade, un élément n’a pas été évoqué : qu’en est-il de la modification de la valeur d’un attribut d’une
instance de la classe ?
En Python, il est tout à fait possible de modifier directement un attribut, par exemple :

>>> rectangle1.longueur = 10

Ceci dit, notamment pour des raisons de « sécurité » du code, cette pratique est déconseillée.

A vous de jouer : Compléter la classe Rectangle en ajoutant une méthode calcule_perimetre

……………………………………………………………………………………………………………….
……………………………………………………………………………………………………………….
……………………………………………………………………………………………………………….
……………………………………………………………………………………………………………….

Exemple 3 : Création de deux classes.

class Chien :
def __init__(self, nom, age, race):
self.nom = nom
self.age = age
self.race = race

class Personne :
def __init__(self, prenom, nom, age, chien):
self.prenom = prenom
self.nom = nom
self.age = age
self.chien = chien

1. Créer une instance chien1 de la classe Chien dont le nom est Médor, agé de 2 ans, et de race berger
allemand.
2. Créer une instance chien2 de la classe Chien dont le nom est Brutus, agé de 4 ans, et de race
Chihuahua.
3. Créer une instance personne1 de la classe Personne qui s'appelle Chris Smith âgé de 42 ans, et qui est
le maître de chien1.
……………………………………………………………………………………………………………….
……………………………………………………………………………………………………………….
……………………………………………………………………………………………………………….
……………………………………………………………………………………………………………….
……………………………………………………………………………………………………………….
Remarque importante : dans la question 3, l'intérêt d’utiliser l'attribut chien1, référençant une instance
de la classe Chien, plutôt que la chaine de caractères 'Medor' permet de conserver toutes les informations
sur chien1 qu'on dispose :

Entrer dans la console et compléter :

>>>personne1.chien.race
…………………

Exemple 4 : classe Combattant

Commentaires sur le code :

Attention ! Python n'impose pas le nom self ce n'est qu'un usage ! Cependant, JE vous l'impose. Si vous
écrivez autre chose que self, personne ne comprendra, et vous aurez 0 à l'exercice.

Application : Utilisation de la classe :

Dans la console :

1. Créer guerrier, une instance de la classe Combattant ayant 10 points de vie et 8 points d'attaque.
>>>…………………………….
2. Créer magicien, une instance de la classe Combattant ayant 5 points de vie et 4 points d'attaque.
>>>…………………………….
3. Vérifier la valeur des attributs des 2 instances créées.
>>>…………………………….
4. magicien attaque guerrier avec la méthode attaquer.
>>>…………………………….
5. Vérifier que la valeur de l'attributs vie de guerrier a été modifiée.
>>>…………………………….
>>>…………………………….
6. magicien attaque à nouveau guerrier avec la méthode attaquer.
>>>…………………………….
7. Vérifier que la valeur de l'attributs vie de guerrier est égale à 0 et que celui de vivant renvoie False.
>>>…………………………….

Dans la suite de ce cours, nous allons introduire peu à peu les bonnes pratiques de programmation. Par
exemple :

Ou même :

Ce qui n'est pas cohérent et qui va générer des erreurs par la suite !

Interface de la POO :

Certaines méthodes sont internes à la classe, on parle de méthodes privées.

Exemple : __init__ est une méthode privée, on n'exécute pas __init__ directement.

D'autres méthodes sont publiques, comme attaquer ou perdre_vie.

L'interface d'une classe est définie par les méthodes qui sont publiques, par les méthodes qui sont
exposées.

Or, les attributs doivent tous être privés et ne servir que pour définir les méthodes.

Lorsqu'on code guerrier.vie , on accède directement aux attributs et c'est une mauvaise pratique.

Si on veut accéder ou modifier un attribut, il faudra donc créer une méthode qui le fasse.
On parle de getter (to get en anglais, obtenir, accéder) et de setter (to set en anglais, modifier).
Exemple 5 : classe Voiture

>>> V1=Voiture('rouge','renault')
>>> V1.get_couleur()
'rouge'
>>> V1.set_couleur('bleu')
>>> V1.get_couleur()
'bleu'

Méthodes spéciales

Elles permettent de définir des opérateurs et de donner des propriétés aux objets.

Exemple : la méthode __repr__

>>> V1=Voiture('rouge','renault')

On définit la méthode __repr__ pour obtenir une représentation plus explicite de l'instance :
Exemple 6 : Vecteur, pour illustrer la méthode __add__

Utilisation :
Premiers exercices pour la maison :

Ex 1 :
1. Écrire une classe Eleve qui contiendra les attributs nom, classe et note.
2. Instancier trois élèves de cette classe.
3. Compléter la classe Eleve par une méthode compare(eleve1, eleve2) qui renvoie le nom de
l'élève ayant la meilleure note.

Ex 2 :
1. Écrire une classe TriangleRect qui contiendra les attributs cote1, cote2, qui sont les longueurs des 2
côtés de l’angle droit d’un triangle rectangle.
2. Compléter la classe TriangleRect par une méthode hypotenuse qui retourne la longueur de
l’hypoténuse.
3. Instancier un rectangle de la classe TriangleRect de côté 3 et 4 et vérifier que la méthode
hypotenuse appliquée à ce rectangle retourne 5.