Chapitre 3 : notions sur les classes en Python

Chapitre 3 : notions sur les classes en
Python : programmation orient´ee objet.
Illustration sur les polynˆomes et frac-
tions rationnelles
Avertissement : aucune connaissance sp´ecifique sur la POO n’est exigible pour les ´ecrits
de concours. En revanche, la POO est mentionn´ee dans la partie exemple du programme
d’I.P.T. Elle peut ˆetre utile aussi dans le cadre des TIPE.
Introduction
Nous connaissons d´ej`a bien la notion de type d’objets. Ainsi en Python,a=1 va fabriquer un
objet ade type integer alors que a="1" va fabriquer un objet de type string et a=[1] une liste.
Pour chacun de ces types de variables, on a une op´eration +mais qui ne fait pas la mˆeme chose.
On dit que la fonction +est ≪polymorphe ≫: elle s’applique `a des objets diff´erents. On va voir
que ce sont les objets de classes munies d’une m´ethode add .
1 Classes et objets
1.1 Essai de d´efinition d’une classe
D´efinir une classe, c’est :
●d´efinir une forme et des propri´et´es qu’auront les objets de la classe,
●d´efinir les fonctions (m´ethodes) qui s’appliqueront `a ces objets.
Par exemple, on va d´efinir ci-dessous une classe Polynome dont chaque objet sera un polynˆome
avec son degr´e, ses coefficients, et les op´erations possibles sur les polynˆomes : ´evaluation, somme,
produit, divisions euclidiennes, mais aussi un affichage, etc...
1.2 La notion de classe est plus g´en´erale que celle de type
Prenons l’exemple d’une variable Len Python intervenant dans le code suivant :
for i in L:
print(L)
Pour que le code pr´ec´edent soit valide, il est n´ecessaire que l’objet Lsoit iterable i.e. supporte une
boucle for, et que les ´el´ements de Lsoient affichables ( pour le print).
En Python, il existe une classe Iterable qui permet de dire que les objets de la classe ont
cette propri´et´e, avec une m´ethode __iter__ qui retourne un objet qu’on peut parcourir 1.
1.3 Les classes font des enfants
La classe Iterable admet (notamment) les classes List et Tuple comme classes filles. . Le type
Integer ne poss`ede pas de m´ethode __iter__
Cette possibilit´e de faire ≪h´eriter ≫une sous-classe de prop. donne beaucoup d’efficacit´e !
Exemple : pour un jeu vid´eo on peut consid´erer une classe ´el´ements avec deux classes
filles personnage et d´ecor et pour la classe personnage deux classes filles personnage g´er´e par
l’ordi. ou personnage g´er´e par le joueur.
1. Nous revenons plus loin sur le sens du double-underscore autour de iter
1

