M103: Programmer en Orienté Objet: Développement Digital (Tronc Commun)

Office de la formation professionnelle
et de la promotion du travail
Direction de la Recherche et Ingénierie de formation
Secteur : Digital & IA
Manuel des travaux pratiques
M103 : Programmer en Orienté

Objet
1ère Année
Filière :
Développement
Digital
(Tronc commun)
Technicien spécialisé
Direction de la Recherche et L’Ingénierie de Formation
Digital I Infrastructure digitale
Version : 01/12/2021
Concevoir un réseau informatique
3
Remerciements
La DRIF remercie les personnes qui ont contribué à l’élaboration du présent document :
Équipe de conception :
BOUDIAF Saida Digital learning manager/
Project manager
MIHOUBI Fattoum, Cheffe de projet pédagogique/
Ingénieure pédagogique
CROUZOULON Jonathan, Directeur pédagogique/
Chef de projet pédagogique
Équipe de rédaction :
JEMEL Meriam, Assistant Professor in Computer Science
Équipe de lecture :
RAHMANI Abdelhak, Formateur Animateur au CDC Digital & IA
LAOUIJA Soukaina, Formatrice Animatrice au CDC Digital & IA
EL KHATABI GHIZLANE, Formatrice Animatrice au CDC Digital & IA
Les utilisateurs de ce document sont invités à communiquer à la DRIF et au CDC Digital & IA toutes les remarques
et suggestions afin de les prendre en considération pour l’enrichissement et l’amélioration de ce module.
Direction de la Recherche et L’Ingénierie de Formation

Digital & IA I Développement digitale
1
Programmer en Orineté Objet
SOMMAIRE PROGRAMMER EN ORIENTÉ OBJET
01 Partie 1 APPRÉHENDER LE PARADIGME

DE LA POO
Activité 1: Définir une classe
02 Partie 2 CONNAÎTRE LES PRINCIPAUX
PILIERS DE LA POO
Activité 1: Définir l’héritage
Activité 2: Définir le polymorphisme
Activité 3: Caractériser l’abstraction et manipuler les interfaces
03 Partie 3 CODER DES SOLUTIONS ORIENTÉES
OBJET
Activité 1: Coder une solution orientée objet en Python
Activité 2: Manipuler les principaux piliers de la POO en Python
Activité 3: Manipuler les données
Activité4: Utiliser les expression régulières
Activité 5: Administrer les exceptions
04 Partie 4 MANIPULER LES MODULES ET LES
BIBLIOTHEQUES
Activité 1: Manipuler les modules
Activité2: Manipuler les bibliothèques
PARTIE 1
APPRÉHENDER LE PARADIGME DE LA
POO
2 heures
Activité 1
Définir une classe
Compétences visées :
₋ Maitrise de la modélisation d’une classe

₋ Maitrise de la définition des composants d’une classe
₋ Maitrise de la visibilité des composants d’une classe
Recommandations clés :
₋ Faire une bonne lecture de l’énoncé du problème pour

repérer les classes à définir ainsi que ses composantes
2 heures
CONSIGNES
1- Pour le formateur
₋ Demander d’analyser l’énoncé du problème
₋ Demander de repérer les attributs (d’instance et de classe)
₋ Demander de repérer les méthodes: les paramètres et le type de
retour
2- Pour l’apprenant
₋ Analyser l’énoncé du problème
₋ Repérer les attributs (d’instance et de classe)
₋ Repérer les méthodes: les paramètres et le type de retour
3 - Conditions de réalisation
₋ Support de résumé théorique accompagnant
4 - Critères de réussite
₋ Le stagiaire est-il capable de :
o Définir une classe?
o Repérer les attributs d’une classe ?
o Repérer les méthodes d’une classe?
Activité 1
Définir une classe
On souhaite programmer une application de gestion commerciale. Cette application permet à une petite société de gérer les commandes. Nous donnons dans ce qui suit
une description des fonctionnalités attendues de l’application.
Gestion produits :
Chaque produit est caractérisé par sa référence, sa désignation, son prix d’achat, son prix de vente, le nombre d’exemplaires en stock; le nombre de produit
A la création du produit, on lui attribue une référence, un prix d’achat, un prix de vente, un stock nul (quantité=0), et une désignation (petite description du produit). Parmi
les fonctionnalités attendues de l’application de gestion de stock, relative au produit, est de pouvoir retourner le nombre de produits existants, afficher les informations
relatives à un produit, modifier son prix d’achat et son prix de vente, augmenter ou diminuer le nombre d’exemplaires en stock
Gestion des commandes:
Les sorties de stock sont gérées à travers les commandes. Une commande est caractérisée par sa date de création et un ensemble de produits avec les quantités qu’on va
livrer (vendre).
Questions:
• Définir l’ensemble de classes à implémenter pour assurer la gestion commerciale de la société.

• Précisez pour chaque classe: les attributs (d’instance ou de classe) et les méthodes.
• Pour chaque méthode, définissez ses paramètres
Copyright - Tout droit réservé - OFPPT 6

Activité 1
Correction
On souhaite programmer une application de gestion commerciale. Cette application permet à une petite société de gérer les commandes. Nous donnons dans ce qui suit
une description des fonctionnalités attendues de l’application.
Gestion produits :
A la création du produit, on lui attribue une référence, un prix d’achat, un prix de vente, un stock nul (quantité=0), et une désignation (petite description du produit). Parmi
les fonctionnalités attendues de l’application de gestion de stock, relative au produit, est de pouvoir retourner le nombre de produits existants, afficher les informations
relatives à un produit, modifier son prix d’achat et son prix de vente, augmenter ou diminuer le nombre d’exemplaires en stock
Gestion des commandes:
livrer (vendre).
Questions:
• Définir l’ensemble de classes à implémenter pour assurer la gestion commerciale de la société.

• Précisez pour chaque classe: les attributs (d’instance ou de classe) et les méthodes..
• Pour chaque méthode, définissez ses paramètres

Activité 1
Correction
1. Définir l’ensemble de classes à implémenter pour assurer la gestion commerciale de la société.
Produit et commande (pour la classe ligne Commande à voir après)
2. Précisez pour chaque classe: les attributs (statiques et non) et les méthodes (statiques et non).
Analyser le texte suivant pour dégager les attributs de la classe Produit

référence: chaine
désignation: chaine
prixAchat: réel
prixVente: réel
nombreExemplaire: entier
nombreProduit: entier
3. Demander de préciser les attributs d’instance (relatif à un objet) et les attributs de classe relatifs à la classe Produit
référence: chaine
désignation: chaine Attributs d’instances

prixAchat: réel

