Programmation Python
Programmation Orientée Objet POO
python 1. Le concept de POO en Python
La programmation orientée objet, ou POO, est un paradigme (une
philosophie pour écrire du code) de programmation qui permet de structurer
les programmes de manière à ce que les propriétés et les comportements
soient regroupés dans des objets à part.
Les objets peuvent interagir entre eux, cela facilite grandement la
compréhension du code et sa maintenance.
python 2. Les classes 3
• Nous avons vu plusieurs types de base en Python (int pour les entiers, float
pour les flottants, str pour les chaînes de caractères, etc.).
• La notion de classe va en quelque sorte nous permettre de généraliser la
notion de « type » afin de créer de nouvelles structures de données
python 2. Les classes 4
Définition d’une classe
Une classe permet de définir un nouveau type permettant de
créer des instances (des objets/variables) contenant des
données (attributs ) et des fonctions (méthodes ) associées à
ces données.
python 2. Les classes 5
Création d’une classe
Comme dans tout langage oriente objet, il est nécessaire de définir la
manière dont on initialise un objet de cette classe, puis définir les
différentes opérations/fonctions permises avec cet objet.
Pour créer une classe en Python, on utilise l'instruction
class nom_de_la_classe :
Par convention en Python, le nom identifiant d’une classe débute par
une majuscule.
class Point():
"Definition d'un point geometrique"
python 2. Les classes 6
La méthode « constructeur »
On crée ensuite une méthode qui permet de construire les objets, appelé
constructeur via l'instruction : def init (self):
La méthode init () est appelée lors de la création d'un objet.
Pour accéder aux donnés d’un objet dans une de ses méthodes, on utilise le mot clef
self.
class Point ():
"Definition d'un point geometrique"
def init (self,x,y):
[Link] = x
[Link]ée=y
self. abscisse est une manière de stocker une information dans la classe. On parle
d'attribut de classe. Dans notre cas, on stock la valeur x dans l'attribut abscisse .
python 2. Les classes 7
Les objets
Un objet est une instance d'une classe. On peut créer autant d'objets
que l'on désire avec une classe .
>>> P=Point(3,2)
Les attributs de classe
Les attributs de classe permettent de stocker des informations au
niveau de la classe. Elle sont similaires aux variables.
>>> P. abscisse
3
python 2. Les classes 8
Les méthodes
Une méthode de classe est une fonction ou
procédure définie au sein de la classe, permettant de
définir des propriétés ou comportements des objets
d'instances.
python 2. Les classes 9
Exemple
class Point ():
"Definition d'un point geometrique"
def init (self,x,y):
[Link]=x
[Link]ée=y a:x=2y=3
def deplace(self, dx, dy): a:x=5y=8
[Link] = [Link] + dx
[Link]ée = [Link]ée + dy
a = Point(2,3)
print("a : x =", a. abscisse, "y =", a. ordonnée)
[Link](3, 5)
print("a : x =", a. abscisse, "y =", a. ordonnée)
python 2. Les classes 10
Exemple
# Définition d’une classe
class Voiture:
def __init__(self, marque, couleur):
[Link] = marque # Attribut
[Link] = couleur # Attribut
a:x=2y=3
def demarrer(self): # Méthode
a:x=5y=8
print(f"La {[Link]} de couleur {[Link]} démarre.")
# Création d’objets (instances de la classe)
v1 = Voiture("Toyota", "rouge")
v2 = Voiture("BMW", "noire")
# Utilisation des objets
[Link]() #La Toyota de couleur rouge démarre.
[Link]() #La BMW de couleur noire démarre.
python 3. Les méthodes magiques 11
__init__(self, …) Constructeur (initialisation d’un p = Point(2,3) appelle __init__
objet)
__repr__(self) Représentation officielle (debug) repr(p)
__str__(self) Représentation lisible (pour print()) print(p) → "Point(2,3)"
__mul__(self, other) Multiplication * p1 * p2
__sub__(self, other) Soustraction - p1 - p2
__ne__(self, other) Différence != p1 != p2
__add__(self, other) Addition + p1 + p2
python 3. Les méthodes magiques 12
__ge__(self, other) Supérieur ou égal >= p1 >= p2
__gt__(self, other) Supérieur > p1 > p2
__eq__(self, other) Égalité == p1 == p2
__le__(self, other) Inférieur ou égal <= p1 <= p2
__lt__(self, other) Inférieur < p1 < p2
python 3. Les méthodes magiques 13
python 3. Les méthodes magiques 14
python 4. L’héritage de classe 15
Comme tous les langages objets, Python accepte l’héritage,
pour éviter de recopier le code d'une classe.
La méthode d'héritage consiste à créer à partir d'une classe
parent ou (classe mère) une autre classe appelé classe
fille ou (classe enfant) qui hérite toutes les méthodes et
attributs de la classe mère.
La syntaxe générale de l'héritage :
class classe_fille(classe_mère) :
python 4. L’héritage de classe 16
Exemples d'héritages en Python
class Personne:
def init (self,nom,age):
[Link] = nom
[Link]=age
# La classe fille Student hérite de la classe mère Personne
class Student(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 fille
[Link] = filiere
Stud = Student("Ahmed",25,"informatique")
print("Le nom de l'étudiant est : " ,[Link])
Le nom de l'etudiant est : Ahmed
print("L'age de l'étudiant est : " ,[Link]) L'age de l'etudiant est : 25
print("La filière de l'étudiant est : " ,[Link]) La filiere de l'etudiant est : Informatique
python 4. L’héritage de classe 17
Si une classe hérite d'une autre classe, elle hérite aussi les
méthodes de son parent.
class Personne:
def init (self,nom,age):
[Link] = nom
[Link]=age
def afficher(self):
print(" l'age de " ,[Link], " est: ", [Link])
# La classe fille Student hérite de la classe mère Personne
class Student(Personne):
# définition des attributs l'age de Ahmed est: 25
def init (self,nom,age):
# héritage des attributs depuis la classe mère
Personne
Personne. init (self,nom,age)
Stud = Student("Ahmed",25)
[Link]()
python 4. L’héritage de classe 18
Super():
Elle permet d’appeler une méthode (souvent __init__) de la classe parente (superclasse)
à partir d’une classe fille (sous-classe)
Exemple:
class Personne:
def __init__(self, nom):
[Link] = nom
class Etudiant(Personne):
def __init__(self, nom, niveau):
super().__init__(nom) # Appelle le constructeur de Personne
[Link] = niveau
e = Etudiant("Ali", "3ème année")
print([Link], [Link]) # Ali 3ème année
python 4. L’héritage de classe 19
Application:
Créer une classe Etudiant avec :
― Deux attributs; nom et note.
― une méthode set_note(n) qui accepte la note seulement si elle est comprise
entre 0 et 20.
― une méthode get_note() qui retourne la note.
― Créer un objet et1 et tester :
― Donner une note valide (ex: 15)
― Donner une note invalide (ex: 25)
python 4. L’héritage de classe 20
Correction:
class Etudiant:
def __init__(self, nom):
[Link] = nom
[Link] = None
def set_note(self, n):
if 0 <= n <= 20:
[Link] = n
else:
print(f" Note invalide ({n}). La note doit être comprise entre 0 et 20.")
def get_note(self):
#Retourne la note actuelle.
return [Link]
python 4. L’héritage de classe 21
def afficher(self):
print(f"Nom : {[Link]}, Note : {[Link]}")
# --- Programme Principal---
et1 = Etudiant("Ahmed")
et1.set_note(15)
print("Note actuelle :", et1.get_note())
et1.set_note(25)
print("Note actuelle :", et1.get_note())
[Link]()
python 4. L’héritage de classe 22
Un programme principal saisit une chaîne d’ADN valide et une séquence d’ADN
valide (« valide » signifie qu’elles ne sont pas vides et sont formées exclusivement
d’une combinaison arbitraire de "a", "t", "g" ou "c").
1. Écrire une fonction valide qui renvoie vrai si la saisie est valide, faux sinon.
2. Écrire une fonction saisie qui effectue une saisie valide et renvoie la valeur
saisie sous forme d’une chaîne de caractères.
3. Écrire une fonction proportion qui reçoit deux arguments, la chaîne et la
séquence et qui retourne la proportion de séquence dans la chaîne (c’est-à-dire
son nombre d’occurrences).
Le programme principal appelle la fonction saisie pour la chaîne et pour la
séquence et affiche le résultat.
Exemple d’affichage : Il y a 13.33 % de "ca" dans votre chaîne.