Programmation Orientée Objet

La programmation orientée objet (POO) est un paradigme de programmation informatique. Il consiste en la définition et l’interaction de briques logicielles appelées objets ; un objet représente un concept, une idée ou toute entité du monde physique,.

Exemples : une voiture, une personne, une page d’un livre…

L’objet possède en interne une structure et un comportement, et il sait interagir avec ses pairs.

Il s’agit donc de représenter ces objets et leurs relations ; l’interaction entre les objets via leurs relations permet de concevoir et réaliser les fonctionnalités attendues, de mieux résoudre des problèmes. Dès lors, l’étape de modélisation revêt une importance majeure et nécessaire pour la POO. C’est elle qui permet de transcrire les éléments du réel sous forme virtuelle.

source : Wikipédia

L’objet et la classe

Un objet est un élément d’une classe (en quelque sorte un « type personnalisé » ; il faut entendre type au même titre qu’un nombre, une chaîne de caractères, …).

Définir une classe revient à définir une nouvelle structure de données, qui s’ajoute à celles définies par le langage.

 

Définition de classe

Avant de créer un objet, il faut avoir défini sa classe.

Une classe possède un nom et des membres, c’est à dire des attributs (ou champs) et des méthodes.

Chaque  membre nommé membre d’un objet objet est accessible via l’expression : objet.membre.

  • Les attributs (ou champs) : ils sont à l’objet ce que les variables sont à un programme.

les attributs sont donc typés (exemple int, float, bool, str, … ou n’importe quel autre classe !)

  • Les méthodes sont des procédures ou fonctions destinées à traiter les données. Elles servent d’interface entre les données et le programme.

les méthodes acceptent donc des arguments et peuvent renvoyer des valeurs

Le fait de réunir dans un même objet les attributs et les méthodes se nomme l’encapsulation. Cela permet de cacher à l’utilisateur d’un objet certaines données ou procédures internes.

Remarque : en Python, tout est objet, même les modules. Par exemple le module math est un objet comprenant l’attributAttribut Un attribut est un identifiant (un nom) décrivant une information stockée dans une base. Les attributs correspondent aux colonnes si la relation à laquelle il appartient est représentée sous forme de table. pi , la méthode sqrt() , …

 

 

En Python, on définit une classe grâce à l’instruction class  :

Le bloc de définition d’une classe contient :

  • des attributs de classe (voir plus bas …)
  • des méthodes :
    • des méthodes spéciales (leurs noms, réservés par le langage Python, commence et finit par « __ » : deux tirets « bas »)
    • des méthodes personnalisées

 

Instanciation d’objet

Une fois la classe définie, on peut créer autant d’objets de cette classe (on parle d’instances) que l’on veut :

L’opération qui permet de créer l’objet s’appelle la construction.

A chaque construction d’un objet, la méthode __init__()  de la classe est exécutée.

Cette méthode permet en générale de définir les différents attributs de l’objet :

… et la construction de l’objet permet de leur attribuer des valeurs :

 

 

Attributs de la classe / Attributs de classe

Chaque objet peut contenir ses propres valeurs d’attributs, ce  sont les attributs de la classe.

Mais on peut également attribuer des attributs à la classe elle-même, de sorte que tous les objets de cette classe puissent les utiliser. On parle d’attribut de classe ( static en Java ou en C++), et en Python, on les définit au niveau du bloc de définition de la classe :

Accès à  un attribut de classe :

Accès à un attribut d’un objet :

 

 

 

Un peu de géométrie dans l’espace

Le point

Soit \(M\) un point de l’espace et de coordonnées cartésiennes \(x_M\), \(y_M\) et \(z_M\) dans un repère \(\mathrm{R}\left(O, \vec{x}, \vec{y}, \vec{z}\right)\).

On peut considérer le point comme un objet géométrique, possédant 3 attributs : ses coordonnées dans \(\mathrm{R}\).

 