Activité 1
Correction
prixVente: réel
Attributs d’instances
nombreExemplaire: entier
nombreProduit: entier à attribut de classe
• Analyse du texte ci-dessous pour dégager les méthodes de la classe Produit
A la création du produit, on lui attribue une référence, un prix d’achat, un prix de vente, un stock nul (quantité=0), et une désignation (petite description du produit).à
définir un constructeur à 4 paramètres
• Parmi les fonctionnalités attendues de l’application de gestion de stock, relative au produit, est de pouvoir retourner le nombre de produits existants, afficher les
informations relatives à un produit, modifier son prix d’achat et son prix de vente, augmenter et diminuer le nombre d’exemplaires en stock
Produit
Les méthodes dégagées sont:
-référence: chaine
CréerProduit(référence: chaine, désignation: réel, prixAchat: réel, prixVente)à constructeur -désignation: chaine
-prixAchat: réel
afficherNbProduits()à méthode de classe -prixVente: réel
afficherInformationsProduit() à méthode d’instance -nombreExemplaire: entier
+nombreProduit: entier
setprixAchat(réel) à méthode d’instance c’est un modificateur
+afficherNbProduits():entier
setprixVente (réel) à méthode d’instance c’est un modificateur +CréerProduit(chaine,chaine réel, réel)
dinimuerExemplaire(entier) à méthode d’instance +afficherInformationsProduit()
+setprixAchat(réel)
augmenterExemplaire(entier) à méthode d’instance +setprixVente (réel)
+diminuerExemplaire(entier)
+augmenterExemplaire(entier)
Activité 1
Correction
• Analyse du texte suivant pour dégager les attributs et les méthodes de la classe commande
livrer (vendre). Il est possible d’afficher une commande
• Indication: définir une classe Ligne de commande qui associe pour chaque produit le nombre d’exemplaires vendus.
• Définition de la classe commande

• Attributs sont: date de création (chaine) et TabLigneCommande (tableau de ligne de commande)
• Methode: AfficherCommande()àméthode d’instance
Commande LigneCommande
dateCreation: chaine produit: Produit

TabLigneCommande: tableau de LigneCommande nb: entier
afficherCommande() afficherLigneCommande()

PARTIE 2
CONNAÎTRE LES PRINCIPAUX PILIERS
DE LA POO
3 heures
Activité 1
Définir l’héritage
₋ Manipuler l’héritage des classes
₋ Réviser le principe de l’héritage vu au cours de la

formation
1 heure
CONSIGNES
₋ Demander de définir une relation d’héritage entre les classes
définies
₋ définir une relation d’héritage entre les classes définies
o Dégager les attributs et les méthodes communes dans des
classes définies ?
o Définir une relation d’héritage entre des classes définies
Activité 1
Définir l’héritage
Banque
• Soient les classes suivantes: -NomDirecteur: chaine Employé

• Analysez ces classes et utilisez la généralisation pour -Capital:entier
factoriser au mieux la description des propriétés. -adresseSiège: chaine Directeur
-Nom: chaine
+getNomDirecteur:Chaine -Prenom: chaine
--Nom: chaine
+setNomDirecteur(n:chaine) -dateEmbauche: date
+getCapital(): entier -Prenom: chaine
+setCapital(c: entier) -revenu: réel +getNom:Chaine
+getAdresse():chaine +getNom:Chaine +setNom(n:chaine)
+setAdress( a: chaine) +setNom(n:chaine) +getPrenom:Chaine
Banque(Adresse:chaine) +getPrenom:Chaine +setPrenom(n:chaine)
+setPrenom(n:chaine) +getDate():Date
Client +getRevenu():chaine +setDate(x: Date)
CompteNonRénuméré Mutation( g: Agence): boolean
+setRevenu(x: réel)
-Nom: chaine
-Solde: réel -Prenom: chaine
-numéro: entier -Conseiller:Employé
-Adresse: Agence CompteNonRénuméré Agence
-Comptes: tableau de Compte
+getNom:Chaine -Solde: réel --nomAgence: chaine
+setNom(n:chaine) -numéro: entier
+getPrenom:Chaine -Adresse: chaine
-taux: réel
+setPrenom(n:chaine)
+getDate():Date +getNomAgence:Chaine
+VerserInteret()
+setDate(x: Date) +setNomAgence(n:chaine)
Mutation( g: Agence): boolean
Activité 1
correction
Banque
-NomDirecteur: chaine Employé

-Capital:entier
-adresseSiège: chaine Directeur
-Nom: chaine
+getNomDirecteur:Chaine -Prenom: chaine
-Nom: chaine
+setNomDirecteur(n:chaine) -dateEmbauche: date
+getCapital(): entier -Prenom: chaine
+setCapital(c: entier) -revenu: réel +getNom:Chaine
+getAdresse():chaine +getNom:Chaine +setNom(n:chaine)
+setAdress( a: chaine) +setNom(n:chaine) +getPrenom:Chaine
Banque(Adresse:chaine) +getPrenom:Chaine +setPrenom(n:chaine)
+setPrenom(n:chaine) +getDate():Date
Client +getRevenu():chaine +setDate(x: Date)
CompteNonRénuméré Mutation( g: Agence): boolean
+setRevenu(x: réel)
-Nom: chaine
-Solde: réel -Prenom: chaine
-numéro: entier -Conseiller:Employé
-Adresse: Agence CompteNonRénuméré Agence
-Comptes: tableau de Compte
+getNom:Chaine -Solde: réel --nomAgence: chaine
+setNom(n:chaine) -numéro: entier
+getPrenom:Chaine -Adresse: chaine
-taux: réel
+setPrenom(n:chaine)
+getDate():Date +getNomAgence:Chaine
+VerserInteret()
+setDate(x: Date) +setNomAgence(n:chaine)
Mutation( g: Agence): boolean
Activité 1
correction
Compte
Personne
CompteRénuméré CompteNonRénuméré
Client Directeur Employé

Activité 2
Définir le polymorphisme
₋ Bonne maitrise du concept de polymorphisme en POO
₋ Réviser le principe de l’héritage vu au cours de la

formation
₋ Réviser le principe de polymorphisme vu au cours de
la formation
1 heure
CONSIGNES
₋ Demander s’il est possible d’accéder aux membres des
classes Mère et Fille à partir d’une variable définie
₋ Vérifier s’il est possible d’accéder aux membres des
classes Mère et Fille à partir d’une variable définie et ceci en se
basant sur le principe du polymorphisme
o Appliquer le principe de polymorphisme?
o Décider si à partir d’une variable définie , est possible
d’accéder aux membres d’une classe Mère ou Fille?
Activité 2
• Soient les variables a, b, c suivantes qui font référence à des objets de type classe Mère ou Fille.
Variables Références Objets

Mère
Type Mère a 0x304021 attributsMere

methodesMère()
Type Fille b 0x304055
Type Mère c Fille

0x304555
attributsFille
methodesFille()

Activité 2
• Dites si il est possible d’accéder aux membres des classes Mère et Fille à partir d’une variable. Compléter le tableau par Vrai ou Faux
a b c
attributsMere
methodesMère()
attributsFille
methodesFille()

