Programmation orientée objet (POO)#

Le paradigme de programmation orientée objet est une forme de programmation basée sur des objets que l’on crée. Chaque objet est créé à partir d’un modèle. Ces objets sont des représentations de ce modèle.

Le modèle qui sert à la création d’un objet définit:

des attributs qui permettent de stocker des valeurs créant une structure de donnée;
des méthodes qui sont des fonctions qui permettent d’agir sur l’objet et ses attributs.

Objet en Python#

En python, un objet est défini par le mot clef class suivi du nom de l’objet et des 2 points.

Une classe est une structure de donnée qui permet de créer des objets.
Une classe permet de définir les attributs d’un objet et les méthodes qui lui sont propres.

class Nom_classe:
    # cette classe crée des objets de type Nom_classe

    pass

Avertissement

Tout ce qui est défini dans la classe doit être indenté.
Par convention, les noms de classe commencent par une majuscule.

Définition

La création d’un objet se fait par une affectation avec la classe définissant l’objet. On dit qu’on instancie un objet.

Exemple

Imaginons que l’on souhaite créer un objet en python représentant une voiture. On peut définir les attributs et les méthodes de notre objet comme suit:

Les attributs sont des caractéristiques ou des propriétés de la voiture: le nombre de roues, la marque, le modèle, le nombre de portes, la couleur, etc.
les méthodes représentent des fonctionnalités ou des actions: avancer, accélérer, démarrer, ralentir, etc.

Pour créer nos objets voitures, on définit la classe Automobile:

class Automobile:
    pass # instruction qui ne fait rien mais évite une erreur dans l'interpréteur

Dans l’interpréteur ou le notebook, on peut créer différentes voitures:

v_1 = Automobile()
v_2 = Automobile()

Indication

Les variables v_1 et v_2 sont 2 instances d’objets construites avec la classe Automobile. On fait souvent le raccourci que v_1 et v_2 sont deux objets de la classe Automobile.

Les attributs d’un objet#

Les attributs d’un objet permettent de stocker des valeurs pour notre objet. Ces attributs sont accessibles et peuvent être modifiés.

Pour créer des attributs, on définit un constructeur qui est une fonction appelée quand on instancie un nouvel objet. Ce constructeur est la fonction __init__ contenant le paramètre obligatoire self .

class Objet:

    # Constructeur
    def __init__(self):
        self.attribut_1 = valeur_1
        self.attribut_2 = valeur_2
        ...
        self.attribut_n = valeur_n

Note

On peut définir autant d’attributs qu’on le souhaite;
Tous les objets créés ont les mêmes attributs ce qui rend la structure plus cohérente;
Un objet définit une structure de données.

Exemple

En reprenant notre classe Automobile, on peut donc y ajouter le constructeur définissant le modèle et le nombre de portes.

class Automobile:
    # classe Automobile pour construire des objets de type Automobile

    def __init__(self):        
        # constructeur de l'objet

        self.modele = "clio"
        self.nombre_portes = 3

>>> v=Automobile() # on instancie un objet v
>>> v.modele
'clio'
>>> v.nombre_portes
3

On remarque tout de suite un problème. Chaque nouvel objet créé est toujours de modèle clio et a 3 portes. Cela implique de modifier les valeurs des attributs après la création pour un modèle différent!

Pour éviter cela, le constructeur étant une fonction, on ajoute des paramètres. Les paramètres sont alors associés aux attributs de l’objet:

class Objet:

    # Constructeur
    def __init__(self,parametre_1,parametre_2,...,parametre_n):
        self.attribut_1 = parametre_1
        self.attribut_2 = parametre_2
        ...
        self.attribut_n = parametre_n

Exemple

En reprenant notre classe Automobile, on peut ajouter les paramètres pour le modèle et le le nombre de portes.

class Automobile:
    # classe Automobile pour construire des objets de type Automobile

    def __init__(self,nom,n):
        # constructeur de l'objet avec paramètres

        self.modele = nom
        self.nombre_portes = n