Définition de classe

en Python :

Remarque : self désigne l’objet lui même. On utilise ce terme dans tout ce qui est défini à l’intérieur de la classe (arguments et méthodes) pour éviter les ambiguïtés lorsque l’on s’intéresse aux membres de l’objet ( self.x = « c’est mon x »).

Si on souhaite que la fonction print() affiche des informations plus explicites sur le point, on peut déclarer, à l’intérieur de la déclaration de classe, la méthode __repr__() (il s’agit d’un nom réservé, d’où les deux caractères « _ ») :
Ce qui aura pour conséquence le comportement suivant :

Remarque : toutes les méthodes ou attributs commençant par « __ » (deux tirets-bas) sont privés, c’est à dire qu’ils ne peuvent être utilisés que depuis l’intérieur même de l’objet.

On peut créer ses propres membres privés (en plus des noms déjà réservés) pour mieux contrôler la modification des données de l’objet.

 Écrire une fonction distance(P1, P2) admettant 2 objets Points comme arguments et renvoyant la valeur de la distance entre ces deux points.

 

 

Le vecteur

De même que pour le point, on peut définir un vecteur par ses 3 coordonnées dans le repère \(\mathrm{R}\).

Définition de classe Python :

Parmi les noms de méthodes spéciales (elles sont toutes ), il en existe une permettant d’utiliser le symbole « + » pour faire une somme de deux objets de même type : la méthode __add__().

 

Écrire la méthode __add__(self, v) , acceptant comme argument le vecteur lui-même ( self) et un autre vecteur v , et en renvoyant le vecteur somme.

Le résultat doit permettre de faire ça (après avoir implémenté une méthode __repr__() comme pour le point) :

 

Faire de même avec les opérateurs suivants :
nom de la méthode expression Python écriture mathématique
différence : __sub__() : u - v \(\vec{u}-\vec{v}\)
norme : __abs__() : abs(u) \(\|\vec{u}\|\)
négation : __neg__() : -u \(-\vec{u}\)
produit par un scalaire : __mul__() : k*u \(k\times\vec{u}\)
(dans ce dernier cas, les arguments étant de types différents, il faut aussi définir la fonction « réfléchie » __rmul__() , pour pouvoir faire k*u et u*k )
Implémenter deux méthodes prod_scal(self, u) et prod_vect(self, u) réalisant les produits scalaires et vectoriels.

 

Droite

Il existe plusieurs manières de définir une droite : Point+Vecteur, deux Points, …

Créer une classe Droite() , dont le constructeur peut admettre différents types d’arguments (pourvu que ceux-ci puissent permettre la définition univoque de l’objet).

Pour tester si un objet est une instance d’une classe donnée, on peut utiliser la fonction isinstance(objet, nom_de_la_classe) , qui renvoie alors True ou False .

 

Pour passer à une fonction des arguments de nombre ou de type non prédéterminés, on peut utiliser l’opérateur « * » :

  • l’argument *args dans la définition de la fonction va récupérer tous les arguments donnés lors de l’appel de la fonction dans un tuple nommé args .

(exemple : def mafct(*args)mafct("a", 2)args = ("a", 2) )

  • l’argument **kargs dans la définition de la fonction va récupérer tous les arguments donnés lors de l’appel de la fonction dans un dictionnaire nommé kargs .

(exemple : def mafct(**kargs)mafct(k="z", p=3)kargs = {'k': "z", 'p': 3} )

  • et on peut combiner les deux :

(exemple : def mafct(*args, **kargs)mafct("a", p="3")

args = ("a",) et kargs = {p : "3"} )

 

Améliorer la fonction distance() pour qu’elle admette également un Point et une Droite comme arguments, et en calcule la distance relative !
Plus dur : étendre les possibilités de la fonction distance() au calcul de la distance entre deux droites…

 

Sources :

Vous aimerez aussi...

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*

code