Activité 2
Correction
• le principe de polymorphisme: le type de la variable est utilisé par le compilateur pour déterminer si on accède à un membre (attribut ou méthode) valide. Exemple
du cours
Variables Références Objets
Type A a1 0x304021 A
methodeA()
Type B b1 0x304055
Type A a2 0x304555 B
methodeB()
b1.MethodeA() à OK car b1 est de type déclaré B qui hérite de A

b1.MethodeB() à OK car b1 est de type déclaré B
a2.MethodeA() à OK car a2 est de type déclaré A
a2.MethodeB()à ERREUR car a2 est de type A (même si le type l’objet référencé est B)

Activité 2
Correction
a b c
attributsMere vrai vrai vrai
methodeMère() vrai vrai vrai
attributsFille faux vrai faux
methodeFille() faux vrai faux

Activité 3
Caractériser l’abstraction et
manipuler les interfaces
₋ Maitrise du concept de classe abstraite

₋ Maitrise du concept d’interface
₋ Réviser le principe de l’abstraction en POO et la

définition des interfaces
1 heure
CONSIGNES
₋ Demander de vérifier le type d’un objet ainsi que le type de
l’objet référencé
₋ Demander de vérifier la relation d’affectation entre des variables
de types différents
₋ Vérifier le type d’un objet ainsi que le type de l’objet référencé
₋ Vérifier la relation d’affectation entre des variables de types
différents
o Distinguer entre le type d’une variable et le type de l’objet
référencé?
o Appliquer le principe de l’abstraction et d’interface en
POO?
Activité 3
Caractériser l’abstraction et manipuler les interfaces
• On vous demande d’analyser chacun des cas suivants d’une manière indépendante des autres. Pour chaque cas, dites s’il y a des instructions erronées.
Classe Abstraire
Interface I Cas 1 :
C1 • X de type C1 fait reference à un objet de type C4
• Y de type C1 fait reference à un objet de type C5
• X=Y
Cas 2 :
• X de type I fait reference à un objet de type C4
Classe Abstraire
Classe C2 • Y de type C3 fait reference à un objet de type C4
C3 • X=Y
Cas 4 :
• X de type C3 fait reference à un objet de type C5
• Y de type C6 fait reference à un objet de type C6
• X=Y
Classe Abstraire
Classe C4 Classe C5
C6

Activité 3
Correction
Cas 1 : correcte
• X de type C1 fait reference à un objet de type C4à correcte

• Y de type C1 fait reference à un objet de type C5 à correcte
• X=Yà correcte
Cas 2 : Faux
• X de type I fait reference à un objet de type C4à correcte

• Y de type C3 fait reference à un objet de type C4à correcte
• X=Yà fausse (car C3 n’implémente pas I)
Cas 3 : Faux
• X de type C3 fait reference à un objet de type C5à correcte

• Y de type C6 fait reference à un objet de type C6à fausse (C6 est abstraite non instanciable)
• X=Y

PARTIE 3
CODER DES SOLUTIONS ORIENTÉES
OBJET
23 heures
Activité 1
Coder une solution orientée
objet en Python
₋ Maitrise du codage d’une classe en Python

₋ Maitrise de la définition des constructeurs
₋ Maitrise de la définition des getters et setters
₋ Maitrise de la définition des méthodes
₋ Maitrise de la surcharge des opérateurs
₋ Réviser les notions théoriques relatives à la définition

d’une classe
4 heures
CONSIGNES
₋ Demander de définir le constructeur d’une classe
₋ Demander de définir les getters et setters pour les attributs
d’une classe
₋ Demander de définir les méthodes d’une classe
₋ Demander d’appliquer le surcharge des opérateurs
₋ Définir le constructeur d’une classe
₋ Définir les getters et setters pour les attributs d’une classe
₋ Définir les méthodes d’une classe
₋ Appliquer le surcharge des opérateurs
₋ Installation de IDLE Python 3.9 ou de l’environnement de
développement Python PyCharm 2021.2.1
o Définir une classe avec son constructeur, ses attributs et
ses méthodes?
Activité1
Coder une solution orientée objet en Python
Considérons une classe appelée Point ayant deux attributs privés __abs (abscisse du point) et __ord (ordonnée du point) et un attribut statique nb qui représente le
nombre de point crées
1. Définissez la classe Point et un constructeur à deux paramètres.
2. Définissez les getters et setters pour les deux attributs en utilisant le décorateur @property
3. Définissez la méthode__ str ()__qui retourne la représentation mathématique d’un point : (abs,ord).
4. Proposer une surcharge de l’opérateur == permettant de vérifiant si deux point p1(x1,y1) et p2(x2,Y2) sont égaux ou non(x1=x2 et y1=y2)
5. Ecrivez la méthode calculerdistance(self) qui permet de calculer la distance entre le point de l’objet courant (self) et l’objet p passé en paramètre. Nous rappelons que
la distance entre deux points A(x1,y1) et B(x2,y2), en mathématiques, est égale à: . Vous pouvez utiliser la fonction math.sqrt(a) pour calculer la
racine carrée de a et math.pow(x, y) pour calculer x puissance y
6. Ecrivez la fonction calculermilieu(self) qui permet de calculer et de retourner un objet correspondant au milieu du segment défini par le point de l’objet courant (this)
et l’objet Point p passé en paramètre. Nous rappelons que les coordonnées d’un point M(xM,yM) milieu de A(x1,y1) et B(x2,y2), en mathématiques, sont :
xM=(x1+x2)/2, yM=(y1+y2)/2
Considérons maintenant une deuxième classe appelée TroisPoints ayant les attributs __point1, __ point2 et __ point3 qui sont de type Point
7. Définissez les getters/setters (avec le décorateur @property) et un constructeur acceptant trois paramètres.
8. Ecrivez une méthode sontalignes(self) qui retourne True si les trois points point1 , point2 et point3 sont alignés, False sinon. Nous rappelons que trois points A, B et C
sont alignés si AB = AC + BC, AC = AB + BC ou BC = AC + AB (AB désignant la distance séparant le point A du point B, pareillement pour AC et BC).
9. Ecrivez une méthode estisocèle(self) qui retourne True si les trois points point1, point2 et point3 forment un triangle isocèle, False sinon. Nous rappelons qu’un triangle
ABC est isocèle si AB = AC ou AB = BC ou BC = AC.

Activité1
Coder une solution orientée objet en Python
10. Implémentez une version statique (méthode décorée par @staticmethod) des deux méthodes calculant la distance et le milieu.
11. Dans un fichier main.py, testez toutes les classes et méthodes que vous avez implémentées.

Activité1
Correction
1. Définissez la classe Point et un constructeur à deux paramètres
• Rappeler la notion d’attribut statique et comment le déclarer dans une classe class Point:
nb=0
Un attribut statique est lié à la classe et pas à une instance def __init__(self, abs,ord):
self.__abs = abs
• Rappeler le rôle du constructeur pour l’initialisation des attributs
self.__ord = ord
Initialiser les attribut lors de l’instanciation d’un objet Point.nb = Point.nb + 1
@property
2. Définissez les getters et setters pour les deux attributs en utilisant le
def getAbs(self):
décorateur @property return self.__abs
• Questionner sur le rôle des getters et des setters @property

