La Programmation Orientée Objets (POO) en

Python
1 Les classes et les objets
Une classe est une modélisation d’une entité du monde réel. Elle renferme les donnée de
l’entité et les traitement sur ces données.
Exemple :
la classe Étudiant qui modélise des un ensemble étudiants.
Une classe Voiture qui modélise les voitures.
Notes qui modelise les notes des étudiants.

Etudiant
Note Voiture
nom
codeEtudiant marque
prenom
matiere immatriculation
codeEtudiant
typeEvaluation model
email
coefficient couleur
mobile
note carburant
adresse
setNote() puissance
editer()
update() entretient()
ajouter()
supprime() circulation()
supprime()
afficherMoyen() info()
afficherMoyen()
Une instance, on l’appel aussi occurrence , d’une classe est un objet unique créé à partir de
cette classe.
Exemple :

obj1 obj2 obj3

TOTI TAHA Sami
Titi Ahmed ABdou
H-22-6032 H-20-2025 H-21-3001
toto@gmail.coml taha@gmail.coml sami@gmail.coml
06685263 05362396 05639525
15. Bvd Med6 Oujda 25, elqods Fes 30, Inara Taza

1.1 Définition d’une classe

class nomClass :
#Definition des attributs de la classe.

Exemple de définition d’une classe :

class personne :
def setData(self, p, n, age ) :
self.fname= p
self.lname = n
self.age=age
def getData(self ) :
return self.fname+" "+ self.lname+" , agé de "+str(self.age)

1
Exemple de création et d’utilisation d’une instance (ou occurrence) de la classe.
o=personne() # Instanciation en appelant le constructeur par défaut.
o.setData("Ahmed","Taha", 33) # Appel de la méthode setData par la notation point
print(o.getData()) # Appel de la méthode getData par la notation point.
p=o # p fait référence a l’objet o
On appel attribut d’une classe tout nom dans l’espace de nommage de la classe. Un attribut
est référencé par la notation point Maclass.nomAttribut.
Personne.setData et Personne.getData sont deux attributs méthodes.

1.2 Portée et Espace de nommage.

Un espace de nommage est une correspondance entre des noms et des objets. En générale,
il sont implémentés sous forme de dictionnaires Python.
L’espace des noms locaux d’une fonction est créé lors de son appel, puis effacé lorsqu’elle renvoie
un résultat ou lève une exception.
La portée est la zone textuelle d’un programme Python où un espace de nommage est directe-
ment accessible. Pour chercher la portée d’un espace de nommage, Python :
En général, la portée est recherchée dans l’ordre suivant :
Cherche d’abord dans la région la plus au proche.
Puis dans la fonction englobante.
Puis dans les espace de nommages global.
Puis les espace de nommage natifs de Python.

1.2.1 Quelques exemples d’illustration.

Exemple 1 : Affiche Hello.
def g() :
print(x)
x="Hello"
g()

x est définie dans l’espace de nommage global, donc visible pour la fonction g.

Exemple 2. Affiche "Salut"

def g() :
x="Salut"
print(x)
x="Hello"
g()

x est dans l’espace de nommage local de g ; cet objet n’a aucun lien avec avec x définie dans
l’espace global du programme.

Exemple 3. Le programme suivant lance l’exception : UnboundLocalError : local variable ’x’

referenced before assignment.
def g() :
print(x)
x="Salut"
print(x)
x="Hello"

2
g()

x est nommée dans la fonction g, donc la portée est g. c’est un objet local à g et n’a pas de
lien avec x définie précédemment.

Exemple 4. Le programme suivant lance l’exception : UnboundLocalError : local variable ’x’

referenced before assignment.
def g() :
print(x)
x= x+ " world"
print(x)
x="Hello"
g()

x est nommée dans la fonction g, donc la portée est local à g. Mais on tente d’affecter a x la
valeur de x qui est définie dans l’espace de nommage globale : Un espace de nommage ne peut
pas être local et global en mème temps.

1.2.2 Espace de nommage globale.

Dans les exemple 3 et 4 précédents, pour augmenter la portée de x et la rendre accessible
dans g, on la déclare globale, par le mot clé "global".
Exemple 5 : Ce programme affiche "Hello World !"
x="Hello"
def g() :
global x
x=x+ " World !"
print(x)
g()
Exercice. Exécutez le programme suivant et expliquez les sorties.
def f() :
ville = " Oujda"
def g() :
global ville
city = "Fes"
print("Avant l’appel de g : " + ville)
print("Appel de g :")
g()
print("Après l’appel g : " + ville)
f()
print("Valeur de ville dans le programme principal : " + ville)

