Rappel sur les grands paradigmes de programmation

En AP2, nous avons vu que la programmation se décomposait en paradigmes, c’est-à-dire en différentes méthodologies.

• La programmation impérative est la plus répandue. Il s’agit simplement de décrire la liste d’instructions avec des opérateurs de contrôles simples (boucle, conditions, fonctions).

• La programmation fonctionnelle propose d’éviter certaines constructions classiques qui entraînent de nombreux effets indésirables. Il s’agit de composer des fonctions les unes avec les autres avec des opérateurs fonctionnels (map, fold, filter, etc.). On a vu des exemples en AP2.

Nous allons voir un nouveau paradigme : la programmation orientée objet. Son objectif est de structurer le code en entité complexe qui reflète une certaine réalité : des objets.

Dans ce cours, on se limitera aux concepts présents dans l’écosystème Python. Pour en savoir plus, il faut étudier des langages différents (C++, Java par exemple).

Introduction à l’objet en Python: les classes.

Une classe en Python est un bout de code qui décrit le comportement d’un objet. Une instance d’une classe est un objet Python manipulable qui suit le comportement imposé par la classe. Il possède sa mémoire interne et des opérations propres.

• Une fonction qui appartient à un objet s’appelle une méthode. Son premier argument est toujours une instance.
• Une variable qui appartient à un objet s’appelle un champ (ou field en anglais).

Un exemple trop simple

class UneClasseInutile:
    pass
print(UneClasseInutile)

<class 'UneClasseInutile'>

Ici la classe UneClasseInutile ne sert à rien, il s’agit d’une classe vide sans méthodes ni champ (ni rien).

On peut l’instancier en un objet (qui ne sert également à rien !) en appelant la classe comme une fonction.

A = UneClasseInutile()
print(A)

<UneClasseInutile object at 0x7f242ac73d90>

Une première méthode

Une méthode est une fonction, qui a en premier argument une variable (qu’on appelle usuellement self) et qui représente l’instance de l’objet.

class EncoreUne:
    def une_methode(self, a):
        self.x = a # self représente une instance.

a = EncoreUne()
a.une_methode(10)
print(a.x)

10

On remarque qu’une méthode peut également avoir d’autres arguments (ou aucun) mais dans tous les cas elle doit avoir self en premier argument. Ici, a.x est une variable locale à l’instance a.

a.une_methode(5)
print(a.x)

5

On peut stocker des variables locales à un objet de manière dynamique:

a.y = 123
print(a.y)

123

ou supprimer un champ:

del a.y
print(a.y)

Traceback (most recent call last):
  File "/var/www/cha/check_py_md", line 77, in repl
    exec(code, env)
  File "<string>", line 2, in <module>
AttributeError: 'EncoreUne' object has no attribute 'y'

Dans l’absolu, une classe peut avoir plein de méthodes et plein de variables locales.

Des méthodes particulières

Certaines méthodes sont particulières et permettent de donner un comportement à la classe bien spécifique. Elles ont en général des noms particuliers entourés de __

• Initialisations: Quand on crée une instance à partir d’une classe, une fonction standard ou une fonction d’initialisation est appelée. Par exemple:

class AvecUnInit:
    def __init__(self, x):
        self.x = x # le champ x est initialisé à la valeur  passée en argument.

A = AvecUnInit(42)
print(A.x)

42

• Surcharge d’opérateurs : des opérateurs de la syntaxe python ou des fonctions standards de Python peuvent être appliqués sur des instances de classes à condition que la bonne méthode soit présente dans la classe. Par exemple, on peut surcharger l’addition pour lui faire faire des choses étranges.

class AdditionBarycentrique:
    def __init__(self, x):
        self.x = x
    def __add__(self, other):
        return AdditionBarycentrique((self.x+other.x)/2)

A = AdditionBarycentrique(0)
B = AdditionBarycentrique(10)
print((A+B).x)

5.0

On peut également changer la manière dont les instances sont affichées quand on appelle print ou str

class AdditionBarycentrique:
    def __init__(self, x):
        self.x = x
    def __add__(self, other):
        return AdditionBarycentrique((self.x+other.x)/2)
    def __repr__(self):
        return "B:"+str(self.x)

A = AdditionBarycentrique(0)
B = AdditionBarycentrique(10)
print(A, B, A+B)

B:0 B:10 B:5.0

• La liste des opérations surchargeables est grande, il y a beaucoup de marge de manoeuvre pour créer des objets informatique

agréables à manipuler pour l’utilisateur. C’est une des raisons du succès de Python. C’est aussi un de ces dangers.

On verra dans le cours suivant les notions d’héritage et de ducktyping.

Propriété, getter, setter

Il arrive que certaines valeurs d’un objet soient dépendantes de son état interne. Il est alors important que ce champ lui soit réservé. Pour cela, on peut utiliser une propriété qui va retourner un champ dont la valeur est calculée par une fonction. On utilise le décorateur @property

import math
class rectangle:
    def __init__(self, largeur, longueur):
        self.largeur = largeur
        self.longueur = longueur
    @property
    def surface(self):
        return math.sqrt(self.largeur**2 + self.longueur**2)

R = rectangle(10, 20)
print(R.surface) # Ce n'est pas une fonction, il n'y a pas les parenthèses !

22.360679774997898

Si on essaye de faire une assignation, Python n’est pas d’accord :

R.surface = 123

Traceback (most recent call last):
  File "/var/www/cha/check_py_md", line 77, in repl
    exec(code, env)
  File "<string>", line 1, in <module>
AttributeError: property 'surface' of 'rectangle' object has no setter

Ici, il est possible de modifier les valeurs des champs largeur et longueur.

R.largeur = 12
print(R.perimentre) # la valeur est toujours correcte

Traceback (most recent call last):
  File "/var/www/cha/check_py_md", line 77, in repl
    exec(code, env)
  File "<string>", line 2, in <module>
AttributeError: 'rectangle' object has no attribute 'perimentre'

On peut empêcher une valeur de changer en lui attribuant une propriété.

class rectangle:
    def __init__(self, largeur, longueur):
        self._largeur = largeur
        self._longueur = longueur
    @property
    def surface(self):
        return math.sqrt(self.largeur**2 + self.longueur**2)
    @property
    def largeur(self):
        return self._largeur
    @property
    def longueur(self):
        return self._longueur

R = rectangle(10, 20)
print(R.longueur, R.largeur, R.surface)

20 10 22.360679774997898

Mais par contre, on ne peut plus modifier les champs :

R.longueur = 21

Traceback (most recent call last):
  File "/var/www/cha/check_py_md", line 77, in repl
    exec(code, env)
  File "<string>", line 1, in <module>
AttributeError: property 'longueur' of 'rectangle' object has no setter

Méthode de classe.

Il arrive qu’on veuille plusieurs constructeurs pour une classe. On peut alors utiliser un décorateur @classmethod pour indiquer qu’une fonction définie dans la classe n’est pas une méthode mais une fonction qui ne dépend que de la classe qui l’appelle.

Son premier argument est toujours la classe qui appelle la fonction (on verra pourquoi avec l’héritage !).

class rectangle:
    def __init__(self, largeur, longueur):
        self._largeur = largeur
        self._longueur = longueur
    @property
    def surface(self):
        return math.sqrt(self.largeur**2 + self.longueur**2)
    @property
    def largeur(self):
        return self._largeur
    @property
    def longueur(self):
        return self._longueur
    @classmethod
    def depuis_coordonnées(cls, x1, x2, y1, y2):
        return cls(x2-x1, y2-y1)

Compiled the: mer. 04 sept. 2024 12:49:50 CEST