def getOrd(self):
Ils permettent de retourner ou modifier les attributs (des méthodes publiques)
return self.__ord
• Rappeler comment les définir avec le décorateur @property
@property
def setAbs(self, abs):
self.__abs=abs
@property
def setOrd(self, ord):
self.__abs = ord

Activité1
Correction
3. Définissez la méthode __str ()__qui retourne la représentation mathématique d’un point : (abs,ord).
def __str__ (self):

return "(" + str(self.__abs) + "," + str(self.__ord) + ")"
4. Proposer une surcharge de l’opérateur == permettant de vérifiant si deux point p1(x1,y1) et p2(x2,Y2) sont égaux ou non(x1=x2 et y1=y2)
• Questionner sur la notion de surcharge des opérateurs
• Revenir à l’exemple du cours
def __eq__(self, p):

return (self.__abs==p.getAbs) and (self.__ord==p.getOrd)
5. Ecrivez la méthode calculerdistance(self) qui permet de calculer la distance entre le point de l’objet courant (self) et l’objet p passé en paramètre
• Rappeler la formule de calcul de la distance entre deux points
• Rappeler le fait d’importer la bibliothèque math pour utiliser les fonction sqrt et pow
import math
………………….
………………….
def calculerdistance(self, pt):
d=math.sqrt(math.pow((self.__abs-pt.getAbs) , 2)+math.pow((self.__ord-pt.getOrd),2))
return d

Activité1
Correction
6. Ecrivez la fonction calculermilieu(self) qui permet de calculer et de retourner un objet correspondant au milieu du segment défini par le point de l’objet courant
(this) et l’objet Point p passé en paramètre
• Même démarche que la fonction précédente
def calculermilieu(self, pt):

absm=(self.__abs + pt.getAbs)/2
ordm = (self.__ord + pt.getOrd) / 2
return Point(absm, ordm)
Considérons maintenant une deuxième classe appelée TroisPoints ayant les attributs __point1, __ point2 et __ point3 qui sont de type Point
7. Définissez les getters/setters (avec le décorateur @property) et un constructeur acceptant trois paramètres.
• Questionner sur le type des attributs de la classe TroisPoints

Les attributs sont de type Point mais en Python on ne spécifie pas le type des variables

Activité1
Correction
class TroisPoint:
def __init__(self, point1,point2, point3):
self.__point1 = point1
@property
def getPoint1(self):
return self.__Point1
@property
@property
@property
def setPoint1(self, p1):
self.__point1 = p1
@property
self.__point2 = p2
@property
self.__point3 = p3