1.2.3 Espace de nommage non-locale.

Introduite avec Python 3, la portée non-local est délimitée par la porté d’une fonction
englobant une fonction interne : le mot clé "nonlocal" doit exister dans une fonction interne et
il est utilisé pour modifier la valeur de l’objet dans la fonction englobante.
le nom déclaré "nonlocal" ne sera pas cherché dans l’espace de nom global.

3
Exemple. le programme suivant affiche l’exception SyntaxError : no binding for nonlocal ’ville’
found ""
def f() :
nonlocal x
x=x+1
print(x)
x="Hello"
f()

La fonction f doit être imbriquée dans une autre.

def g() :
ville = "Oujda"
def f() :
nonlocal ville
ville= "Oujda"
print("Oujda")
x="Hello"
f()

1.3 Les constructeurs

Le constructeur d’une classe permet de créer un objet. Il a le mème nom que la classe. Par
défaut, la classe fournit un constructeur sans paramètre.
o=employ() : # employ() est le constructeur par défaut.
Si on veut initialiser les champs de l’objet au moment de la création, on implémente la méthode
_init_ dans notre classe.

class personne :
def _init_(self, fname, lname, age ) :
self.fname= fname
self.lname = lname
self.age=age
def getData(self ) :
return self.fname+" "+ self.lname+" , agé de "+str(self.age)+" ans".

p=person("Toto", "Titi", 18)

lorsqu’on implémente _init_ , le constructeur par défaut n’est plus disponible.

o=personne("MOHA", "Ahmed", 40) # Correcte
o=personne() # Incorrecte : éclanche une exception.
_init_ a au moins le paramètre "self", et peut avoir d’autres paramètres qui sont des valeurs
qu’on veut assigner à tous ou certain champs.

Exemple : Constructeur sans paramètre. Initialise les champs d’un objet par "TOTO",
"Titi" et 17.
def _init_(self) :
self.fname= "TOTO"
self.lname = "Titi"
self.age=17

4
o=personne()
o.getData() : retourne TOTO Titi agé de 17 ans.

Exemple : Constructeur paramétré. Initialise tous les objets par les valeurs passées en ar-
guments
def _init_(self, fname, lname, age ) :
self.fname= fname
self.lname = lname
self.age=age

o=personne("John", "Patric", 20)

o.getData() : retourne John Patric 20 ans.
Noter qu’on ne peut pas avoir deux méthodes _init_ dans la mème classe. Du coup, on peut
pas surcharger le constructeur.

1.4 Surcharge des méthodes

Dans les langage orienté , comme Java, C++ .., la surcharge est le fait qu’une classe peut
avoir deux méthodes de mème nom mais avec des signature différentes : c’est à dire le nombre
ou les types de paramètres est différents
Python n’autorise pas ce surcharge dans la classe elle même, mais l’autorise dans une classe
dérivée. Nous allons voir un exemple dans le paragraphe concerné à l’héritage.

1.5 Imbrication
Les objets d’une classe peuvent être appelés dans une autre classe.
Exemple : un objet de la classe "person" a un attribue "birdday" qui est un objet de la classe
date

class date :
def __init__(self, day, mounth, year ) :
self.mounth=mounth
self.day= day
self.year= year
def __str__(self ) :
return str(self.day) + ’/’ + self.mounth+ ’/’ +str(self.age)

class person :
def __init__(self, fname, lname, day, month, year ) :
self.fname= fname
self.lname = lname
self.birdday= date(day, month, year)

def __str__(self, fname, lname, age ) :

return self.fname + ’ ’+ self.lname+ "né(e) le "+self.birdday.__str__()

5
1.6 Les attributs de classe et les attributs d’instances
Un attribut est un membre à qui on peut accéder en utilisant la notation point.
Une classe peut avoir comme attributs : des variable de type primitifs ou un type d’une autre
classe.
des méthodes qui ont "self" comme premier paramètre. Ces méthodes agissent sur les instance
de la classe.
des fonction, qui n’ont pas le paramètre "self". Ces fonction ne dépendent pas des instances de
la classe.
Une instance peut avoir comme attributs les variable d’instances qui stockent les données. et
des méthodes qui agissent sur ces données.
Exemple :
class animal :
nbre=0
def __init__(self, genre, categorie) :
self.genre=genre
self.categorie=categorie
animal.nbre+=1
def appeler() :
return "Coucou"

