Programmation objet
Le paradigme de programmation objet fournit une notion de classe, qui permet à la fois de définir (et nommer) des
structures de données composites, et de structurer le code d’un programme.
1) Classes et attributs : structurer les données
Une classe définit et nomme une structure de données qui vient s’ajouter aux structures de base du langage.
La structure définie par une classe peut regrouper plusieurs composantes de natures variées.
Chacune de ces composantes est appelée un attribut et est doté d’un nom.
Description d’une classe
Supposons que l’on souhaite définir dans notre programme différents personnages possé- Personnage
dant chacun un nom et une certaine force. On peut appeler la structure correspondante
nom ’Murzol’
Personnage, et nous pourrions nous figurer le personnage « Murzol de force 50 » comme
une paire nommé correspondant à la représentation graphique ci-contre : force 50
Python permet la définition de cette structure Personnage sous la forme d’une classe avec le code suivant :
class Personnage :
""" une classe pour repr é senter un personnage
muni d ’ un nom et d ’ une force """
def __init__ ( self , n , f ) :
self . nom = n
self . force = f
• La définition d’une nouvelle classe est introduite par le mot-clé class suivi du nom choisi pour la classe ;
• Le nom d’une classe commence par une lettre majuscule ;
• les fonctions définies à l’intérieur d’une classe sont appelées méthodes ;
• une méthode possède nécessairement un paramètre appelé self en premier ;
• une classe possède une méthode spéciale init() nommée constructeur qui sera appelée lorsqu’on va créer un
élément de cette classe.
Création d’un objet
Une fois la classe Personnage définie, un élément de cette strucutre peut être construit avec une expression de la
forme : Personnage(n, f). On appelle un tel élément un objet ou une instance de la classe Personnage.
>>> p = Personnage ( ’ Murzol ’ , 50)
Tout s’écrit comme si le nom de la classe était également une fonction atten- p •−−−−−−−−−−−→ Personnage
dant deux paramètres et construisant l’élément correspondant. Ici la variable nom ’Murzol’
p contient un pointeur vers le bloc mémoire qui a été alloué à cet objet : force 50
Manipulation des attributs
On peut accéder aux attributs d’un objet p de la classe Personnage avec la notation p.a où a désigne le nom de
l’attribut visé. Les attributs (comme les case d’un tableau) sont mutables en python : on peut non seulement consulter
leurs valeurs mais également les modifier.
>>> p . force
50
>>> p . force += 10
>>> p . force
60
Les attributs définis ici sont des attributs d’objet (ou attributs d’instance) car chaque objet possède pour ses attributs
des valeurs qui lui sont propres.
1 NSI Tle - 2023/24
Attributs de classe
Une classe peut également définir des attributs de classe , dont la valeur est attachée à la classe elle-même.
class Personnage :
force_max = 100
...
On peut consulter de tels attributs depuis n’importe quelle instance, ou depuis la classe elle-même.
>>> p = Personnage ( ’ Murzol ’ , 50)
>>> ( p . force_max , Personnage . force_max )
(100 , 100)
On peut également modifier cet attribut en y accédant via la classe elle-même pour que la modification soit perceptible
par toutes les instances présentes ou futures.
>>> Personnage . force_max = 150
>>> p . force_max
150
En revanche un tel attribut n’est pas destiné à être modifié depuis une instance.
2) Méthodes : manipuler les données
Dans le paradigme de la programmation objet, un programme manipulant un objet n’est pas censé accéder librement
à la totalité de son contenu. La manipulation de l’objet passe donc de préférence par une interface constituée de
fonctions dédiées, qui font partie de la définition de la classe et son appelées les méthodes de cette classe.
Utilisation d’une méthode
Les méthodes d’une classe servent à manipuler les objets de cette classe.
Chaque appel de méthode peut recevoir des paramètres mais s’applique avant tout à un objet de la classe concernée.
L’appel à une méthode affiche s’appliquant au personnage p et renvoyant >>> p . affiche ()
une chaîne de caractères décrivant le personnage représenté par p est réalisé ’ nom : Murzol | force : 50 ’
ainsi :
Cette notation pour l’appel de méthode utilise la même notation pointée que l’accès aux attributs de p, mais fait
apparaître en plus une paire de parenthèses, comme pour l’appel d’une fonction sans paramètres.
Lorsqu’une méthode dépend d’autres paramètres que cet objet principal p , >>> p . renforcer (10)
ces autres paramètres apparaissent de la manière habituelle, enttre les pa- >>> p . affiche ()
raenthèses et séparès par des virgules. ’ nom : Murzol | force : 60 ’
Lors d’un appel [Link](para1 , ..., paran ) à une méthode met :
• l’objet obj est appelé le paramètre implicite ;
• les paramètres para1 , ..., paran sont appelés les paramètres explicites .
Toutes les méthodes d’une classe attendent comme paramètre implicite un objet de cette classe.
Les paramètres explicites, en revanche, peuvent être des valeurs de base (nombres, chaines, etc) ou des objets.
On peut imaginer dans notre classe Personnage :
– une méthode egale s’appliquant à deux personnages (le paramètre im- >>> p2 = p . clone ( ’ Murzol2 ’)
plicite et un paramètre explicite) et testant l’égalité des forces de ces deux >>> p . egale ( p2 )
True
personnages ;
>>> p2 . renforcer (10)
– et une méthode clone s’appliquant à un personnage p et renvoyant un
>>> p . egale ( p2 )
nouveau personnage initialisé avec la même force et un nom donné en para- False
mètre (explicite).
2 NSI Tle - 2023/24
Définition d’une méthode
Une méthode d’une classe peut être vue comme une fonction ordinaire, pouvant dépendre d’un nombre arbitraire de
paramètres, à ceci près qu’elle doit nécessairement avoir pour premier paramètre un objet de cette classe (le paramètre
implicite). Une méthode ne peut donc avoir zéro paramètre.
La définition d’une méthode d’une classe se fait exactement avec la même notation que la définition d’une fonction.
En python, le paramètre implicite apparaît en première position et par convention est systématiquement appelé self .
Ce paramètre étant un objet, on va pouvoir accéder à ses attributs avec la notation [Link]
Ainsi les méthodes affiche et renforcer de la classe Personnage peuvent être définies de la manière suivante :
def affiche ( self ) :
return ( ’ nom : ’ + self . nom
+ ’ | force : ’ + str ( self . force ) )
def renforcer ( self , f ) :
self . force += f
# depassement de la force max
if self . force > Personnage . force_max :
self . force = Personnage . force_max
Constructeur
La construction d’un nouvel objet avec une expression comme Personnage(’Murzol’, 50) déclenche deux choses :
• la création de l’objet lui-même.
• L’appel à la méthode spéciale __init__ chargé d’initialiser les valeurs des attributs.
Autres méthodes particulières en Python (dunders)
Il existe en Python des méthodes particulières, chacune avec un nom fixé et encadré par deux caractères soulignés
( __) . Ces méthodes sont appelées par certaines opérations prédéfinies de python, permettant parfois d’alléger ou
d’uniformiser la syntaxe. Il existe de telles méthodes d’usage général, comme dans les exemples suivants :
méthode appel effet
__str__(self) str(p) renvoie une chaîne de caractères décrivant p
__lt__(self, q) p < q renvoie True ssi p est strictement plus petit que q
__eq__(self, q) p == q renvoie True ssi p est égal à q (avec critère d’égalité adapté à la classe)
D’autres sont spécifiques à des classes représentant certaines catégories d’objets.
Ci-dessous, trois méthodes pour une classe représentant une collection.
méthode appel effet
__len__(self) len(obj) renvoie un nombre entier définissant la taille de obj
__contains__(self, x) x in obj renvoie True ssi x est dans la collection obj
__getitem__(self, i) obj[i] renvoie le i-ème élément de obj
3 NSI Tle - 2023/24
Méthodes de classe
De même qu’il existe des attributs de classe, dont la valeur ne dépend pas des instances mais est partagée au niveau de
la classe entière, une méthode de classe ne s’applique pas à un objet particulier. Ces méthodes sont parfois pertinentes
pour réaliser des fonctions auxiliaires ne travaillant pas directement sur les objets de la classe :
def force_valide ( f ) :
return f < Personnage . force_max
def vainqueur ( p1 , p2 ) :
if p1 . force > p2 . force :
return p1
elif p1 . force < p2 . force :
return p2
else :
return None
Pour appeler de telles méthodes, on peut utiliser la notation d’accès direct avec le nom de la classe :
>>> Personnage . force_valide (130)
False
>>> p = Personnage ( ’ Murzol ’ ,50)
>>> g = Personnage ( ’ Gandalf ’ , 60)
>>> Personnage . vainqueur (p , g ) . affiche ()
’ nom : Gandalf | force : 60 ’
3) Héritage et polymorphisme
Il est possible de définir une nouvelle classe comme une extension d’une classe existante. Dans ce contexte, la classe
d’origine est appelée classe mère et la nouvelle classe fille . Dans une telle situation d’extension, la classe fille possède
automatiquement tous les attributs et méthodes de la classe mère (on dit qu’elle en hérite) et peut en outre ajouter à
sa définition de nouveaux attributs et de nouvelles méthodes qui lui sont spécifiques. On dit que la classe fille est une
spécialisation de la classe mère et que la classe mère est une généralisation de la classe fille.
Ainsi, une structure Magicien peut être définie comme un Personnage qui posséderait, en plus de ce qui caractérise
un Personnage ordinaire, des pouvoirs magiques. La définition à écrire pour cela est la suivante :
class Magicien ( Personnage ) :
""" Personnage avec des pouvoirs magiques """
def __init__ ( self , n , f , m ) :
Personnage . __init__ ( self , n , f )
self . magie = m
def affiche ( self ) :
print ( " nom : " + self . nom + " | force : " + str ( self . force )
+ " | magie : " + str ( self . magie ) )
À la première ligne de la définition, le nom de la nouvelle classe suit directement le mot-clé class et le nom de la
classe mère est fourni entre parenthèses.
L’instruction Personnage.__init__(self, nom, force) permet de faire appel au constructeur de la classe mère
Personnage (et donc d’initialiser le nom et la force ici).
La définition du contenu de la classe ne mentionne ensuite que ce qui est spécifique à la classe fille, ici la redéfinition
de la méthode affiche pour faire apparaître la magie. C’est ce qu’on appelle le polymorphisme .
Toutes les méthodes déja présentes dans Personnage , comme renforcer sont héritées.
>>> m = Magicien ( ’ Gandalf ’ ,60 ,100)
>>> m . renforcer (10)
>>> m . affiche ()
’ nom : Gandalf | force : 70 | magie : 100 ’
4 NSI Tle - 2023/24