NSI - Terminale - Programmation Orientée Objet
Le Paradigme objet
Cliquez sur le lien du chapitre de cours à consulter:
le paradigme objet
La programmation orienté objet (POO) est un paradigme (une façon de voir) de programmation qui consiste à imaginer un programme comme un assemblage de briques logicielles appelées des objets. Python est un langage qui utilise ce paradigme et d'autres.
Un objet logiciel est un élément quelconque du programme qui peut être concret comme un menu, un bouton, une fenêtre, une donnée de type simple ( nombre, caractère, chaîne de caractères) , une donnée de type construit ( liste, tuple, ensemble); un objet peut aussi représenter quelque chose d'abstrait comme une émotion, un rêve, etc... En python, tout ce que l’on peut associer par affectation à une variable avec l’opérateur (=) est un objet.
Un Objet a des propriétés qui le décrivent. Par exemple, un objet fenêtre possède des attributs pour stocker sa largeur, sa hauteur, son titre, etc.. Les valeurs des propriétés sont associées à des variables propres à l’objet que l’on appelle les attributs de l’objet.
Un objet possède aussi des méthodes qui permettent de le manipuler, une fenêtre a des méthodes pour être créée, déplacée, agrandie, etc. Les méthodes sont des fonctions associées aux objets.
la Classe
Le code qui décrit comment un objet est constitué s’appelle une classe, c’est le plan de montage de l’objet.
Pour créer l’objet, ce qui s’appelle créer une instance de la classe, on doit invoquer une méthode qui s’appelle un constructeur. En python il y a deux méthodes impliquées dans la construction _new _ (…) et _ init _(…).
- Comment créer sa propre classe ?
Imaginons une classe qui décrive une voiture. On doit utiliser le mot clé class suivi du nom de la classe suivi de deux points ( : ), par convention le nom d'une classe commence par une majuscule :
class Voiture:
''' la classe Voiture permet de construire des objets de type Voiture'''
On ajoute ensuite dans la classe les attributs (variables) et les méthodes (fonctions) nécessaires.
Exemple, une classe Voiture qui définit 5 attributs et une méthode:
Remarque: Création d'un objet Voiture
La création de l'objet assigné à la variable bagnole ressemble à une variable qui reçoit la valeur renvoyée par une fonction, selon le modèle: variable = Nom_classe(), exemple:
bagnole = Voiture()
Le nom d'une classe commence par lettre une majuscule.
ici on a défini class Voiture et pas class voiture (le nom d'une fonction qui s'appelerait voiture() commencerait par une lettre minuscule) .
le constructeur et les attributs
Le processus de création de l'objet en mémoire est complexe, il se déroule globalement en deux phases. A partir de la classe, on crée un objet (une instance de la classe) qui sera associé à une variable ( ici bagnole par exemple ):
bagnole = Voiture( )
Dans ce cas:
Phase1: création de l’objet en mémoire:
Python appelle implicitement ( sans notre intervention) la méthode _new _(..). Cette méthode est responsable de créer l’objet bagnole en mémoire avec ses attributs et ses méthodes. La méthode _new _(..) appartient à la classe object (dont hérite toutes les autres classes), on ne peut pas l'invoquer directement dans notre code pour créer un objet, c'est l'interpréteur python qui gère son appel.
Phase2: initialisation de l’objet:
Une fois l’objet créé en mémoire, la variable bagnole contient une référence vers l'objet Voiture en mémoire. Python appelle alors implicitement ( sans notre intervention) la méthode _init _(…).
La méthode _init _(...) est également une méthode de la classe object mais on peut en redéfinir une dans notre classe qui sera alors appelée à la place de celle de la classe object pour initialiser notre objet:
Voici une classe Voiture avec une méthode _init _ personnalisée, vous remarquerez que la ligne de création de l'objet devient différente de celle montrée ci_dessus:
# ***************************************************************** #
# DEFINITION #
# ***************************************************************** #
class Voiture:
'''la classe Voiture permet de construire des objets de type Voiture'''
def __init__ (self:object, coul:str, m:str, mod:str, t:float):
self.couleur = coul
self.marque = m
self.modele = mod
self.taille_reservoir = t
self.niveau_reservoir = t /2.0
# ***************************************************************** #
# UTILISATION #
# ***************************************************************** #
# création d'un objet Voiture qui utilise __ init__ de notre classe
bagnole = Voiture ("blanche", "Volkwagen", "Coccinelle", 55.0)
IMPORTANT: le mot clé self utilisé dans init représente l’objet Voiture créé, si on confond l'objet et la variable qui le réprésente on peut dire que self est l'objet bagnole.
IMPORTANT: les attributs de l’objet s’écrivent self.nom_attribut dans la définition de _ init _.
Les valeurs passées en arguments lors du code: Voiture ("blanche", "Volkwagen", "Coccinelle", 55.0), sont récupérées par _ init _ pour initialiser l'objet bagnole. Ainsi on aura:
self = bagnole, coul = "blanche", m = "Volkwagen", mod = "Coccinelle" et t = 55.0
Ce qui permet d'initialiser les attributs de l'objet bagnole:
bagnole.couleur = "blanche"
bagnole.marque = "Volkwagen"
bagnole.modele = "Coccinelle"
bagnole.taille_reservoir = 55.0
bagnole.niveau_reservoir = 27.5
les méthodes
Les méthodes sont des fonctions qui manipulent les objets. On en distingue deux sortes:
-
les méthodes d'instance qui sont propres à un objet ( elles donnent un résultat différent selon l'objet ), elles ont en premier argument le mot clé self pour définir à quel objet on les applique. La méthode _ init _ est un exemple de méthode d'instance mais elle est spéciale parce que vous ne pouvez pas l'appeler dans votre code
Ci-dessous vous avez aussi la méthode d'instance get_niveau_reservoir(self) qui va permettre de connaître de connaitre le niveau du réservoir d'un objet Voiture (le niveau du réservoir est propre à un objet voiture ) -
les méthodes de classe appartiennent à la classe et ne sont pas propres à un objet, elles n'ont le mot clé self en argument. Ci-dessous convertir_km_en_miles est une méthode de classe Voiture
# ***************************************************************** #
# DEFINITION #
# ***************************************************************** #
class Voiture:
'''la classe Voiture permet de construire des objets de type Voiture'''
# une méthode d'instance
def __init__ (self:object, coul:str, m:str, mod:str, t:float):
self.couleur = coul
self.marque = m
self.modele = mod
self.taille_reservoir = t
self.niveau_reservoir = t /2.0
# une autre méthode d'instance
def get_niveau_reservoir (self:object) -> float:
return self.niveau_reservoir
# une méthode de classe ( identique pour tous les objets => pas de self)
def convertir_km_en_miles(km:float) -> float:
return km * 0.621371
# ***************************************************************** #
# UTILISATION #
# ***************************************************************** #
# création d'objets Voiture qui utilisent __ init__ de notre classe
bagnole = Voiture ("blanche", "Volkwagen", "Coccinelle", 55.0)
la_clio = Voiture("rouge", "Renault", "Clio", 45.0)
# appel de la méthode d'instance get_niveau_reservoir() pour bagnole
# L'appel de la méthode d'instance se code: nom_objet.methode(arguments éventuels)
# on appelle la méthode avec le code: bagnole.get_niveau_reservoir()
# self = bagnole (lors de l'utilisation self n'est plus en argument dans les parenthèses)
# affichage niveau du réservoir pour l'objet bagnole
print(bagnole.get_niveau_reservoir())
# appel de la méthode de classe convertir_km_en_mile
# L'appel de la méthode de classe se code: nom_classe.methode(arguments éventuels)
# affichage du nombre de miles de 250 km
print( "250 km représente:", Voiture.convertir_km_en_mile(250), "miles" )