Initiation à la programmation objet en Python
En Python tout est objet
De même que Monsieur Jourdain faisait de la prose sans le savoir, vous faites avec Python, de la Programmation Oriénté Objet tout en l'ignorant.
Vous manipulez dès le départ des instances de classe, des méthodes de classes.
Regardez attentivement cette suite de commandes :
Quand vous écrivez type(maliste) l'interface retourne le message : class 'list'.
Vous avez créé une instance de la classe 'list'.
Ensuite vous manipulez cet objet de la classe 'list' et alors vous rencontrez deux syntaxes différentes :
- la syntaxe "fonction(objet)" ; exemples : len(maliste) & type(maliste)
- la syntaxe "objet.fonction(arguments éventuels)" ; exemples : maliste.count(5 & maliste.index(2)
Len() est une fonction générique (ou native ou standard) qui peut s'appliquer à des objets de
types différents (appartenant à différentes classes).
Vous connaissez d'autres fonctions natives : abs(), dir(), round(), print(), type(), range(), input(), range(), etc.
Par contre count() & index() sont des fonctions spécifiques la classe 'list'. On parle plus précisément de méthodes de classe.
Pour appliquer une méthode de classe à un objet de ladite classe, il faut utiliser la notation pointée : nomObjet.méthode(arguments éventuels).
La terminologie et syntaxe de la POO
Nous attaquons dans ce chapitre un gros morceau qui peut faire peur : la POO (Programmation Orientée Objet).
Rassurez vous, comme vous êtes déjà familiarisé avec les classes, les instances de classe et les méthodes de classe, ça devrait pas poser
pour vous de grosses difficultés.
Prenons un exemple tiré de la vie courante pour illustrer la POO.
Médor est un chien. Pendant une journée typique, il fait diverses actions: il mange, il court, il dort, etc.
La syntaxe
- Voici comment un programmeur utilisant la POO écrira tout cela :
- Médor = Chien()
- Médor.mange()
- Médor.court()
- Médor.dort()
- De plus, Médor a diverses qualités ou attributs ou propriétés (taille, couleur de poil,etc). Un programmeur pourrait décrire ceci comme suit:
- Médor.taille = "petit"
- Médor.couleur_poil = "noir"
Terminologie
En POO on utilise les termes suivants : classe, instance de classe (ou objet), attributs et méthodes de classe.
- Chien est une classe d'objets
- Médor est une instance de classe (ou objet) de la classe Chien
- mange(), court() et dort() sont des méthodes de la classe Chien ; les méthodes sont des fonctions qui appartiennent à une classe
- taille et couleur_de_poil sont des attributs (ou propriétés) d’une instance donnée
La relation entre un attribut OU une méthode et l’objet est indiquée par un point écrit entre les deux. C'est ce qu'on appelle la notation pointée.
Des programmes orientés objet
La POO correspond à une autre manière d’imaginer, de construire et d’organiser son code.
Python est résolument orienté objet, tout est construit autour de la notion d'objet.
Pour véritablement maitriser Python il est donc indispensable de comprendre la composante orientée objet.
Premier programme en POO
Le code
# nom programme : p_classe_personne
# création classe Personne avec deux attributs
class Personne:
def __init__(self,n,a):
self.nom = n
self.age = a
# création d'une instance dans la classe Personne
p1 = Personne("Albert",27)
print("nom et âge de p1 : ", p1.nom , " " , p1.age)
# création d'un nouvel objet de type Personne
p2 =Personne("Evelyne",47)
print("nom et âge de p2 : " ,p2.nom, " " , p2.age)
# modifier les attributs de objet p1
p1.age = 28
p1.nom =" Einstein"
print("nom et âge modifiés de p1 : " , p1.nom, " " ,p1.age)
Que fait ce programme ?
Il crée une classe nommée "Personne" puis :
- il définit pour cette classe deux attributs : nom & age
- ensuite il crée une instance de la classe Personne nommé "p1"
- puis il crée un deuxième objet dans cette classe nommé "p2"
- enfin il modifie les attributs de l'objet "p1"
Deuxième programme
Le précédent programme ne définissait pour la nouvelle classe que des attributs. Dans celui-ci on définit aussi des méthodes de classe.
Le code
#classe Rectangle avec deux attributs
class Rectangle:
def __init__(self,L,l):
self.Longueur=L
self.Largeur=l
# méthodes de classe ci-dessous
def surface(self):
return self.Longueur*self.Largeur
def perimetre(self):
return (self.Longueur* 2) + (self.Largeur*2)
# création d'un rectangle de longueur 7 et de largeur 5
rect1 = Rectangle(7,5)
print("La surface de mon rectangle est : ", rect1.surface())
print("le périmètre du rectangle est : " ,rect1.perimetre())
# modifier les attributs d'une instance de classe
rect1.Longueur = 9
rect1.largeur = 6
print ("Nouveaux périmètre et surface de rect1 : ", rect1.surface(), rect1.perimetre())
# créer une nouvelle instance de classe
longueur = eval(input("longueur : "))
largeur = eval(input("largeur : "))
rect2 = Rectangle(longueur, largeur)
print( "Caractéristiques de rect2" , end=":")
print( rect2.Longueur, " " , rect2.Largeur, " ", rect2.surface(), " " , rect2.perimetre() )
Que fait ce programme ?
Il crée une classe nommée "Rectangle".
Il définit pour cette classe :
- deux attributs: longeur & largeur
- deux méthodes : surface & perimetre
- Ensuite :
- il crée une instance de cette classe nommé "rect1"
- il calcule la surface et le périmètre de l'objet rect1 en utilisant les méthodes de classe
- il modifie toujours avec la notation pointée les valeurs de rect1
- il crée une deuxième instance de classe : rect2
- il calcule et affiche la surface et périmètre de rect2
Syntaxe Python et POO
Maintenant que vous avez observé attentivement le code de ces deux programmes on peut présenter la syntaxe Python dans le cadre de la POO
Définir une classe
Syntaxe : class Nomclasse:
Par convention le nom d’une classe commence toujours par une majuscule, mais ce n'est pas une obligation. N'oubliez pas les : pour début de bloc
Dans le même bloc il faut définir les attributs et méthodes de la classe.
Définir les attributs de classe
def __init__(self,param1, param2, ...):
self.variable1=param1
self.variable2=param2
...
Le mot "self" est obligatoire.
Définir une méthode de classe
def méthode(self):
return expression
Il faut au minimum le paramètre "self". Le mot "self" sera expliqué plus bas.
L'expression est construite à partir des attributs.
Créer une instance de classe
Syntaxe : nomObjet = NomClasse(arguments)
Modifier les attributs d'un objet
Syntaxe : nomObjet.attribut = nouvelle valeur
Appliquer une méthode à un objet
Syntaxe : nomObjet.méthode()
Le mot self
Il faut expliquer ce que signifie ce mot "self" qui est omniprésent dans la syntaxe.
Une des particularités des méthodes est que l’objet qui l’appelle est passé comme premier argument de la fonction telle que définie dans
la classe. Ainsi, lorsqu’on écrit rect1.surface() par exemple, l’objet "rect1" est passé de manière implicite à "surface()".
Aussi une méthode possède toujours à minima le paramètre "self" et lorsqu'on appelle ladite méthode, il n'y a aucun argument à saisir.
Si la fonction --init--() comprend trois paramètres (dont self), il faut alors passer deux arguments pour créer une nouvelle instance de classe.
Les classes et le principe d’encapsulation
Les classes nous permettent de mettre en place ce qu'on appelle l'encapsulation du code c'est à dire le compartimentage des variables et des fonctions.
En effet chaque objet créé à partir d’une classe posséde ses attributs et méthodes qui ne sont pas accessibles à l'extérieur de l'objet.
Héritage
En POO on dit qu’un objet “hérite” des méthodes de sa classe ; cela signifie qu'une instance de classe a accès aux méthodes de cette classe.
Ainsi une instance de la classe Rectangle a accès aux méthodes surface() et perimetre().
Une classe peut "hériter" d'une autre classe : une classe dite "fille" hérite de toutes les variables et fonctions de la classe parent (et notamment de sa fonction __init__())
Premier programme avec héritage
Le code
# nom programme : heritage.py
#création d'une classe Personne avec deux attributs
class Personne:
def __init__(self,nom,age):
self.nom = nom
self.age=age
# La classe Etudiant hérite de la classe mère Personne
class Etudiant(Personne):
# définition des attributs
def __init__(self,nom,age,filiere):
# héritage des attributs depuis la classe mère Personne
Personne.__init__(self,nom,age)
# ajout d'un nouvel attribut filiere à la classe Etudiant
self.filiere = filiere
etudiant1 = Etudiant("Albert",27,"math")
print("nom, âge, filière : " ,etudiant1.nom, " ", etudiant1.age, " " ,etudiant1.filiere)
#créer d'une nouvelle instance de la classe Etudiant
etudiant2 =Etudiant("Isabelle",21,"informatique")
print("nom, âge, filière : " ,etudiant2.nom, " ", etudiant2.age, " " ,etudiant2.filiere)
Que fait ce programme ?
Création d'une classe "Personne" avec deux attributs : nom & age
Création de la classe "Etudiant" à partir de "Personne"
Cette classe récupère les attributs de la classe mère
Ajout d'un troisième attribut
Création d'une première instance de Etudiant : etudiant1
Création d'une deuxième objet : etudiant2
Remarque syntaxique
Les paramètres de la fonction –init--() peuvent être identiques aux noms des variables (attributs) définis par cette fonction.
Exemple :
def __init__(self,nom,age):
self.nom = nom
self.age=age
class Etudiant(Personne): cette instruction signifie que la classe "Etudiant" hérite de la classe "Personne".
Personne.__init__(self,nom,age) : instruction pour récupérer les attributs nom et age de Personne
self.filiere = filiere : instruction pour créer un troisième attribut.
Deuxième programme
Le code
# nom programme : heritage.py
#création d'une classe Personne
class Personne:
def __init__(self,nom,age):
self.nom = nom
self.age=age
# La classe fille Etudiant hérite de la classe mère Personne
class Etudiant(Personne):
# définition des attributs
def __init__(self,nom,age,filiere):
# héritage des attributs depuis la classe mère Personne
Personne.__init__(self,nom,age)
# ajout d'un troisième attribut
self.filiere = filiere
#ajout d'une méthode
def affiche(self):
return self.nom + " " + str(self.age) + " "+ self.filiere
#créer une instance de Etudiant
etudiant1 = Etudiant("Albert",27,"math")
print("Nom, âge, filière : " ,etudiant1.nom, " ", etudiant1.age, " " ,etudiant1.filiere)
#modifier les attributs d'un objet
etudiant1.nom ="Alberta"
etudiant1.age = 28
#utiliser la méthode affiche() à l'objet etudiant1
print("nom, âge, filière : " ,etudiant1.affiche())
#créer d'une nouvelle instance de Etudiant
etudiant2 =Etudiant("Isabelle",21,"informatique")
#utiliser la méthode affiche() à l'objet etudiant2
print("Nom, âge,filiere :", etudiant2.affiche())
Que fait ce code de plus par rapport au précédent ?
Il définit dans la classe Etudiant une méthode affiche() qui produit la fiche de l'étudiant.
Il est en effet beaucoup plus simple d'écrire print(nomObjet.affiche()) que
print(nomObjet.nom , " ", nomObjet.age , " ", nomObjet.filiere)
Et encore, ici il n'y a que trois variables. Mais s'il y en avait 10 ...