Accueil
Mes tutoriels sur la programmation

Tutoriel Python - sommaire


Vous pouvez me contacter via Facebook (questions, critiques constructives) : page Facebook relative à mon site

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 :

>>> maliste = [5,4,3,2,1] >>> type(maliste) <class 'list'> >>> len(maliste) 5 >>> maliste.count(5) # compter les occurrences 5 dans la liste 1 >>> maliste.index(2) # position de l'occurence 2 dans la liste 3

Quand vous écrivez type(maliste) l'interface retourne le message : class 'list'
La variable "maliste" est en effet un objet de type "list" ; on dit aussi une instance de la classe "list".
Ensuite vous manipulez cet objet de la classe 'list' et alors vous rencontrez deux syntaxes différentes :

Len() est une fonction générique 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 abordons 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

Terminologie

En POO on utilise les termes suivants : classe, instance de classe (ou objet), attributs et méthodes de classe.

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 :

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 :

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 ...