la variable "nbre" et la méthode "appeler()" sont des attribut de la classe. Elles ne dé-
pendent pas des instances : leurs valeurs sont les même pour tous les instances de la classe. On
accède à ces attributs en utilisant la notation point.
animal.nbre # Ici, nbre retourne le nombre d’instance crées
animal.appeler()
Les variable "genre" et "categorie " sont des attribut des instances. chaque instance de la classe
"animal" a des données différente des autres.
La méthode __init__() est un attribut de la classe mais qui agit différemment sur chaque
instance.
Exercice : soit le code suivant
a= animale("Tigre", "Felin" )
b= animale("Lion", "Felin" )
c= animal ("vache", "Bovin" )
Vérifier que a.appeler(), b.appeler et c.appeler ont la même valeur.
Même chose pour a.nbre, b.nbre et c.nbre
On prefere noter animal.nbre et animal.appeler().
Vérifier que a.genre, b.genre, c.genre ont des valeurs différentes

2 L’héritage simple
L’héritage permet d’utiliser une classe existante pour en définir une autre classe.
La classe dérivée peut accéder à toutes les méthodes de la classe de base.
Toute instance de la classe dérivée est une instance de la classe de base. Donc elle possède tous
les attributs que possède une instance de la classe de base.
Une classe dérivée peut :
Ajouter des nouvelles méthodes
Redéfinir une méthode de la classe de base
Surcharger une méthode de la classe de base

6
Ajouter des attributs au instances de la classe de base.

Pour hériter d’une classe, on utilise la syntaxe :

class classDerivee(classBase)

la classe "classDerivee" est une classe fille, sous classe ou classe dérivée de la classe "classBase".
"classBase" est la classe mère, classe de base ou super classe de la classe "classDerivee"
la classe "classDerivee" peut être dérivée à son tour.

class deriveeSecond(classDerivee) :
pass
On peut hériter de "deriveeSecond" et ainsi de suite,
Exemple :
class person :
def __init__(self, fname,lname) :
self.fname=fname
self.lname = lname
def__str__(self) :
return "Je suis : "+self.lname+" "+self.fname

class employe(person)
pass

e=employe("toto","titi")
# e instance de employe utilise le constructeur de la classe de base person.
print(e.__str__())
# L’instance e peut accéder aux méthodes de la classe de base person.
print(e.fname)
print(e.lname)
# L’instance e de la classe dérivée "employe" possède tous les attributs que possède une ins-
tance de la classe de base person.

2.1 Surcharge de constructeur.

Si, pour une classe fille, on veut un constructeur qui initialise tous les attributs de ses ins-
tance, on appelle le constructeur de la super classe par la syntaxe :

super(classDerivee, self).__init__()
ou simplement par
super().__init__()

Exemple
class person :
def __init__(self, fname,lname) :
self.fname=fname
self.lname = lname
def __str__(self ) :
return "Je suis : "+self.lname+’ ’+self.fname
class employe(person) :

7
 def __init__(self,flname,lname, salary) :
super( employe, self ).__init__(flname, lname)
self.salary=salary

a=employe("Toto", "Titi", 4500) # a est une instance de la classe "employe",

a=employe("Toto", "Titi") # Lève une exception, le constructeur a deux paramètre n’existe
plus.

2.2 Surcharge de méthode.

Une méthode surchargée dans la classe fille a le mème nom qu’une méthode de la classe
mère, mais une signature différente.
Dans l’exemple suivant g est surchargée avec un paramètre de plus.

class base :
def g(self ) :
return "salut"
class derivee(base) :
def g(self,nom) :
return "salut" + nom
a= base()
b=derivee()
a.g() : # retourne "salut"
b.g("Toto") # retourne "salut toto"
b.g() : # Lève une exception. La méthode g() n’est plus disponible dans classe fille

2.3 Redéfinition de méthodes

La redéfinition est le fait de changer l’implémentation d’une méthode dans une classe fille.
Dans l"exemple suivant on redéfinit, dans la classe fille "employe", la méthode __str__ définit
dans la classe "person" .
class employe(person) :
def __init__(self,flname,lname, salary) :
super( employe, self ).__init__(flname, lname)
self.salary=salary
def __str__(self ) :
return super(employe, self ).__str__() +’ \n Mon salaire est : ’+ str(self.salary)
a= person("Sami", "Ahmed")
b= employe("Toto", "Titi", 5000)
a.__str__() # retourne "Je suis : Sami Ahmed"
b.__str__() # retourne "Je suis : Toto Titi
Mon salaire est 5000 "

3 Héritage multiple
Python autorise l’héritage multiple. C’est à dire une classe peut être derivée de plusieur
classe à la fois. la syntaxe est :

8
class calassderive( classe1, class2,..., classN)
Bien que ce type d’héritage est autorisé il est préférable de l’éviter car il présente beaucoup
d’anomalie dans son implémentation.