1.4 Les objets : leurs attributs et leurs valeurs
Pour d´efinir une classe, on doit d’abord d´efinir les attributs de ses objets
Dans l’exemple Paul a 100 g de pain,l’objet Paul de la classe Humain a un attribut pain
avec une valeur 100g.
L’id´ee : tous les humains peuvent avoir l’attribut pain mais avec des valeurs diff´erentes, y
compris 0.
1.5 Les fonctions attach´ees `a une classe s’appellent des m´ethodes :
Pour d´efinir une classe, on doit ensuite d´efinir les m´ethodes qui op`erent sur ses objets
On connaˆıt d´ej`a bien la syntaxe des m´ethodes pour les listes par exemples : l.append(1).
D’une mani`ere g´en´erale, quand on va d´efinir une classe, on va, `a la suite des premi`eres ins-
tructions qui vont modeler les objets de la classe, d´efinir un certain nombres de fonctions qui
s’appliqueront aux objets de la classe. Ce sont les m´ethodes de la classe.
Par exemple avec help(list) on voit toutes les m´ethodes d´efinies pour la classe liste et les
docstrings qu’on aura ´ecrites comme aide des fonctions apparaˆıtront dans cette aide.
1.6 Le self : une autre fa¸con d’appeler les m´ethodes
On a rappel´e au paragraphe pr´ec´edent la syntaxe d’appel des m´ethodes d’une classe. En r´ealit´e,
il en existe une autre : par exemple pour rajouter `a une liste Lune entr´ee 12, on peut au lieu de
faire L.append(12) faire :
list.append(L,12)
Il s’agit de la mˆeme fonction appel´ee avec les arguments self, 12 : le premier argument
est la liste sur laquelle la m´ethode va op´erer. On met list devant le append pour dire `a
Python o`u la chercher alors qu’avec L.append ce n’est pas n´ecessaire puisque en voyant L
il sait que c’est une liste.
D’une mani`ere g´en´erale : objet.m´ethode(arguments) et
nomclasse.m´ethode(objet,arguments) sont des appels ´equivalents de la fonction
m´ethode. Sous la deuxi`eme forme, ce premier argument est appel´e self.
2 Une construction concr`ete : l’exemple de la classe Polynome
Convention : (pas forc´ement toujours respect´ee) les noms de classe en Python commencent par
une majuscule.
2.1 Pour pouvoir d´efinir des objets : la m´ethode init
Comment on commence :
Voici le d´ebut du code de d´eclaration de notre classe Polynome avec la premi`ere fonction
init expliqu´ee ci-apr`es.
class Polynome:
def __init__ (self, coefs):
self.coefs = coefs
self.degre = None
Le def est une d´eclaration de fonction. Comme il est `a l’int´erieur de la classe, cette fonction est
une m´ethode de la classe. Le mot __init__ est un nom r´eserv´e de Python. Avant de d´etailler ce
qu’il y a `a l’int´erieur de la d´eclaration de notre fonction __init__, voyons d´ej`a :
2

A quoi sert notre m´ethode __init__ ? A initialiser nos objets
Utilisation concr`ete :
a=Polynome([3,2,4])
type(a)
<__main__.Polynome at 0x1100cd898>
# bon il nous dit d´ej`a qu’on a un objet de la classe Polynome
qui fait partie du r´epertoire __main__
La m´ethode __init__ est ≪magique ≫: on ne l’appelle pas par son nom, mais par le nom de la classe !
Retour sur la d´eclaration def __init__ :les arguments self,coef.
Dans le code de d´eclaration def __init__ prend deux arguments self,coef.
Dans l’utilisation, on n’a rentr´e qu’un argument qui est la liste des coefficients stock´ee dans
coef.
En fait, l’´ecriture magique a=Polynome([3,2,4]) appelle la m´ethode Polynome.__init__(a,[3,2,4])
dans lequel self est l’objet asur lequel agit la m´ethode (ici en le modelant). 2
Davantage sur les attributs :
La suite du code
self.coefs = coefs
self.degre = None
d´efinit deux attributs pour l’objet self cr´e´e par cette m´ethode. L’attribut self.coefs prend la
valeur coefs qui est pass´ee comme argument par la fonction __init__. Autrement dit, quand
on a cr´ee P=Polynome([3,2,4]), l’attribut self.coefs prend la valeur [3,2,4] : c’est donc une
liste. L’attribut self.degre ne prend pas de valeur par d´efaut : None mais nous y reviendrons. On
a choisi de mettre cet attribut degre pour avoir acc`es facilement au degr´e du polynˆome.
Les attributs contiennent des valeurs associ´es `a notre objet, directement accessibles :
>>>A=Polynome([4,2,1])
>>>A.coefs
[4,2,1]
2.2 Excursion : regardons une autre classe et d’autres attributs
>>>help(complex)
Help on class complex in module builtins:
class complex(object)
| complex(real[, imag]) -> complex number
|
| Create a complex number from a real part and an optional imaginary part.
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
2. Plus technique : Toutefois, les deux instructions a=Polynome([3,2,4]) et Polynome. init (a,[3,2,4])
ne sont pas ´equivalentes : car la premi`ere appelle d’abord une m´ethode new qui cr´ee l’objet (que l’on ne red´efinit
pas) puis appelle init . Ainsi, il n’est pas tout `a fait correct de dire, comme on le voit souvent, que init est
le constructeur. En revanche, quand vous avez d´ej`a cr´e´e un objet init pourra le modifier.
3

|
| __add__(self, value, /)
| Return self+value.
|
......
------------
| Data descriptors defined here:
|
| imag
| the imaginary part of a complex number
|
| real
| the real part of a complex number
J’ai saut´e la liste des m´ethodes, mais les data descriptors sont les attributs, et donc la
syntaxe pour extraire partie r´eelle et partie imaginaire est :
z=complex(15,7) # cr´ee le complexe 15+7i
z.real # oui sans parenth`ese apr`es car attributs et pas fonctions....
z.imag
2.3 Une deuxi`eme m´ethode : pour acc´eder aux coefficients
def coef (self, i):
""" Retourne le coefficient de X**i """
try:
return self.coefs[i]
except: # s’il y a une erreur de out of range, on veut que les coefficients
# existent, mais qu’ils soient nuls !
return 0
On peut ensuite faire P.coef(2) par exemple...
2.4 Une m´ethode pour calculer le degr´e et une modif. de init
def get_deg(self):
m = "-infini"
for i in range(len (self.coefs)):
if self.coef(i) != 0:
m=i
self.degre = m
return m
A ce stade, c’est un peu bizarre : l’attribut P.degre n’est juste que si on appelle une fois la m´ethode get_deg
Du coup, on modifie notre m´ethode init :
def __init__ (self, coefs):
self.coefs = coefs
self.degre = self.get_deg() # appelle la m´ethode get.deg() qu’on d´efinit apr`es
# qu’importe tout est lu !
4

