Classes et objets

Un objet est un bout de code auquel est associé :

• des fonctionnalités (des méthodes) qui sont communes à tous les objets de sa classe
• des choses à lui tout seul (sa structure de donnée interne qui constitue ses attributs) qui lui permettent de se différentier des autres objets de sa classe même s'il a les mêmes fonctionnalités.

Un objet, n'est donc pas isolé, il partage ses fonctionnalités avec tous les objets de sa classe.

Créer ses propres classes

De façon générale, on peut définir un objet et une classe comme :

On crée une classe par rapport à un besoin que l'on veut satisfaire. Supposons que l'on veuille créer une classe compteur qui doit satisfaire les besoins suivant :

• créer un compteur de valeur initiale 0,
• pouvoir ajouter une unité à un compteur via une méthode,
• connaître la valeur du compteur.

Le code python suivant est correct et utilise une classe compteur qui satisfait nos besoins :

from compteur import Compteur

c1 = Compteur()
c2 = Compteur()
c1.incrémente()
c2.incrémente()
c1.incrémente()

print(c1.valeur, c2.valeur)

Notez que l'on a pas eu besoin du code de Compteur() ni de incrémente() pour "voir" ce que faisait le code. C'est une de la puissance de la programmation objet :

Formalisation cette notion de besoin avec l'UML.

Modélisation UML

Pour représenter les différentes possibilités offertes par une classe on utilise l'Unified Modeling Language (UML)

L'UML peut être très compliqué. Nous allons uniquement l'utiliser ici comme une représentation synthétique d'une classe/objet. Vous le verrez dans les exemples ci-dessous mais, en gros, une classe en UML c'est le diagramme :

Par exemple un point et un polygone qui les utilise :

Ou le classique personne et compte bancaire :

UML du Compteur

On va essayer de comprendre le code pour produire une représentation UML de la classe Compteur. L'analyse du besoin que l'on a effectué nous a permit de définir l'usage ue l'on veut faire du compteur :

• ajouter une unité à un compteur via la méthode incrémente
• connaître la valeur du compteur via l'attribut valeur

Ce qui donne le diagramme UML du compteur :

Implémentation en python

La modélisation UML ne nous indique pas l'implémentation des différentes méthodes, il nous indique juste comment on peut les utiliser. Pour exécuter et utiliser notre compteur, il faut le coder.

La modélisation UML se transcrit presque mot pour mot en python. En codant la classe suivante dans un fichier nommé compteur.py l'exemple va fonctionner :

class Compteur:
    def __init__(self):
        self.valeur = 0

    def incrémente(self):
        self.valeur = self.valeur + 1

On va détailler plus tard les méthodes et moyens de construire des classes en python mais de l'écriture de la classe compteur on peut d'ores et déjà en déduire que :

• une classe est un bloc python
• le constructeur est une fonction définie dans le bloc de classe et qui s'appelle __init__ (c'est une méthode spéciale !)
• les attributs sont assignés dans l'espace de nom d'un objet nommé self qui est le premier paramètres de toutes les fonctions définies dans la classe
• les méthodes sont des fonctions définies dans la classe

Classes en python

Définition de classes

La définition d'une classe est un bloc python :

class <nom de la classe>:
    def __init__(self, paramètre 1, ..., paramètre n):
        # création des attributs
        # initialisation de l'objet
    def méthode(self, paramètre 1, ..., paramètre n_1):
        # ...
        # instructions de la méthode
        # ...
    # autres méthodes

Ce bloc contient :

• le nom de la classe,
• le constructeur qui sera toujours la méthode : __init__. C'est une méthode spéciale,
• les méthodes.

Notez qu'en python on ne décrit pas les différents attributs. On les créera dans le constructeur en utilisant le paramètre self qui est présent dans toutes les méthodes et contient l'objet appelant la méthode (on verra comment en détail ci-après).

De façon formelle :

Reprenons l'exemple de la classe compteur et examinons son exécution. à la fin de la ligne 1, on vient d'importer le module compteur qui contient uniquement une définition de classe, on est dans le cas suivant :

L'espace de nommage de la classe Compteur contient deux méthodes (les fonctions définies dans une classes sont appelées méthodes) :

• __init__ qui est le constructeur de la classe
• incrémente qui est une méthode

Les deux méthodes prennent comme premier paramètre un objet nommé self, qui est la manière explicite de python de montrer quel objet est utilisé lors de l'appel de méthodes :

Création d'un objet

En python, le retour de l'exécution d'une classe (l'utilisation de la classe comme si c'était une fonction) produit un objet. Par exemple :

• list() : crée un objet de type list (une liste), sans paramètre.
• int() : crée un objet de type int (un entier) sans paramètre (c'est 0).
• int(3.1415) : crée un un objet de type int avec un paramètre, valant le réel 3.1415 (c'est 3)
• float("3.1415") : crée un objet de type float (un réel) avec un paramètre valant la chaîne de caractères "3.1415".
• list(range(5)) : crée un objet de type list avec comme unique paramètre le résultat de la fonction range

Le code suivant :

o = MaClasse(paramètre_1, ..., paramètre_n)

Va créer un objet de type MaClasse en effectuant les différentes étapes suivantes :

1. créant un objet vide o de type MaClasse contenant un espace de nommage dont le parent est l'espace de nommage de sa classe
2. il exécute le constructeur __init__ sur l'objet : MaClasse.__init__(o, paramètre 1, ..., paramètre n) (c'est pour ça que la méthode __init__ n'a pas de retour)

En prenant l'exemple du compteur. l'exécution de la ligne 3 (c1 = Compteur()) se déroule comme suit :

1. Création d'un nouvel objet :
2. Exécution du constructeur __init__ avec le nouvel objet en paramètre. À la fon de l'exécution du constructeur on est dans la configuration suivante :

On refait pareil pour la ligne 4 (c2 = Compteur()), ce qui fait qu'on se trouve dans l'état suivant :

Comme le constructeur est toujours appliqué au nouvel objet créé chaque objet va bien avoir des attributs distincts !

Exécution de méthodes

L'exécution de méthodes se fait simplement en utilisant les règles des espaces de nommages et de la notation pointée.

1. on cherche le nom (potentiellement récursivement) dans l'espace de nommage
2. l'objet appelant est donné comme premier paramètre de la méthode.

Ainsi pour l'exemple du compteur, l'exécution de la ligne 5 (c1.incrémente()) se déroule comme suit :

1. on cherche le nom incrémente dans l'espace de nommage de c1. Il n'y est pas
2. on cherche alors le nom incrémente dans l'espace de nommage parent, c'est celui de sa classe et on le trouve !
3. on exécute la méthode incrémente en plaçant l'objet appelant (ici c1) en premier paramètre de la méthode
4. La méthode accède aux différents attributs de l'objet en utilisant la notation pointée ((ici self.valeur))

Le résultat de l'exécution de la ligne 5 est alors :

À vous pour vérifier que vous avez compris :

Code Python de la classe Compteur