Activité1
Correction
8. Ecrivez une méthode sont alignes(self) qui retourne True si les trois points point1 , point2 et troisi`point3 sont alignés, False sinon
9. Ecrivez une méthode est isocèle(self) qui retourne True si les trois points point1, point2 et point3 forment un triangle isocèle, False sinon
def sontalignes(self):
ab=self.__point1.calculerdistance(self.__point2)
ac = self.__point1.calculerdistance(self.__point3)
bc = self.__point2.calculerdistance(self.__point3)
if (ab==ac+bc)or(ac==ab+bc)or(bc==ac+ab):
return True
else:
return False
def estisocele(self):
ab = self.__point1.calculerdistance(self.__point2)
ac = self.__point1.calculerdistance(self.__point3)
bc = self.__point2.calculerdistance(self.__point3)
if (ab == ac) or (ab == bc) or (bc == ac):
return True
else:
return False

Activité1
Correction
10. Implémentez une version statique (méthode décorée par @staticmethod) des deux méthodes
calculant la distance et le milieu.

• Rappel sur la notion d’une méthode statique: Une méthode statique ne nécessite pas qu’une instance soit créée pour être appelée. C’est donc une méthode n’ayant
pas besoin du paramètre self. Elle est appelée par le nom de la classe: NomClass.methode
• Ainsi il faut changer les paramètre des méthodes précédentes en mettant deux attributs p1 et p2 et en enlevant l’attribut self
@staticmethod
def StaticCalculerdistance(pt1, pt2):
d = math.sqrt(math.pow((pt1.getAbs - pt2.getAbs), 2) + math.pow((pt1.getOrd - pt2.getOrd), 2))
return d
@staticmethod
def StaticCalculermilieu(pt1, pt2):
absm = (pt1.getAbs + pt2.getAbs) / 2
ordm = (pt2.getOrd + pt2.getOrd) / 2
return Point(absm, ordm)

Activité1
Correction
• Rappeler le fait qu’il faut importer les classes Point TroisPoints

• Questionner sur l’instanciation des objets de type Point et TroisPoints (appel du constructeur)
from Point import Point, TroisPoint
if __name__ == '__main__':
p1 = Point(3, 6)
p2 = Point(3, 9)
p3 = Point(6, 6)
p4 = Point(6, 6)
print ("le nombre de point créé est = " + str(Point.nb))
print("Vérification si p1 et p2 sont égaux")
print (p1==p2)
print("Appel methode non statique-->La distance entre p1 et p2= "+str(p1.calculerdistance(p2)))
print("Appel methode statique-->La distance entre p1 et p2= " + str(Point.StaticCalculerdistance(p1, p2)))
pt = TroisPoint(p1, p2, p3)

print(" p1, p2 et p3 sont allignés (True/false)--> " + str(pt.sontalignes()))

Activité 2
Manipuler les principaux piliers
de la POO en Python
₋ Manipulation de l’héritage en Python

₋ Manipulation de la chainage des constructeurs
₋ Manipulation de la redéfinition des méthodes
₋ Manipulation des classes abstraites en Python
₋ Révision du support théorique
10 heures
CONSIGNES
₋ Demander de définir la relation d’héritage entre les classes
₋ Demander d’appliquer le principe de chainage de constructeur
₋ Demander d’appliquer le principe de la redéfinition des
méthodes
₋ Demander d’appliquer le principe de la classe abstraite
₋ Définir la relation d’héritage entre les classes
₋ Appliquer le principe de chainage de constructeur
₋ Appliquer le principe de la redéfinition des méthodes
₋ Appliquer le principe de la classe abstraite
o Définir une relation d’héritage?
o Appliquer le chainage des constructeurs?
o Appliquer la redéfinition des méthodes?
o Définir une classe abstraite?
Activité 2
Manipuler les principaux piliers de la POO en Python
Nous voulons écrire un programme en Python servant à déterminer les prix de vente pour le compte d’une entreprise qui achète des produits élémentaires pour les utiliser
dans la fabrication d’autres produits dits composés.
Dans ce système d’information, un produit ne peut être qu’élémentaire ou composé. Pour chaque produit composé, il faut connaître sa composition (ou constitution),
c'est-à-dire les produits élémentaires qui entrent dans sa fabrication avec les quantités utilisées.
Exemple : P1 est élémentaire, P2 est élémentaire, P3 est constitué de 2 unités de P1, et 4 unités de P2, P4 est constitué de 3 unités de P2 et de 2 unités de P1
1. Définissez les classes suivantes :
Classe composition ayant :

-Deux attributs privés __produit et __quantité
-Un constructeur à deux paramètres
-les getters et setters pour les deux attributs en utilisant le décorateur @property
Classe produit ayant :
-Deux attributs privés __nom et __code

-Un constructeur à deux paramètres
-les getters pour les deux attributs en utilisant le décorateur @property
-une méthode abstraite getPrixHT

Activité 2
Classe produit élémentaire ayant :
• un attribut privé __prixAchat

• Un constructeur
• une méthode __str ()__ qui retourne les informations sur un produit élémentaire
• une méthode getPrixHT qui retourne le prixAchat d’un produit élémentaire
Classe produit composé ayant :
• un attribut privé __fraisFabrication, qui représente le coût engendré par la fabrication d’un produit à partir de ses composants (la valeur des composants n’est pas
considérée)
• un attribut tauxTVA qui est le même pour tous les produits composés (18%)
• un attribut privé __listeContituants qui représente un tableau de compositions.

• Un constructeur
• les getters pour les attributs en utilisant le décorateur @property

• une méthode __str ()__ qui retourne les informations sur un produit composé
• une méthode getPrixHT qui calcule et retourne le prix hors taxe qui est la somme des prix hors taxe de tous les constituants majoré par les frais de fabrication du produit
en question.

Activité 2

Activité 2
Correction
1. Définissez les classes suivantes : class composition:

def __init__(self, quantite, produit):
Classe composition ayant :
self.__produit = produit
-Deux attributs privés __produit et __quantité self.__quantite = quantite
-Un constructeur à deux paramètres @property

def getProduit(self):
-les getters et setters pour les deux attributs en utilisant le décorateur @property return self.__produit from abc import ABC, abstractmethod
@property class Produit(ABC):

Classe produit ayant : def getQuantite(self): def __init__(self, nom, code):
return self.__quantite self.__nom= nom
-Deux attributs privés __nom et __code self.__code = code
-Un constructeur à deux paramètres @property

def getNom(self):
-les getters pour les deux attributs en utilisant le décorateur @property
return self.__nom
-une méthode abstraite getPrixHT
@property
• Rappel sur la notion de méthode abstraire et son utilité def getCode(self):
return self.__code
C’est une méthode sans code qui doit être implémentée dans les classes dérivées de
Produit
@abstractmethod
def getPrixHT(self):
pass

Activité 2
Correction
Classe produit élémentaire ayant :
-un attribut privé prixAchat

-Un constructeur class ProduitElementaire(Produit):
-Une méthode str () qui retourne les def __init__(self, nom, code, prix):
Produit.__init__(self, nom, code)
informations sur un produit élémentaire self.__prix= prix
-Une méthode getPrixHT qui retourne le prixAchat d’un produit élémentaire
@property
• La classe ProduitElementaire est une classe fille de Produit et elle doit def getPrixHT(self):
obligatoirement implémenter la méthode getPrixHT return self.__prix
• Les attributs hérités de la classe mère sont non et code et ils sont initialisés def __str__(self):
en faisant au constructeur de la classe mère return "Produit Elementaire : nom=" + str(self.getNom) + " code = " +
str(self.getCode) + " prix= " + str(self.__prix)
• La méthode __str() retourne une chaine de charactères décrivant un
Produit élémentaire (non, code,…)

Activité 2
Correction
Classe produit composé ayant :
-un attribut privé __fraisFabrication, qui représente le coût engendré par la fabrication d’un produit à partir de ses composants (la valeur des composants n’est pas
considérée)
-un attribut __tauxTVA qui est le même pour tous les produits composés (18%)
-un attribut privé listeContituants qui représente un tableau de compositions.
-Un constructeur
les getters pour les attributs en utilisant le décorateur @property
-une méthode __str () qui retourne les informations sur un produit composé
-une méthode getPrixHT qui calcule et retourne le prix hors taxe qui est la somme des prix hors taxe de tous les constituants majoré par les frais de fabrication du produit
en question. Lorsqu’un constituant coïncide avec un produit élémentaire, on utilise son prix d’achat.
• tauxTVA est un attribut de classe puisqu’il est commun pour tous les produits Composés
• L’attribut listeContituants est un tableau de Consttituants

Activité 2
Correction
class ProduitCompose(Produit):
tauxTva=8
def __init__(self,nom, code, fraisFab,listeContituants):
self.__fraisFab = fraisFab
self.__listeContituants=listeContituants
@property
def getfraisFab(self):
return self.__fraisFab
def getPrixHT(self):
m=0.0
for x in self.__listeContituants:
m=m+(x.getProduit.getPrixHT*x.getQuantite)
m=m+m*self.__fraisFab/100
return m
def __str__(self):
return "Produit composé : nom=" + str(self.getNom) + " code = " + str(self.getCode) + " prix= " + str(self.getfraisFab) + " Tva= "+ str(ProduitCompose.tauxTva)

Activité 2
Correction
from Produit import Produit, ProduitElementaire,ProduitCompose,composition, LengthListContituantsError
if __name__ == '__main__':
p1=ProduitElementaire("P1","1",19.1)
print(p1)
p2 = ProduitElementaire("P2", "2", 20)
print(p2)
c1=composition(2,p1)
c2 = composition(2, p2)
tabConstituant=(c1,c2)
p3=ProduitCompose("P3","3",10,tabConstituant)
print(p3)
print("Prix TTC =" + str(p3.getPrixHT()))

Activité 3
Manipuler les données
₋ Maitrise des structures de données liste et Collection

en Python
₋ Comprendre la différence entre les différentes

structures de données en termes de définition et
manipulation
4 heures
CONSIGNES
₋ Demander de définir une liste
₋ Demander de définir un namedtuple
₋ Demander de définir un defaulttdict
₋ Demander de définir un deque
₋ Définir une liste
₋ Définir un namedtuple
₋ Définir un defaulttdict
₋ Définir un deque
o Définir une liste et une collection?
o Manipuler les collections?
Activité 3
Manipuler les données
Cette activité est une suite de l’activité précédente
1. Créer une liste ListeProduit contenant la liste de tous les produits (élémentaires/ composés) crées
2. Pour chaque produit de ListeProduit, créer un objet Description de type namedtuple
Description= namedtuple('Description’, ['Produit', 'Détail’])
Le champ Produit: correspond au nom du produit

Le champ Détail: présente une description textuelle du produit
Par exemple:
• Si le produit P1 est un produit élémentaire, le champ nom =‘’P1 ’’ et le champ Détail=‘’ P1 est un produit Elémentaire’’
• Si le produit P3 est un produit composé de P1 et P2, le champ nom=‘’P3’’ et le champ Détail est’’ P3 est composé de P1 et P2 ’’
3. Convertissez chaque instance de Description créée en un dictionnaire
4. Créer ListeDescription un objet de type defaulttdict contenant toutes les descriptions des produits
5. Créer un objet DeqDescription de type deque. Ajouter les éléments de ListeDescription dans DeqDescription

Activité 3
Correction
1. Créer une liste ListeProduit contenant les produits (élémentaires/ composés) crées.
• La notion de Liste: Une liste est une collection qui est commandée et modifiable
print(p1)
print(p2)
ListeProduit=[p1,p2,p3]
print (ListeProduit)
2. Pour chaque produit de ListeProduit, créer un objet Description de type namedtuple

Description= namedtuple('Description’, ['Produit', 'Détail’])
Le champ Produit: correspond au nom du produit
Le champ Détail: présente une description textuelle du produit

Activité 3
Correction
• Rappelons le rôle de la classe namedtuple: La classe namedtuple du module collections permet d'ajouter des noms explicites à chaque élément d'un tuple pour
rendre ces significations claires dans un programme Python
• La Syntaxe de déclaration d’un namedtuple
Description= namedtuple('Description',['Produit', 'Détail'])
• La méthode de vérification du type d’un objet
Utiliser la méthode isinstance pour vérifier le type d’un objet
if (isinstance(x,ProduitElementaire)):
Description= namedtuple('Description',['Produit', 'Détail’])

for x in ListeProduit:
nom=x.getNom
des=x.getNom+" "+ "est un produit Elémentaire"
else:
consituants=""
for i in x.getlisteContituants:
consituants=consituants+","+ (i.getProduit).getNom
des=x.getNom + " est un produit Composé de"+ consituants
d=Description(nom,des)

Activité 3
Correction
3. Convertissez chaque instance de Description créée en un dictionnaire
• La méthode permettant de convertir un objet nametuple en un dictionnaire: La

méthode__asdict()
Description= namedtuple('Description',['Produit', 'Détail’])

for x in ListeProduit: ListeProduit=[p1,p2,p3]
nom=x.getNom print (ListeProduit)
if (isinstance(x,ProduitElementaire)): ListeDescription=defaultdict(list)
des=x.getNom+" "+ "est un produit Elémentaire" Description= namedtuple('Description',['Produit', 'Détail'])
else: k=0
consituants="" for x in ListeProduit:
for i in x.getlisteContituants: k=k+1
consituants=consituants+","+ (i.getProduit).getNom nom=x.getNom
des=x.getNom + " est un produit Composé de"+ consituants if (isinstance(x,ProduitElementaire)):
d=Description(nom,des) des=x.getNom+" "+ "est un produit Elémentaire"
print(d._asdict()) else:
consituants=""
4. Créer ListeDescription un objet de type defaulttdict contenant toutes les descriptions
des produits
• Rappelons le rôle de la classe defaultdict: defaultdict du module de collections qui d=Description(nom,des)
permet de rassembler les informations dans les dictionnaires de manière rapide et print(d._asdict())
concise. defaultdict ne soulève jamais une KeyError. ListeDescription[k]=d
print(ListeDescription)

Activité 3
Correction
5. Créer un objet DeqDescription de type deque. Ajouter les éléments de ListeDescription dans DeqDescription
ListeProduit=[p1,p2,p3]
print (ListeProduit)
ListeDescription=defaultdict(list)
Description= namedtuple('Description',['Produit', 'Détail'])

k=0
for x in ListeProduit:
k=k+1
nom=x.getNom
des=x.getNom+" "+ "est un produit Elémentaire"
else:
consituants=""
d=Description(nom,des)
print(d._asdict())
ListeDescription[k]=d
print(ListeDescription)
f=deque()
for i in ListeDescription.keys():
f.append(ListeDescription[i])
print(f)
Activité 4
Utiliser les expressions
régulières
₋ Maitriser la définition et la manipulation des

expressions régulières
₋ Révision du support théorique
3 heures
CONSIGNES
₋ Demander de définir une expression régulière
₋ Demander de manipuler une expression régulière
₋ Définir une expression régulière
₋ Manipuler une expression régulière
o Définir une expression régulière
o Manipuler une expression régulière
Activité 4
Utiliser les expressions régulières
Soit exemple la description textuelle d’un ensemble de produit
exemple='''
P1 est un produit composé de P2 et P3
P2 est un produit élémentaire
P4 est un produit élémentaire
P9 est un produit composé de P1, P6 et P4
P11 est un produit composé de P5 et P3 '‘’
Utiliser les expressions régulières pour:
1. Trouver tous les produits élémentaires
2. Les produits composés de trois produits
3. Les produits composés seulement des produits P3 et P5
4. Les produits composés qui n’ont pas P2 dans leurs compositions
5. Les produits qui composent P9

Activité 4
Correction
Utiliser les expressions régulières pour:
1. Trouver tous les produits élémentaires
#les produits élémentaires

expression0 =re.compile(r'P\d+ est un produit élémentaire')
ex0=expression0.findall(exemple)
print(ex0)
2. Les produits composés de trois produits
#les produits composés de trois produits

expression1 =re.compile(r'P\d+ est un produit composé de P\d+, P\d+ et P\d+')
print(ex1)
3. Les produits composés seulement des produits P3 et P5
#les produit composé de p3 et p5

expression2 =re.compile(r'P\d+ est un produit composé de P[3|5] et P[3|5]')
print(ex2)

Activité 4
Correction
4. Les produits composés qui n’ont pas P2 dans leurs compositions
#les produits composés qui n'ont P2 dans leur composition

expression3 =re.compile(r'P\d+ est un produit composé de P[^2],* P[^2]* et P[^2]')
print(ex3)
5. Les produits qui composent P9
#la composition du produit composants P9

expression4 =re.compile(r'P9 est un produit composé de (?P<premier>P\d+), (?P<deuxième>P\d+) et (?P<troisième>P\d+)')
ex4=expression4.search(exemple)
print(ex4.group('premier'))
print(ex4.group('deuxième'))
print(ex4.group('troisième'))

Activité 5
Administrer les exceptions
₋ Définir des exceptions personnalisées en Python

₋ Gérer les exceptions en Python
₋ Bonne révision du résumé théorique
2 heures
CONSIGNES
₋ Demander de définir une exception qui hérite de la classe
Exception
₋ Demander de lever une exception
₋ Demander d’attraper une exception quand elle survient (bloc try
et except)
₋ Définir une exception qui hérite de Exception
₋ Lever une exception
₋ Attraper une exception quand elle survient (bloc try et except)
o Définir une exception?
o Lever une excepter?
o Attraper une exception dans un bloc Python?
Activité 5
1. Modifier la classe produitComposé pour qu’elle lève une exception lorsque le nombre de constituants d’un produit composé est inférieur à 3
• Le type d’exception à lever: Il s’agit d’une exception personnalisée

• Les étapes à suivre pour lever une exception
a. Définir une exception qui hérite de Exception
b. Lever une exception

c. Attraper cette exception quand elle survient (bloc try et except)
Définir l’exception Lever l’exception
class ProduitCompose(Produit):
class LengthListContituantsError(Exception):
tauxTva=8
def __init__(self, message):
def __init__(self,nom, code, fraisFab,listeContituants):
self.__messsage = message
if len(listeContituants) <=2:
@property
raise LengthListContituantsError("taille du tableau est fausse")
def getMessage(self):
return self.__messsage
self.__fraisFab = fraisFab
self.__listeContituants=listeContituants

Activité 5
Attraper l’exception lors de l’appel du constructeur de la classe ProduitCompose
if __name__ == '__main__':
print(p1)
print(p2)
try:
print(p3)
print("Prix TTC =" + str(p3.getPrixHT()))
except LengthListContituantsError as e:
print(e.getMessage)

PARTIE 4
MANIPULER LES MODULES ET LES
BIBLIOTHEQUES
16 heures
Activité 1
Manipuler les modules
₋ Maitrise de la création et de l’importation d’un

module
₋ Maitriser les différents types d’importation
4 heures
CONSIGNES
₋ Demander de créer un module
₋ Demander d’importer un module
₋ Créer un module
₋ Importer un module
o Créer un module?
o Appliquer les différents types d’importation d’un module
Activité 1 :
Manipuler les modules
• On souhaite créer une application de gestion des comptes bancaires. On

simplifiera les types de comptes bancaires en considérant le diagramme suivant :
1.Ecrire les modules Compte.py, CompteCourant.py et CompteEpargne.py

définissant respectivement les classes Compte, CompteCourant et CompteEpargne.
2.Ecrire pour chaque classe un constructeur approprié.

3.Ecrire les getters correspondant à chaque attribut.
4. Ecrire la méthode __str() pour chaque classe permettant de construire une chaine
représentant les informations caractérisant un de ces comptes bancaires.

Activité 1
Correction
class Compte:
nb = 0
def __init__(self,proprietaire,solde):
self.__numero= Compte.nb+1
self.__proprietaire = proprietaire Définition de getter
self.__solde=solde
@property
def getNum(self):
return self.__numero
@property
def getProp(self):
return self.__proprietaire
@property
def getSolde(self):
return self.__solde
def __str__(self):
return "Numéro Compte :" + str(self.getNum) + " propriétaire = " + str(self.getProp) + " Solde Initial= " + str(
self.getSolde)

Activité 1
Correction
from .Compte import Compte

class CompteCourant(Compte):
def __init__(self, proprietaire, solde, montantDecouvert): Importation de la classe Compte du module Compte
Compte.__init__(self,proprietaire, solde )
self.__montantDecouvert=montantDecouvert
print(Compte.nb)
@property Constructeur de compteCourant
def getMontantDecouvert(self):
return self.__montantDecouvert Appel du constructeur de la classe mère
def __str__(self):
return Compte.__str__(self) + "Montant découvert " + self.getMontantDecouvert
from .Compte import Compte

class CompteEpargne(Compte):
def __init__(self,proprietaire,solde,interet):
Compte.__init__(self,proprietaire, solde)
self.__interet=interet
print(Compte.nb)
@property
def getInteret(self):
return self.__interet
@property
def getInteret(self):
return self.__interet
def __str__(self):
return Compte.__str__(self) + "Interet " + self.getInteret

Activité 2
Manipuler les bibliothèques
₋ Bonne maitrise de la création des bibliothèques et

leurs importation
₋ Intégration des bibliothèques standards
₋ Manipulation de la bibliothèque graphique tkinter

₋ Suivie des exemples présents dans le résumé
théorique
12 heures
CONSIGNES
₋ Demander de créer une bibliothèque
₋ Demander d’importer une bibliothèque
₋ Demander de manipuler la bibliothèque tkinter
₋ Créer une bibliothèque
₋ Importer une bibliothèque
₋ Manipuler la bibliothèque tkinter
o Créer une bibliothèque?
o Importer une bibliothèque?
o Créer une interface graphique avec tkinter?
Activité 2 :
Manipuler les bibliothèques
1. Créer une bibliothèque BibCompte Contenant les modules Compte.py, CompteEpargne.py et CompteEpargne.py crées précédemment
2. Dans le module InterfaceCompte.py, réaliser une interface graphique pour l’application de création de comptes dans une banque. L’interface une fois réalisée sera
constituée des éléments présents dans la Figure ci-dessous.
Champs texte toujours inactif contenant automatiquement le numéro du

compte à créer (numéro séquentiel)
Champs texte actif sauf s’il s’agit d’un compte épargne
Champs texte actif sauf s’il s’agit d’un compte courant
Le clic sur le bouton entraine l’insertion du nouveau compte dans le table

Activité 2
Correction
1-Créer une bibliothèque BibCompte Contenant les modules Compte.py, CompteEpargne.py et CompteEpargne.py crées précédemment
• Créer Le dossier BibCompte qui les modules Compte.py, CompteEpargne.py et CompteEpargne.py ainsi que le fichier __init__.py
• Le fichier setup.py qui contient la fonction setup permettant l’installation de la librairie sur le système
from setuptools import setup
setup(
name="BibCompte",
version="0.0.1",
author="authorX",
author_email="authorX@yahoo.fr",
description="courte description de la librairie",
url="lien vers la page officielle de la librairie",
licence='Other/Propertary Licence',
packages={
'BibCompte',
}, Le fichier setup.py
classifiers=[
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
],
install_requires=[
],
includ

Activité 2
Correction
• Une fois l’ensemble des ces éléments est défini, la librairie peut être installée sur le système en utilisant la commande suivante (exécuter la commander dans le
répertoire du projet) :
py setup.py install

Activité 2
Correction
2. Dans le module InterfaceCompte.py, réaliser une interface graphique pour l’application de création de comptes dans une banque. L’interface une fois réalisée sera
constituée des éléments présents dans la Figure ci-dessous.
• Création des composants pour le numéro de compte, le propriétaire et le solde initial
import tkinter as tk v=tk.IntVar()
from tkinter import ttk case1=tk.Radiobutton(variable = v, value='1')
from BibCompte import Compte, CompteEpargne, CompteCourant case2=tk.Radiobutton(variable = v, value='2')
case1.config(text='Courant')
root = tk.Tk() case2.config(text='Epargne')
root.geometry('1200x600') v.set ('1')
numLabel = tk.Label(text='Numéro:') TypeLabel.place(x=20, y=110 )
numLabel1=tk.Label(text='1') case1.place (x= 100, y =110)
numLabel1.config(state=tk.DISABLED) case2.place (x= 240, y =110)
numLabel.place (x= 20, y =20) case1.config(state=tk.NORMAL)
numLabel1.place (x= 100, y =20) tauxIntLabel = tk.Label(text='Taux Interêt')
propLabel = tk.Label(text='Propriétaire:') tauxIntText=tk.Entry('')
propText=tk.Entry('') pourcentLabel = tk.Label(text='%')
propLabel.place (x= 20, y =50) tauxIntLabel.place(x=20, y=140 )
propText.place (x= 100, y =50) tauxIntText.place (x= 100, y =140)
SoldeLabel = tk.Label(text='Solde Initial:') pourcentLabel.place (x= 240, y =140)
SoldeText=tk.Entry('') decouvertLabel = tk.Label(text='M. Découvert')
euroLabel = tk.Label(text='Euro') decouvertext= tk.Entry('')
SoldeLabel.place (x= 20, y =80) decouvertEuroLabel = tk.Label(text='Euro')
SoldeText.place (x= 100, y =80) decouvertLabel.place(x=20, y=170 )
euroLabel.place(x=240,y=80) decouvertext.place (x= 100, y =170)
TypeLabel = tk.Label(text='Type:') tauxIntText.config(state=tk.DISABLED)

Activité 2
Correction
• Création du bouton et du tableau
ajouter= tk.Button(text='Création Compte')

ajouter.place (x= 100, y =210)
area=('#', 'Numéro', 'Propriétaire', 'soldeInitial', 'type', 'Taux Intérêt', 'Montant Découvert')
ac=('all','n','e','s','ne','nw','sw')
tv=ttk.Treeview(root,columns=ac,show='headings',height=7)
for i in range(7):
tv.column(ac[i],width=120,anchor='e')
tv.heading(ac[i],text=area[i])
tv.place (x= 150, y =300)

Activité 2
Correction
• Définition de la fonction add() permettant d’ajouter un nouveau compte dans le tableau avec les données saisies
####################################################
o=""
def add():
print(str(v.get()))
if(str(v.get()) =='1'):
o='courant'
c = CompteCourant.CompteCourant(propText.get(), SoldeText.get(), decouvertext.get())
cc = ('', str(Compte.Compte.nb), propText.get(), SoldeText.get(), 'Courant', '',
decouvertext.get())
else:
o='epargne'
c = CompteEpargne.CompteEpargne(propText.get(), SoldeText.get(), tauxIntText.get())
cc = ('', str(Compte.Compte.nb), propText.get(), SoldeText.get(), 'Epargne',
tauxIntText.get(),'')
numLabel1.config(text=str(Compte.Compte.nb+1))
tv.insert('','end', values=cc)
propText.delete(0,'end')
SoldeText.delete(0,'end')
decouvertext.delete(0,'end')
tauxIntText.delete(0,'end')

Activité 2
Correction
• Définition de la fonction modifVisib() permettant gérer la visibilité des champs de texte taux interêt et montant de découvert
• Programmation de l’évènement sur le bouton ainsi que sur les boutons radio
def modifVisib(evt):
print(str(v.get()))
if (str(v.get()) == '2'):
tauxIntText.config(state=tk.DISABLED)
decouvertext.config(state=tk.NORMAL)
if (str(v.get()) == '1'):
tauxIntText.config(state=tk.NORMAL)
decouvertext.config(state=tk.DISABLED)
ajouter.config (command = add)

case1.bind("<Button-1>", modifVisib)
case1.focus_set()
case2.bind('<Button-1>', modifVisib)
case2.focus_set()
root.mainloop()

M103: Programmer en Orienté Objet: Développement Digital (Tronc Commun)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

M103: Programmer en Orienté Objet: Développement Digital (Tronc Commun)

Titre original :

Transféré par

Droits d'auteur :

Formats disponibles

Office de la formation professionnelle

Secteur : Digital & IA

Manuel des travaux pratiques

M103 : Programmer en Orienté

Direction de la Recherche et L’Ingénierie de Formation

01 Partie 1 APPRÉHENDER LE PARADIGME

₋ Maitrise de la modélisation d’une classe

₋ Faire une bonne lecture de l’énoncé du problème pour

• Définir l’ensemble de classes à implémenter pour assurer la gestion commerciale de la société.

Copyright - Tout droit réservé - OFPPT 6

• Définir l’ensemble de classes à implémenter pour assurer la gestion commerciale de la société.

Copyright - Tout droit réservé - OFPPT 7

1. Définir l’ensemble de classes à implémenter pour assurer la gestion commerciale de la société.

Produit et commande (pour la classe ligne Commande à voir après)

Analyser le texte suivant pour dégager les attributs de la classe Produit

désignation: chaine Attributs d’instances

Copyright - Tout droit réservé - OFPPT 8

• Définition de la classe commande

dateCreation: chaine produit: Produit

Copyright - Tout droit réservé - OFPPT 10

₋ Manipuler l’héritage des classes

₋ Réviser le principe de l’héritage vu au cours de la

• Soient les classes suivantes: -NomDirecteur: chaine Employé

-NomDirecteur: chaine Employé

Client Directeur Employé

Copyright - Tout droit réservé - OFPPT 16

₋ Bonne maitrise du concept de polymorphisme en POO

₋ Réviser le principe de l’héritage vu au cours de la

Variables Références Objets

Type Mère a 0x304021 attributsMere

Type Fille b 0x304055

Type Mère c Fille

Copyright - Tout droit réservé - OFPPT 19

Copyright - Tout droit réservé - OFPPT 20

Variables Références Objets

b1.MethodeA() à OK car b1 est de type déclaré B qui hérite de A

Copyright - Tout droit réservé - OFPPT 21

attributsMere vrai vrai vrai

methodeMère() vrai vrai vrai

attributsFille faux vrai faux

methodeFille() faux vrai faux

Copyright - Tout droit réservé - OFPPT 22

₋ Maitrise du concept de classe abstraite

₋ Réviser le principe de l’abstraction en POO et la

Copyright - Tout droit réservé - OFPPT 25

• X de type C1 fait reference à un objet de type C4à correcte

• X de type I fait reference à un objet de type C4à correcte

• X=Yà fausse (car C3 n’implémente pas I)

• X de type C3 fait reference à un objet de type C5à correcte

Copyright - Tout droit réservé - OFPPT 26

₋ Maitrise du codage d’une classe en Python

₋ Réviser les notions théoriques relatives à la définition

Copyright - Tout droit réservé - OFPPT 30

Copyright - Tout droit réservé - OFPPT 31

1. Définissez la classe Point et un constructeur à deux paramètres

• Questionner sur le rôle des getters et des setters @property

Copyright - Tout droit réservé - OFPPT 32

def __str__ (self):

• Revenir à l’exemple du cours

def __eq__(self, p):

Copyright - Tout droit réservé - OFPPT 33

def calculermilieu(self, pt):

def str (self):

def eq(self, p):

-Deux attributs privés nom et code