>>> v_1=Automobile('clio',3)
>>> v_2=Automobile('golf',5)
>>> v_1.modele
'clio'
>>> v_2.modele
'golf'

Les méthodes d’un objet#

Les méthodes sont des fonctions propres aux objets, ce qui implique que la fonction ne peut être appliquée qu’à l’objet. Comme l’attribut, la méthode est appelée en utilisant la notation pointée : objet.méthode().

Méthode en python

En python, une méthode d’objet est définie dans la classe. Pour faire référence à l’objet, nous devons utiliser le mot clé self qui désigne l’objet. Ce mot clé self est passé en paramètre.

class Objet:

    # Constructeur
    def __init__(self,parametre_1,parametre_2,...,parametre_n):
        self.attribut_1 = parametre_1
        self.attribut_2 = parametre_2
        ...
        self.attribut_n = parametre_n

    # Méthode
    def ma_methode(self):
        # modifier un attribut
        self.attribut_1 = self.attribut_1 + 1

        # afficher un attribut
        print(self.attribut_2)

        # renvoie d'une valeur
        return self.attribut_3, self.attribut_4

Exemple

Reprenons l’exemple de la classe Automobile et créons une méthode pour savoir si la voiture avance. Pour cela, on ajoute un attribut vitesse initialisé avec la valeur 0.

class Automobile:
    # classe Automobile pour construire des objets de type Automobile

    def __init__(self,nom,n):
        # constructeur de l'objet avec paramètres

        self.modele = nom
        self.nombre_portes = n
        # v est la vitesse initiale égale à 0
        self.vitesse = 0 

    # méthode de l'objet
    def avancer(self):
        if self.vitesse > 0:
            return True
        else:
            return False

On crée un objet v_1 et on applique la méthode avance:

>>> v_1 = Automobile("clio",3)
>>> v_1.avance()
False

On modifie la vitesse et on applique la méthode avance:
```
>>> v_1.vitesse = 50
>>> v_1.avance()
True
```

Note

Une classe peut contenir de nombreuses méthodes. Ces méthodes sont des fonctions propres aux objets. Elles ne peuvent être appelées que par les objets créés par la classe contenant les méthodes.

Méthode avec paramètres

Une méthode est une fonction, donc on peut ajouter des paramètres à celle-ci.

class Objet:

    # constructeur
    def __init__(self):
        ...

    # Méthode
    def ma_methode_avec_parametres(self,p1,p2):

        self.attribut_1 = self.attribut_1 + p1
        if p2 <= 0:
            self.attribut_2 = 0
        else:
            self.attribut_2 = self.attribut_2 * p2

Exemple

Dans la classe Automobile, on crée une méthode ralentir qui diminue la vitesse de la voiture d’une valeur donnée en paramètre.

class automobile:
    # classe Automobile pour construire des objets de type Automobile

    def __init__(self,nom,n):
        # constructeur de l'objet avec paramètres

        self.modele = nom
        self.nombre_portes = n
        # v est la vitesse initiale égale à 0
        self.vitesse = 0 

    # méthode de l'objet
    def avancer(self):
        if self.vitesse > 0:
            return True
        else:
            return False
        
    def ralentir(self,v):
        if self.vitesse >= v:
            self.vitesse = self.vitesse - v
        else:
            self.vitesse = 0

On crée un objet v_1 et on applique la méthode avance:

>>> v_1 = Automobile("clio",3)
>>> v_1.avance()
False

On modifie la vitesse et on applique la méthode avance:
```
>>> v_1.vitesse = 50
>>> v_1.avance()
True
```
On diminue la vitesse en appliquant la méthode ralentir:
```
>>> v_1.ralentir(20)
>>> print(v_1.vitesse)
30
```

Programmation orientée objet (POO)

Contenu

Programmation orientée objet (POO)#

Objet en Python#

Les attributs d’un objet#

Les méthodes d’un objet#