2. PLAN
I. Appréhender le paradigme de la POO
II. Connaître les principaux piliers de la POO
III. Coder des solutions orientées objet
IV.. Manipuler les modules et les bibliothèques
3. INTRODUCTION
• Imaginez que vous devez préparer des plats à manger, donc vous avez besoin des
recettes que cela se traduit en orientée objet.
• Vous êtes le chef de votre code, et préparation de vos plats (que l'on appellera
des classes) avec vos recettes (que l'on appellera des objets ).
4. LES CLASSES
• Une classe contient un état et un comportement.
• L’état fait référence à des données ou des variables. Une classe Cake (Gâteau), par
exemple, peut avoir une variable flavor (saveur).
• Le comportement d’une classe désigne simplement une série de choses que cette
classe peut faire. Ce comportement est contenu dans les méthodes,
6. COMMENT DÉCLARER UNE CLASSE EN PYTHON
• On utilise le mot-clé class, des déclarations de fonctions (def), et des
déclarations d’affectation de variables (x = 3).
7. LES CONSTRUCTEUR
• En Python, le constructeur d'une classe est une méthode spéciale appelée
__init__. Il a pour rôle principal d'initialiser les attributs d'une instance d'une
classe lorsqu'elle est créée.
• Les constructeurs ont pour fonction d'éviter les erreurs en garantissant que
certains attributs de l'objet existent toujours dès sa création.
8. EXEMPLE :
• Créer une classe : Personne qui contient comme attribut le prénom et l'âge
d’utilisateur.
• Créez une méthode Saluer() contient le message suivant : ‘’ Bonjour je suis –
prénom d’utilisateur- et j’ai –âge- ans ‘’
• Faire l’appel de classe avec vos informations.
10. DESTRUCTEUR
• un destructeur est une méthode spéciale qui s'appelle automatiquement
lorsqu'un objet n'est plus utilisé, pour libérer les ressources qu'il occupe. Cette
méthode est nommée __del__ et, comme le constructeur, elle est définie au
sein de la classe.
• En résumé, le destructeur en Python est un moyen d'effectuer des actions de
nettoyage lorsqu'un objet est supprimé, mais il n'est pas toujours
indispensable. Car python utilise garbage collector.
12. MANIPULER LES MÉTHODES
I. Visibilité d’une méthode
I. La visibilité d'une méthode en Python détermine si cette méthode est accessible à
l'extérieur de la classe ou non. Python propose trois niveaux de visibilité :
Méthodes publiques (par défaut) :
Elles peuvent être appelées depuis n'importe où, aussi bien à l'intérieur qu'à l'extérieur de la
classe.
13. Méthodes protégées (préfixées d'un _) :Ces méthodes sont accessibles uniquement à
l'intérieur de la classe et de ses sous-classes (par convention, elles ne devraient pas
être utilisées à l'extérieur).
class Voiture:
def _diagnostic(self):
print("Diagnostic de la voiture en cours.")
14. Méthodes privées (préfixées de __) :Ces méthodes sont uniquement
accessibles dans la classe où elles sont définies (elles sont en réalité name
mangled).
class Voiture:
def __verifier_niveau_huile(self):
print("Vérification du niveau d'huile.")
15. L’ENCAPSULATION
• L'encapsulation est une des pierres angulaires de la Programmation Orientée
Objet. Elle consiste à protéger et cacher les données (attributs) d'une classe,
afin qu'elles ne soient accessibles ou modifiables que de manière contrôlée,
via des méthodes spécifiques (getters, setters).
• Revenant à l’exemple d’exercice de compte bancaire :
16. DE PLUS
• Dans la vraie vie, personne ne devrait pouvoir modifier directement le solde
d'un compte sans passer par une procédure contrôlée (par exemple, un dépôt
ou un retrait).
• Sans encapsulation, rendre ce comportement est dangereux, car tout
utilisateur du programme peut faire n'importe quoi avec les données.
• En utilisant l'encapsulation, nous rendons le solde privé (inaccessible
directement)
18. L'HÉRITAGE EN PYTHON
• L’héritage est une fonctionnalité de la programmation orientée objet qui permet
de créer une nouvelle classe à partir d'une classe existante.
• Syntaxe :
class SuperClasse:
# Code de la super-classe
pass
class SousClasse(SuperClasse):
# Code de la sous-classe pass
20. BREF
• Animal est la super-classe et contient une méthode parler générique.
• Chien est une sous-classe qui hérite de Animal et redéfinit la méthode parler.
• Cela s'appelle la surcharge de méthode : la méthode parler dans Chien
remplace celle dans Animal pour les instances de Chien.
21. Parfois, dans une sous-classe, on souhaite étendre (et non remplacer
complètement) une méthode de la super-classe. pour cela, on utilise
super().
23. 2. HÉRITAGE EN CASCADE
Personne
Nom
CIN
age()
stagiaire
Note1
note2
Moyenne()
Stagiaire 2eme
annee
option
24. POLYMORPHISME
• Le polymorphisme est un concept clé de la programmation orientée objet
(POO).
• En termes simples, il permet à des objets de types différents d'être traités de
manière uniforme.
• Un objet peut prendre plusieurs formes (d'où le nom polymorphisme qui vient
du grec poly = "plusieurs" et morphe = "forme").
25. CONCEPTS
• Polymorphisme de méthode overriding «redéfinition » (ou polymorphisme
d'exécution) : C'est celui où une même méthode se comporte différemment en
fonction de l'objet qui l'appelle. Cela se produit généralement avec des méthodes
redéfinies dans des classes dérivées.
• Polymorphisme de surcharge overloading (ou polymorphisme de compilation) : Il
permet d'avoir plusieurs méthodes avec le même nom mais des signatures
différentes. Cela n’est pas couramment utilisé en Python, car ce langage ne prend
pas en charge la surcharge de méthode comme certains autres langages
26. CARACTÉRISER L’ABSTRACTION
• L’abstraction permet de réduire la complexité et d'obtenir une conception et
une implémentation plus efficaces dans les systèmes logiciels complexes.
• Elle permet aussi de :
• Éviter d'écrire du code de bas niveau.
• Éviter la duplication de code et augmenter la réutilisabilité.
• Pouvoir modifier l'implémentation interne d'une classe objet, sans affecter les
personnes ou codes qui l'utilisent.
27. EXEMPLE
• Supposons, on a :
• une classe Véhicule avec les attributs : prix, marque, couleur, capacité et la
méthode AfficherInfos().
• On crée deux classes filles de cette classe qui sont :
• La classe Moto avec les attributs spécifiques vitesse, modele et les méthodes : AfficherInfos() ,
Accelerer(), Arreter(), AfficherModele().
• La classe Vélo qui a simplement les éléments (méthode et attributs ) hérités.
• Supposons qu’on exige de ne jamais avoir des objets de la classe Véhicule. Autrement
dit, cette classe ne sera jamais instanciée donc cette classe doit être Abstraite.
28. BREF
Une classe est dite abstraite, si elle ne peut être instanciée. Une classe est abstraite si
elle a au moins une méthode abstraite .
Une méthode abstraite est une méthode qui n’a pas de corps, on définit juste le
prototype de la méthode.
Chaque classe fille doit redéfinir la méthode abstraite.
29. ABC signifie Abstract Base
Class (Classe de Base
Abstraite), qui permet de
définir des classes abstraites. .
En résumé, ABC est une classe (dans le modèle abc) utilisée pour créer des classes
abstraites, tandis que abc est le modèle qui contient cette classe et d'autres outils
pour gérer les classes abstraites en Python.
30. EXERCICES PRATIQUES
• Développez le programmes des animaux , en déclarant pour chaque classe la
méthode de son qui va être redéfinit dans les classes filles ( chien et chat ).
Nommez la classe abstraite animal, avec un seul attribut (le nom d’animal).
31. ETUDE DE CAS PRATIQUE
• Vous devez développer un système de gestion de paiements pour une plateforme
e-commerce. Tâche : Concevoir une classe abstraite PaymentProcessor avec des
sous-classes pour gérer différents modes de paiement (Carte bancaire, PayPal,
Crypto-monnaie).
• Vous avez besoin d’une méthode qui affiche le montant à payer pour chaque mode
de paiement.
32. MANIPULER LES INTERFACES
• Une interface est une forme particulière de classe où toutes les méthodes sont abstraites.
• Le décorateur @abstractmethod indique qu'une méthode doit être implémentée dans toute
classe qui hérite de cette classe.
• Si une classe dérivée ne redéfinit pas toutes les méthodes abstraites, elle ne peut pas être
instanciée.
• il est tout à fait possible de créer une classe qui agit comme une interface sans utiliser le
module abc ou hériter de ABC Dans ce cas, il n'y aura aucune contrainte imposée aux classes
qui "implémentent" cette interface. Cela signifie que rien n'empêchera une classe de ne pas
implémenter toutes les méthodes définies dans l'interface.
34. Une classe peut implémenter plusieurs interfaces grâce à l'héritage
multiple.
35. EXERCICE PRATIQUE
• Vous devez créer un programme pour représenter différents types d'animaux.
Tous les animaux partagent des comportements communs :
• Chaque animal peut émettre un son.
• Chaque animal peut se déplacer.
37. RAPPEL
• random : fonctions permettant de travailler avec des valeurs aléatoires
• math : toutes les fonctions utiles pour les opérations mathématiques (cosinus,sinus,exp,etc.)
• sys : fonctions systèmes
• os : fonctions permettant d'interagir avec le système d'exploitation
• time : fonctions permettant de travailler avec le temps
• calendar : fonctions de calendrier
• profile : fonctions permettant d'analyser l'execution des fonctions
• urllib2 : fonctions permettant de récupérer des informations sur internet
• re : fonctions permettant de travailler sur des expressions régulières
38. COMMENT CRÉER UN PACKAGE ?
• Un package en Python est simplement un dossier contenant un fichier spécial nommé
__init__.py. Ce fichier peut être vide ou contenir du code pour initialiser le package.
• Créez un dossier pour votre package
• Choisissez un nom pour votre package, par exemple mon_package, et créez un
dossier portant ce nom.
39. SUITE
• Ajoutez un fichier __init__.py
• Créez un fichier __init__.py à l'intérieur de ce dossier. Ce fichier permet à Python
de reconnaître ce dossier comme un package. Il peut être vide ou contenir du code
d'initialisation.
• Ajoutez des modules (fichiers .py)
• Créez d'autres fichiers Python à l'intérieur du package, par exemple module1.py et
module2.py, contenant des fonctions ou des classes.
40. COMMENT IMPORTER DES MÉTHODES DEPUIS UN
DOSSIER?
• Exemple d’une structure d’un package
• Dans mon_script.py on peut importer les fonctions, les classes ou les methodes
comme suite :
41. EXERCICE D’APPLICATION
• Créer un package pour modéliser une bibliothèque avec des livres et des
auteurs.
• Vous avez besoin de gérer le titre de livre l’année de publication de ce livre
ainsi le nom d’auteur et sa nationalité, et des methodes pour afficher les infos
précédents
• dans un script principal (main.py) importez le package bibliotheque. Créez
plusieurs objets Auteur et Livre.
43. RAPPEL DE :
• Les listes
• Les tuples
• Les dictionnaire
• Les ensembles
44. LES COLLECTIONS
• une collection est une structure de données qui permet de stocker et de manipuler
plusieurs objets. Python propose plusieurs types de collections natives, comme les listes,
les tuples, les dictionnaires et les ensembles. Cependant, en POO, il est souvent utile de
définir des collections personnalisées pour mieux structurer et encapsuler les données.
• Python propose plusieurs types de collections prédéfinies
• Listes (list) : Collection ordonnée et modifiable d'objets.
• Tuples (tuple) : Collection ordonnée et immuable d'objets.
• Dictionnaires (dict) : Collection non ordonnée d'associations clef-valeur.
• Ensembles (set) : Collection non ordonnée et non indexée d'objets uniques
45. COLLECTIONS – CONTAINER
• Le module collections de Python offre des structures avancées qui permettent
d'étendre les collections de base :
46. EXEMPLE D’UTILISATION DE COLLECTION
-namedtuple-
P.S : On peut insérer des instances des classe déjà créer comme des éléments de cette
tuple
47. EXEMPLE D’UTILISATION DE COLLECTION
-deque-
• Un deque (double-ended queue) est une structure de données de la bibliothèque collections en Python qui
permet d'ajouter et de supprimer des éléments des deux côtés (gauche et droite) de manière efficace. Il
est optimisé pour ces opérations, contrairement aux listes Python où les suppressions en début de liste sont
plus coûteuses en temps de calcul.
49. EXEMPLE D’UTILISATION DE COLLECTION
-ChainMap-
• ChainMap un conteneur qui encapsule de nombreux dictionnaires dans une
seule unité.
50. LES EXPRESSIONS RÉGULIÈRE
• Les expressions régulières (regex) sont des motifs utilisés pour rechercher,
correspondre et manipuler du texte selon des règles précises. Elles permettent
d'automatiser le traitement de chaînes de caractères, notamment dans la
validation de données, le filtrage et la recherche.
• Python utilise le module re pour manipuler les expressions régulières.
51. FONCTIONS PRINCIPALES DU MODULE re
Fonction Description
re.match(pattern, string) Vérifie si le début de la chaîne correspond au motif.
re.search(pattern, string)
Recherche la première occurrence du motif dans la
chaîne.
re.findall(pattern, string)
Renvoie une liste contenant toutes les
correspondances.
re.finditer(pattern, string) Renvoie un itérateur sur les correspondances.
re.sub(pattern, replacement, string) Remplace toutes les occurrences du motif.
re.split(pattern, string) Divise la chaîne en fonction du motif.
54. INTRODUCTION
• En python, on peut réaliser des interfaces graphiques.
• Tkinter (Tk interface) est un module intégré à la bibliothèque standard de
Python, permettant de créer des interfaces graphiques :
• des fenêtres,
• des widgets (boutons, zones de texte, cases à cocher, …),
• des évènements (clavier, souris, …).
56. STRUCTURE DE BASE D'UNE APPLICATION TKINTER
• La boucle principale (mainloop())
• La création d'une fenêtre (Tk() et Toplevel())
• Gestion des dimensions et du positionnement (geometry())
• Ajout d’un titre (title())
57. PRINCIPAUX WIDGETS DE TKINTER
• label = tk.Label(fenetre, text="Bienvenue sur Tkinter!") #pour ajouter des textes
• entry = tk.Entry(fenetre) #champ à saisir
• def action():
print("Bouton cliqué!")
bouton = tk.Button(fenetre, text="Cliquez-moi", command=action)
bouton.pack() # exemple de widget de boutton
58. • Gestion de position :
• label.pack(side="top") # side="left" | "right" | "top" | "bottom“
• label.grid(row=0, column=0) # position par grille
entry.grid(row=0, column=1)
• label.place(x=50, y=100) #position en pixel
• zone_texte = tk.Text(fenetre, height=5, width=30) #zone de text
• case = tk.Checkbutton(fenetre, text="Option", variable=var) #case à cocher
• frame = tk.Frame(fenetre, borderwidth=2, relief="ridge") #cadre