2.5 Quelques m´ethodes magiques
#
" !
On appelle m´ethodes magiques des m´ethodes qui s’utilisent tr`es agr´eablement `a l’aide
par exemple d’un op´erateur comme +,* ou une autre commande, plutˆot que par
la syntaxe usuelle d’appel de m´ethodes. Ces m´ethodes ont un nom r´eserv´e en Py-
thon, encadr´e par des . Ce nom de m´ethode peut ˆetre utilis´e pour des classes tr`es
diff´erentes : la m´ethode sous-jacente faisant des r´esultats tr`es diff´erents. On va le voir
en reprenant l’exemple de l’addition de l’introduction.
Nous avons d´ej`a vu que __init__ ´etait magique.
2.5.1 M´ethode magique str pour afficher avec print
On a vu avec la classe complex que lorsqu’on d´eclarait un complex(2,3),Python affichait un
≪joli ≫:2+3j. On veut faire de mˆeme avec nos polynˆomes : on veut que si on rentre P=Polynome([3,2,1])
il nous affiche 3+2X^1+X^2 .
def __str__(self):
s="" # initialisation
# on regarde d’abord si le polyn^ome est nul
if self.get_deg()=="-infini":
return "0"
else:
s=s+str(self.coef(0))
for i in range(1,self.get_deg()+1):
if i!=0:
s+=" + {}.X^{}".format(self.coef(i),i)
return s
De mˆeme la m´ethode repr permet de d´efinir ce que renvoie le shell si on tape le nom d’un
objet simplement. Ici, on peut choisir qu’elle renvoie la mˆeme chose que pour le print.
2.5.2 M´ethode magique call : permet d’appeler comme une fonction
def __call__ (self, valeur):
Alors on pourra ´ecrire P(2) pour ´evaluer la fonction polynomiale associ´ee `a Pen 2.
A faire : `a vous de jouer. Utiliser l’algorithme de Horner
2.5.3 M´ethodes magiques pour les op´erations :
En programmant des m´ethodes utilisant les noms r´eserv´es add et mul qu’on peut
appeler +et le *et div et mod qu’on peut appeler avec // et %vous pouvez programmer
l’addition et la multiplication, quotient et reste de la division euclidienne des polynˆomes. Apr`es
vous pourrez faire directement P+Q et P*Q, etc...
3 Un autre exemple, avec une classe m`ere et une classe fille
3.1 Classe m`ere : les points alg´ebriques
3.1.1 Premi`ere version de la m´ethode init
On va d´efinir un point alg´ebrique par l’entr´ee d’un couple de coordonn´ees cart´esiennes d’o`u la
m´ethode init ci-dessous :
class PointAlg:
def __init__(self, xy=[0,0]):
self.x = float(xy[0])
self.y = float(xy[1])
5