Programmation OO et encapsulation¶

1 - Encapsulation¶

Un problème de la programmation impérative (utilisation de variables globales) est que toutes les parties d'un programme dépendent potentiellement des autres. On parle de "programmation spaghetti".

Cela augmente considérablement la complexité d'un gros programme, rendant difficile de le maintenir et de le modifier sans introduire de régressions.

Cela rend aussi difficile le travail en équipe, chacun devant avoir conscience du fonctionnement du programme entier.

Une réponse possible a ces problèmatiques est l'encapsulation des données : le programme est divisée en plusieurs parties, qui chacune a un accès exclusif à ses données (variables).

Python propose plusieurs solutions pour encapsuler les données :

• l'utilisation des modules : c'est la programmation modulaire;
• la programmation orientée objet.

2 - Interface et implémentation¶

Quand un programme est divisé en plusieurs parties qui chacunes encapsulent leurs données, ces parties communiquent ensemble via des fonctions.

La spécification des ces fonctions constitue l'interface de la partie (classe ou module).

Le code à l'intérieur de chaque partie est l'implémentation de l'interface. Ce code est complètement indépendant du code des autres parties.

Par exemple, l'interface de la classe Vecteur est constituée de :

class Vecteur:

    def __init__(self, x, y):
        """
        Construit un vecteur de coordonnées (x, y).
        :param x: (float) l'abscisse du vecteur
        :param y: (float) l'ordonnée du vecteur
        :return: (Vecteur object)
        """
        pass
        
    def norme(self):
        """
        Renvoie la norme du vecteur self
        :return: (float) la norme du vecteur self
        """
        pass
    
    def multiplie(self, k):
        """
        Multiplie le vecteur self par le scalaire k
        :param k: (float)
        """
        pass

Le code à l'intérieur de ces fonctions constitue l'implémentation de la classe Vecteur.

3 - Attributs privés¶

Une attribut privé est un attribut d'une classe auquel seules les méthodes de cette classe ont accès.

En Python, un attribut privé a un nom qui commence par _ (c'est une convention, le language n'empêche pas l'accès).

Si un accès en lecture d'un attribut privé est nécessaire de l'extérieur de la classe, on rajoute à l'interface une méthode (getter) qui renvoie la valeur de la variable.

De la même façon, une méthode (setter) peut modifier la valeur d'une variable privée.

Une classe doit avoir un maximum d'attributs privés (de préférence tous).

Par exemple, la classe Vecteur devient :

4 - Objets et références¶

Comme les listes, les objets sont passés par référence dans les fonctions. Ainsi, si une fonction modifie un objet reçu en argument, les modifications persistent en dehors de la fonction.

Par exemple, la fonction suivante annule un vecteur :

On peut constater que le vecteur v est passé par référence :

5 - Exercices sur les vecteurs¶

a - Somme¶

Rajouter à la classe Vecteur une méthode add qui prend en argument un vecteur u et l'ajoute à self.

b - Produit scalaire¶

Rajouter à la classe Vecteur une méthode scalaire qui prend en argument en vecteur u et renvoie le produit scalaire des vecteurs u et self.

c - Déterminant¶

Rajouter à la classe Vecteur une méthode det qui prend en argument en vecteur u et renvoie le déterminant des vecteurs u et self.

Le déterminant de deux vecteurs $\vec{u}(x, y)$ et $\vec{v}(x', y')$ est :

$$ \det(\,\vec{u}, \vec{v}\,) = xy' - x'y $$

6 - Exercice sur les points¶

Implémenter la classe Point dont voici l'interface :

class Point:

    def __init__(self, x, y):
        """
        Contruit un point de coordonnées (x, y)
        :param x: (float) Abscisse du point self
        :param y: (float) Ordonnée du point self
        """
        pass
    
    def get_coordonnees(self):
        """
        Renvoie les coordonnées du point self
        :return: (tuple)
        """
        pass
    
    def distance(self, m):
        """
        Renvoie la distance entre les points self et m
        :param m: (objet Point)
        :return: (float)
        """
        pass
   
    def translate(self, v):
        """
        Applique au point self la translation de vecteur v
        :param v: (objet Vecteur)
        """
        pass
        
    def dup(self):
        """
        Duplique le point self
        :return: (objet Point) un point ayant les même coordonnées que self
        """
        pass
        
    def vect(self, m):
        """
        Renvoie le vecteur qui translate le point self sur le point m
        :param m: (objet Point)
        :return: (objet Vecteur)
        """
        pass

7 - Exercice : polygônes¶

Il s'agit dans cette partie de programmer une classe Polygone, qui satisfait les contraintes suivantes :

• les sommets seront représentés par des objets Point;
• une méthode permet de rajouter un sommet;
• une méthode permet d'obtenir le nombre de sommet du polygône;
• une méthode permet d'obtenir les coordonnées du n-ième sommet;
• une méthode permet d'obtenir le périmètre du polygône;
• une méthode permet de translater l'intégralité du polygône d'un vecteur v;
• une méthode affiche le polygône (en vous inspirant du programme de la cellule suivante);
• une méthode indique si le polygône est convexe (c'est le cas si les déterminants de deux côtés (vecteur) successifs sont tous du même signe);
• une méthode calcule son aire.