Python For Data Science - French Course

1
Programmation python
HAYTAM EL YOUSSFI
elyoussfihaytam@gmail.com
Web Developer & Junior Data Scientist
Haytam EL YOUSSFI Haytam222 @HaytamYoussfi haytam.elyoussfi haytam.elyoussfi2018

2021-2022
H.EL YOUSSFI Programmation python 2
Plan du cours
• Introduction à Python
• Structures de contrôle
• Conteneurs standards
• Fonctions
• Modules
• Programmation orientée objet

Introduction à python
• Langage Python
• Types et opérations de base
2021-2022

4
Python
Python est un langage de script:
• Développé depuis 1989 par Guido van Rossum
• Orienté objet (mais peut être utilisé quasi non-"objectivement")
• Open Source et gratuit
• Portable
• Simple à comprendre/ écrire
• Versions:
 Version 1.0 : 1990
 Version 2.0 : 2000
 Version 3.0 : 2008
Introduction à python Langage python
2021-2022

Python
Avantages : Interpréteur permettant de tester n'importe quel petit bout de
code, compilation transparentes
Inconvénients : peut être lent
Que peut-on faire avec Python ?
 Développement Web: Django, Pyramid, Zope, Plone,...
 Calcul Scientifique: Numpy, Scipy, sage, ...
 Représentation graphique: gnuplot, matplotlib, VTK, ...
 GUIs: TkInter, PyGtk, PyQt,...
 Manipulation d’images: Pillow, OpenCV-Python,...
 Bases de données: MySQL, PostgrSQL, Oracle, ...
Code Source ByteCode resultat
Compilateur Interpreteur
2021-2022

Règles d’écritures
• La casse est significative
• Le typage des variables est dynamique
• Une instruction doit commencer en première colonne
• L’indentation est obligatoire pour marquer les blocks
• Si une instruction dépasse la taille d’une ligne, il est possible soit
d’écrire un caractère de continuation ou de mettre l’instruction entre
parenthèses
Exemple
if (a == b and c == d and
d==e) :
print("ok ")
if a == b and c == d and
d==e :
print("ok ")
2021-2022

Opérations de base
• Affectation
Introduction à python Opérations de base
2021-2022

Opérations de base
• Opérateurs arithmétiques
• Opérateurs relationnels
x + y Addition
x - y Soustraction
x * y Multiplication
x / y Division
x // y Division entière
x % y Modulo
x ** y Puissance
x==y Egal
x!=y Différent
x<y Inférieur
x<=y Inférieur ou égal
x>y Supérieur
x>=y Supérieur ou égal
• Exemples
print(3*2+1) -> 7
print(3*(2+1)) -> 9
print( round(3.75)) -> 4
print(round(3.75,1) -> 3.8
print(3/5) -> 0.6
Print(3//5) -> 0
num_1 = 3
num_2 = 2
Print(num_1>num_2) -> true
not x Négation
x or y Ou-logique
x and y Et-logique
• Opérateurs logiques
Opérations de base
2021-2022

Chaines de caractères
Synatxe Sémantique
len(s) Longueur de la chaîne s
s1 + s2 Concaténation de s1 et s2
s * n Répétition ’n’ fois de la chaîne ’s’
s in t Teste si la chaîne ’s’ est présente dans ’t’.
s[n] Extraction du n-ième caractère en partant du début de la chaîne
s[-n] Extraction du n-ième caractère en partant de la fin de la chaîne
s[n:m] Extraction des caractères se trouvant entre le n-ième et le m-ième
s[:n] Extraction des ’n’ premiers caractères de la chaîne
s[n:] Extraction des derniers caractères de la chaîne à partir du n-ème
s[-n:] Extraction des caractères des ’n’ derniers caractères de la chaîne
• Encadrées par des apostrophes (' ') ou des guillemets (" ")
• Les opérateurs sur les chaînes permettent de concaténer, filtrer ou extraire
des parties des chaînes de caractères entres elles
Opérations de base
2021-2022

Chaines de caractères
• Exemple
txt="cours python"
print(len(txt)) #12
print(txt[2]) #u
print(txt[-2]) #o
print(txt[2:7]) #urs p
print(txt[:7]) #cours p
print(txt[4:]) #s python
print(txt[-4:]) #thon
txt2="math"
print(txt+txt2) #cours pythonmath
txt2=txt*2
print(txt2) #cours pythoncours python
print("ou" in txt) #True
Opérations de base
2021-2022

Conversion entre types
• La conversion de types permet de passer d’un type à l’autre
• La règle générale est de se servir du nom du type avec des parenthèses
• Exemple
Syntaxe Sémantique
bool(var) Converti ’var’ en un booléen
int(var) Converti ’var’ en un entier
float(var) Converti ’var’ en un flottant
str(var) Converti ’var’ en une chaîne de caractères
Opérations de base
2021-2022

print() / input()
• print(msg) : imprime à l’écran une chaîne de caractères donnée en
argument
• input(msg): permet de récupérer une chaîne de caractères tapée par
l’utilisateur (retourne une chaine)
• Exemples
Opérations de base
2021-2022

Structures de contrôle
• Structures alternatives
• Structures itératives
2021-2022

Les blocs
Structures de contrôle Structures conditionnelles
• Un bloc d’instructions est une unité de
programmation qui regroupe une
séquence ordonnée d’instructions qui
s’exécutent les unes après les autres
• Les instructions qui se trouvent au même
niveau d’indentation font parti d’un
même bloc
• Pas de délimiteurs (pas de { et de })
• Tout ce qui suit un caractère ’#’ est
considéré comme un commentaire et est
ignoré
2021-2022

Les structures conditionnelles
• Syntaxe
if <condition1>:
<blocs d'instructions 1>
elif <condition2>:
else:
• Exemple1
2021-2022

Les structures conditionnelles
• Exemple2
• Remarque
Il n’existe pas de switch en python et par conséquent on peut utilise if …
elif…else
2021-2022

Conditions
Types évaluant à faux :
• None
• False
• Tous les zéros : 0 , 0. , 0j
• Les listes/dictionnaires/chaines vides : [] , () , '' '', {}
• Tout objet dont la méthode bool() retourne False
• Tout objet dont la méthode len() retourne 0
Exemple
condition = 5 -> True
condition = None -> False
condition = 0 -> False
condition = ' ' -> False
condition = [] -> False
condition = () -> False
condition = {} -> False
2021-2022

Boucle for
Structures de contrôle Structures itératives
• En Python, for est un itérateur sur des collections d’objets. Il est utilisé pour
parcourir, dans l’ordre s’il y en a un, les éléments de la collection
• Syntaxe:
iterable est souvent:
 range(debut,fin,[step=1])
 une liste
 n’importe quel objet itérable
Remarque : la fonction range(start, stop, step)permet de créer une
collection de nombres pour itérer dessus
• Exemples
Résultats
for elem in iterable :
Instructions
2021-2022

Boucle for
• Exemples
2021-2022

Boucle while
• Syntaxe
 break : sort de la boucle sans
passer par else
 continue : remonte au début de la boucle
 pass : ne fait rien
 else : lancé si et seulement si la boucle se termine normalement
• Exemple
Boucle infinie
while <condition1>:
if <condition2>: break
if <condition3>: continue
else:
while <condition1>:
2021-2022

Boucle while
• Exemples
2021-2022

Conteneurs standards
• Listes
• Tuples
• Ensembles
• Dictionnaires
2021-2022

Listes
Conteneurs standards Listes
• Les listes servent à stocker des collections ordonnées d’éléments avec
possibilité de les étendre ou de les manipuler facilement
Initialisation
• L1=[]; L2=list() #Listes vides
• L1= [1, 2, 3, 4, 5]; L2= ['point', 'triangle', ‘rectangle']
• L=[1, 4, ‘ali', 4, ‘laila', ['point', 6]]
• L=[3]*6 # L=[3, 3, 3, 3, 3, 3]
Concaténation
2021-2022

Manipulation des listes
Syntaxe Sémantique
len(L) Nombre d’éléments dans la liste
del(L[n]) Détruit l’élément ‘n’ de la liste ‘L’
L1 + L2 Concaténation de ‘L1’ et ‘L2’
L * n Répétition ’n’ fois de la liste ‘L’
L[n] Extraction du n-ième élément en partant du début de la liste
L[-n] Extraction du n-ième élément en partant de la fin de la liste
L[n:m] Extraction des éléments qui sont entre ‘n’ et ‘m’
L[:n] Extraction des ‘n’ premiers éléments de la liste
L[n:] Extraction des éléments ‘n’ à la fin de la liste
L[-n:] Extraction des ‘n’ derniers éléments de la liste
2021-2022

Manipulation des listes
Syntaxe Sémantique
L.clear() Vide la liste ‘L’
L.copy() Renvoie une copie de la liste ‘L’
L.append(e) Ajoute l’élément 'e' à la fin de la liste 'L'
L.insert(n, e) Insère l’élément 'e' à la position 'n' dans la liste 'L'
L.sort() Trie la liste L
L.reverse() Inverse la liste L
L.index(e) Rechercher l’élément 'e' dans la liste L
L.remove(e) Retirer l’élément 'e' de la liste L
L.pop() Retirer le dernier élément de la liste L
L.pop(ind) Retirer l’élément qui est dans la position ' ind' de la liste L
2021-2022

Exemples
cours=['Hist','Math','Phy','Ar','Sc']
print(cours) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(len(cours)) #5
print(cours[1]) #Math
print(cours[-2]) # Ar
print(cours[1:3]) #['Math', 'Phy']
print(cours[:2]) #['Hist', 'Math']
print(cours[2:]) #['Phy', 'Ar', 'Sc']
cours.append('Fr'); print(cours) #['Hist', 'Math', 'Phy', 'Ar', 'Sc', 'Fr']
p=cours.pop(); print(cours) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(p) #Fr
cours.insert(1,'Art');
print(cours) # ['Hist', 'Art', 'Math', 'Phy', 'Ar', 'Sc']
cours=['Hist','Math','Phy','Ar']
cours2=['Ang','Fr']
cours.insert(1,cours2); print(cours) # ['Hist', ['Ang', 'Fr'], 'Math', 'Phy', 'Ar']
#insertion en tant que liste et non en tant que valeurs
cours.remove(cours2); print(cours) # ['Hist', 'Math', 'Phy', 'Ar']
cours.extend(cours2); print(cours) # ['Hist', 'Math', 'Phy', 'Ar', 'Ang', 'Fr']
2021-2022

Exemples
cours =['Hist','Math','Phy','Ar','Sc']
cours.reverse(); print(cours) #['Sc', 'Ar', 'Phy', 'Math', 'Hist']
cours.sort(); print(cours) #['Ar', 'Hist', 'Math', 'Phy', 'Sc']
cours.sort(reverse=True);
print(cours) #['Sc', 'Phy', 'Math', 'Hist', 'Ar']
cours =['Hist','Math','Phy','Math',‘Ar']
coursTrié=sorted(cours)
print(coursTrié) #['Ar', 'Hist', 'Math', 'Math', 'Phy']
print(cours) # ['Hist', 'Math', 'Phy', 'Math', 'Ar']
print(cours.index('Math')) # 1
print(cours.index('FR')) #Erreur
print('Hist' in cours) #True
txt=' - '.join(cours)
print(txt) # Hist - Math - Phy - Math - Ar
cours2=txt.split(' - ')
print(cours2) # ['Hist', 'Math', 'Phy', 'Math', 'Ar']
2021-2022

Exemples
cours =['Hist','Math','Phy']
for matiere in cours: print(matiere) #Hist Math Phys
for i,matiere in enumerate(cours): #
print(i,matiere)
for i,matiere in enumerate(cours,start=1): #
print(i,matiere)
L=[4,2,6,1]
L.sort(reverse=True)
print(L) # [6, 4, 2, 1]
print(min(L)) #1
print(sum(L)) #13
L=[2,5,7]
L1=3*L; print(L1) # [2, 5, 7, 2, 5, 7, 2, 5, 7]
L2=[3*x for x in L]; print(L2) # [6, 15, 21]
print([3*x for x in L if x>2]) # [15, 21]
2021-2022

Suppression d’un élément
• remove: Retire la première occurrence d’un élément de la liste
Exemple: L=[1, 2, 4, 2]
L.remove(2)
print(L) # [1, 4, 2]
• del: supprime un élément de la liste à partir de son indice
Exemple: L=[1, 2, 4, 2]
del(L[2])
print(L) #[1, 2, 2]
• pop: supprime un élément à partir de son indice et le retourne
Exemple: L=[1, 2, 4, 2]
x=L.pop(2)
print(x) #4
print(L) # [1, 2, 2]
2021-2022

Copie d’une liste
L =['Hist','Math','Phy','Ar','Sc']
T=L
print(L) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(T) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
T[2]="Fr"
print(T) #['Hist', 'Math', 'Fr', 'Ar', 'Sc']
print(L) #['Hist', 'Math', 'Fr', 'Ar', 'Sc']
L =['Hist','Math','Phy','Ar','Sc']
T=L[:] #T=L.copy()
T[2]="Fr"
print(T) #['Hist', 'Math', 'Fr', 'Ar', 'Sc']
print(L) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
Remarque:
Les listes sont mutables: ils peuvent subir des modifications
2021-2022

Tuples
Conteneurs standards Tuples
• Ils permettent de grouper des éléments de différentes natures pour créer une
structure qui les englobe
Initialisation
• T1=(); T2=tuple() # Tuples vides
• T= 'a', 'b', 'c', 'd' # T=('a', 'b', 'c', 'd')
• T= ('a', 'b', 'c', 'd')
• T= (1, 2)*3 # T=(1, 2, 1, 2, 1, 2)
Concaténation
T1,T2=(1,2),("ali","laila")
print("T1=",T1) # T1= (1, 2)
print("T2=",T2) # T2= ('ali', 'laila')
print("T1+T2=",T1+T2) # T1+T2= (1, 2, 'ali', 'laila')
2021-2022

Tuples
Conteneurs standards Tuples
• Les tuples ne sont pas modifiables: Il sont immuables
Exemple
t =('Hist','Math','Phy','Ar','Sc')
print(t) #('Hist', 'Math', 'Phy', 'Ar', 'Sc')
print(t[2]) #Phy
print(t[2:]) #('Phy', 'Ar', 'Sc')
print(t[-2]) #Ar
t2=t
print(t2) #('Hist', 'Math', 'Phy', 'Ar', 'Sc')
t2[0]='Art' #Error: 'tuple' object does not support item assignment
print(t2)
print(t)
2021-2022

Ensembles
Conteneurs standards Ensembles
• Un ensemble est une collection d'objets sans répétition et sans ordre (donc
sans numérotage). Ce n'est pas une séquence
• On les note comme en maths avec des accolades {...}. Les éléments sont de
types quelconques
Initialisation
• S=set() # Ensembles vides
• S={"rouge","vert","noir"}
• S= {5,'foo',(3,-2),7.4}
Remarque
• S={} crée un dictionnaire et non pas un ensemble
Opérations
• Les seules opérations que l’on peut faire sur les ensembles sont toutes les
opérations ensemblistes (appartenance, intersection, union, …)
2021-2022

Opérations
Syntaxe Sémantique
len(s) Taille de l’ensemble 's'
s.add(e) Ajoute 'e' à 's'
s.remove(e) Retire 'e' de 's' (erreur si ’e’ ∉ 's')
s.discard(e) Retire 'e' de 's'
s.clear() Vide l’ensemble 's'
s1 | s2 Union de ’s1’ et ’s2’
s1 & s2 Intersection de ’s1’ et ’s2’
s1 ^ s2 Différence exclusive de ’s1’ et ’s2’
Syntaxe Sémantique
e in s 'e' ∈ 's'
e not in 'e' ∉ 's'
s1 == s2 's1' égal 's2'
s1 != s2 's1' différent de 's2'
s1 < s2 's1' est inclus (strict) dans 's2'
s1 <= s2 's1' est inclus ou égal à 's2'
s1 > s2 ’s2’ inclus (strict) dans 's1'
s1 >= s2 's2' inclus ou égal à 's1'
s1.issubset(s2) 's1' inclus dans 's2'
s1.issuperset(s2) 's1' inclus 's2'
2021-2022

Exemples
color1={'rouge','vert','bleu','noir'}
print(color1) #{'bleu', 'noir', 'vert', 'rouge'} Affichage change à
chaque exécution
color1={'rouge','vert','bleu','noir','vert'}
print(color1) #{'bleu', 'noir', 'vert', 'rouge'} n’accepte pas les
doublons
print(color1[1]) #Error: 'set' object does not support indexing
print(len(color1)) #4
print('vert' in color1) #True
print('belu' not in color1) #True
color2={'rose','vert'}
c=color1|color2; print(c) #{'bleu', 'rose', 'vert', 'noir', 'rouge'}
print(color1.union(color2)) #{'bleu', 'rose', 'vert', 'noir', 'rouge'}
c=color1 & color2; print(c) #{'vert'}
print(color1.intersection(color2)) #{'vert'}
print(color1^color2) #{'bleu', 'rose', 'noir', 'rouge'}
print(color2.issubset(color1)) #False
print({'rouge','bleu'}.issubset(color1)) #True
2021-2022

Dictionnaires
Conteneurs standards Dictionnaires
• Un dictionnaire est une collection non numérotée de couples var:val où var
est un objet non mutable (la clé) et où val est n'importe quelle valeur
• On peut accéder à un élément d’un dictionnaire à partir d’une clé
• Les clés d’un dictionnaires doivent être distinctes et ne peuvent pas être
modifiées
Initialisation
• D={}; Dc=dict() #Dictionnaire vide
• stock={"pomme":40,"orange":30}
• etudiant={'nom':'ali','age':20,'cours':['Math','Phys']}
Insertion/Modification
On peut modifier la valeur associée à une clé, ou rajouter un nouveau couple
clé/valeur :
 stock={"pomme":40,"orange":30}
 stock["kiwi"]=60 #stock={'pomme': 40, 'orange': 30, 'kiwi': 60}
 stock['orange']='cent' # stock={'pomme': 40, 'orange': 'cent', 'kiwi': 60}
2021-2022

Accès à un élément
• On peut rapidement accéder à la valeur associée à une clé. C'est le principal
intérêt des dictionnaires
Exemple
• La clé doit être non mutable. Donc essentiellement des chaînes et des
nombres mais pas de listes. On peut utiliser des tuples comme clés à
condition qu'ils ne contiennent aucun objet mutable
• Il est aussi possible de demander si la clé existe, avec l'opérateur in
Exemple
2021-2022

Principales méthodes
Syntaxe Sémantique
len(d) Nombre d’éléments du dictionnaire
del(d[k]) Détruit l’entrée 'k' du dictionnaire
d.clear() Supprime tous les éléments du dictionnaire 'd'
d.copy() Renvoie une copie du dictionnaire 'd'
d.keys() Renvoie la liste des clés utilisées dans le dictionnaire
d.values() Renvoie la liste des valeurs utilisées dans le dictionnaire 'd'
d.has_key(k) Renvoie True si la clé passée en paramètre existe, False sinon
d.items() Renvoie une liste équivalente de tuples à partir du dictionnaire 'd'
d.pop(cle, val) Supprime et retourne d[cle] si la clé est présente sinon retourne val
d.update(d1) Ajoute les paires clé-valeur de 'd1' à 'd'
sorted(d) Retourne une liste ordonnée des clés du dictionnaire d
2021-2022

Exemple
etud={'nom':'ali','age':20,'cours':['math','phys']}
print(etud) #{'nom': 'ali', 'age': 20, 'cours': ['math', 'phys']}
print(len(etud)) #3
print(etud['nom']) # ali
print(etud['tel']) # Erreur
print(etud['cours']) # ['math', 'phys']
print(etud.get('nom')) # ali
print(etud.get('tel')) # None
print(etud.get('tel','clé inexistante')) # clé inexistante
etud['adresse']='agadir‘
etud['nom']='imad'
print(etud) # {'nom': 'imad', 'age': 20, 'cours': ['math', 'phys'], 'adresse': 'agadir'}
etud2={'nom':'laila','pays':'maroc'}
etud.update(etud2)
print(etud) # {'nom': 'laila', 'age': 20, 'cours': ['math', 'phys'], 'adresse': 'agadir',
'pays': 'maroc'}
del(etud[‘cours'])
print(etud) # {'nom': 'laila', 'age': 20, 'adresse': 'agadir', 'pays': 'maroc'}
2021-2022

Exemple
x=etud.pop('nom','clé inexistante')
print(x) #ali
print(etud) #{'age': 20, 'cours': ['math', 'phys']}
print(etud.pop('tel',-1)) #-1
print(etud.keys()) #dict_keys(['nom', 'age', 'cours'])
print(etud.values()) #dict_values(['ali', 20, ['math', 'phys']])
for i in etud: #
print(i,":",etud[i])
for cle,val in etud.items(): #
print (cle,val)
2021-2022

Les fonctions
• Définition
• Arguments d’une fonction
• Fonctions variadiques
• Portée d’une variable
2021-2022

Définition
Fonctions Définition
• Les fonctions servent à rendre un programme modulaire et à éviter de
répéter plusieurs fois le même code
Définition:
def <nom_fonction>(arg1, arg2,... argN):
bloc d'instructions
return <valeur(s)>
Exemple:
1.
2.
3.
2021-2022

Exemples
• Les parenthèses sont obligatoires pour appeler une fonction
Exemple:
• Définition d’une fonction qui ne fait rien
Exemple:
• Remarque: Une fonction qui n'a pas de return renvoie par défaut None
2021-2022
Fonctions Définition

Arguments d’une fonction
Fonctions Arguments d’une fonction
• Les arguments d'une fonction ne sont pas typés a priori mais sont substitués
dynamiquement dans le code de la fonction lors de l’exécution
• On peut inverser les arguments lors d’un appel si on les nomme
Exemple:
def puissance(a, b):
return a**b
print(puissance(2,3)) #affiche 8
x=puissance(b=3,a=2)
print(x) #affiche 8
2021-2022

Arguments nommés
• Les arguments nommés permettent de donner des noms et des valeurs par
défaut à certains arguments d’une fonction
• Les arguments nommés deviennent optionnels lors de l’appel à la fonction
• Exemples
1. def afficher(msg,nom="ali"):
return "{} {}".format(msg,nom)
print(afficher("bonjour")) #bonjour ali
print(afficher("bonjour","laila")) #bonjour laila
2. def F(a,b,c=0,d=2):
return a+b-c*d
x=F(10,5); print(x) #15
y=F(5,10,d=3); print(y) #15
z=F(5,10,d=1,c=2); print(z) #13
• Les arguments non-nommés doivent être placés, toujours dans le même
ordre, au début de la fonction et les arguments nommés toujours à la fin
2021-2022
Fonctions Arguments d’une fonction

Fonction variadique
• Une fonction variadique est une fonction dont le nombre d’arguments est
variable et donc on peut y mettre le nombre d’arguments que l’on veut
• L’opérateur * convertit des arguments non nommés en tuple
• Exemple
• On utilise l'opérateur * pour transformer une liste en arguments d’une fonction
Exemple:
L=[2,5,9,4]
print(sum(L)) #Error: unsupported operand type(s) for +=: 'int' and 'list'
print(sum(*L)) # 20 =>l’opérateur * "déliste" L en arguments
2. def sum(*args):
s=0
for x in args: s+=x
return s
print(sum(2,4)) #6
print(sum(2,3,10,5,4)) #24
1. def afficher(*args):
print(args)
afficher('pomme','orange')
#('pomme', 'orange')
afficher('laila',30,True,'salut')
#('laila', 30, True, 'salut')
2021-2022
Fonctions Fonctions variadiques

Fonction variadique
• On peut avoir un nombre variable d’arguments nommés, utile quand on a
beaucoup d’arguments optionnels ayant une signification différente
• L’opérateur ** convertit des arguments nommés en dictionnaire
Exemple
1. def afficher(**args):
print(args)
afficher(nom="ali",age=30) #{'nom': 'ali', 'age': 30}
2. def test(**args):
for k in args:
print(k," : ",args[k])
test(nom='ali',age=30,adresse='agadir')
etudiant={'nom':'laila','age':20,'cours':['Math','Phys']}
test(**etudiant)
2021-2022

Fonction variadique
Exemple
def afficher(*args,**kargs):
print(args)
print(kargs)
afficher('Math','Phys',nom='ali',age=30) #('Math', 'Phys')
{'nom': 'ali', 'age': 30}
cours=['Math','Pys']
info={'nom':'ali','age':30}
afficher(cours,info) # (['Math', 'Pys'], {'nom': 'ali', 'age': 30})
{}
afficher(*cours,**info) #('Math', 'Pys')
{'nom': 'ali', 'age': 30}
2021-2022

Exemple
nbr_jours=[0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
def is_leap(annee):
return annee%4==0 and(annee%100!=0 or annee%400==0)
def nbrJour(mois,annee):
""" Retourne le nombre de jours dans le mois et l’année spécifiés"""
if not 1<=mois<=12: return 'mois invalide'
elif mois==2 and is_leap(annee): return 29
else: return nbr_jours[mois]
print(nbrJour(2,2000)) #29
print(nbrJour(2,2017)) #28
2021-2022

Variable locale/globale
Fonctions Portée d’une variable
• La portée d’une variable correspond à l’ensemble des lignes dans lesquelles la
variable peut être appelée
• Lorsqu’on est en dehors de la portée d’une variable et que l’on fait appel à elle,
le programme provoque une erreur
• Une variable est dite “globale” si sa portée recouvre l’ensemble du programme
• Une variable est dite “locale” si sa portée recouvre seulement une partie du
programme
• Exemple
2021-2022
x="salut"
def test():
x="bonjour"
print(x)
test() #bonjour
print (x) #salut
def test():
x="bonjour"
print(x)
test() #bonjour
print (x) #Erreur
#x inconnu à l’exterieur
de la fonction test
x="salut"
def test():
global x
x="bonjour"
print(x)
test() #bonjour
print (x) #bonjour

1. x='global x '
def test():
y='local y'
print(y)
test() #local y
2. x='global x'
def test():
y='local y'
print(x)
test() #global x
3. x='global x'
def test():
y='local y'
print(x)
x='abc'
test() #Erreur
# local variable 'x' referenced
before assignment
2021-2022
4. x='global x'
def test():
x='local x'
print(x)
test() #local x
print(x) #global x
5. x='global x'
def test():
global x #on déclare travailler avec la
variable globale
x='local x'
print(x)
test() #local x
print(x) #local x

2021-2022

enumerate() / zip()
Fonctions Fonctions
2021-2022
• Les fonctions enumerate() et zip() sont utiles pour les itérations sur des
structures
 enumerate() : Associe un index sur la structure lorsqu’il n’y en a pas
 zip() : Permet d’itérer deux structures en parallèle
• Exemple
 myset = {'a','w','d'}
for index,item in enumerate(myset):
print(index,item)
 mylist1 = [5, 3, 9, 4, 1]
mylist2 = ['a','w','d','e']
for index,char in zip(mylist1,mylist2):
print (index ,char)

2021-2022
Les modules
• Importer un module
• Créer un module
• Chemin de recherche d’un module
• Modules standards

Importer un module
Modules Importer un module
2021-2022
• Les modules Python permettent de grouper et de rendre facilement
réutilisable du code Python
• Différentes manières d'importer un module
 import module1 , module2 # Importe les modules
 import module1 as md1 #Importe un module en lui donnant un nom
 from module import func1,func2 # Importe les fonctions
 from module import * # Importe toutes les fonctions du module
• Exemple

Écrire et utiliser un module
Modules Créer un module
2021-2022
• Créer un module revient à créer un fichier au nom du module que l’on désire
créer (suivi de ’.py’), puis d’y inclure les fonctions désirées
• Exemple
#Fichier my_module.py
txt='test string'
def find_index(L,val):
"""Trouver l'indice d'une valeur
dans une sequence"""
for i, value in enumerate(L):
if value==val :
return i
return -1
import my_module
cours=['math','phys','arabe','Histoire']
indice=my_module.find_index(cours,'phys')
print(indice)
import my_module as md
indice=md.find_index(cours,'phys')
print(indice)
from my_module import find_index
indice=find_index(cours,'phys')
print(indice)

Chemin de recherche d'un module
Modules Chemin de recherche d’un module
2021-2022
• Par défaut, l’interpréteur Python cherche le module dans le répertoire où il
exécute les scripts, puis dans les endroits “habituels”
• Si un module se trouve dans un autre répertoire, il faut l'ajouter dans sys.path
Exemple:
• Remarque: si du code Python se trouve en dehors de toute fonction dans le
module, il sera exécuté à son chargement. Pour éviter que cela se produise, il
faut “protéger” le code avec :
import sys
sys.path.append('/Users/amazal/Desktop/Exemples_python')
from my_module import find_index,txt
cours=['math','phys','arabe','Histoire']; indice=find_index(cours,'phys')
print(indice)
print(txt)
#Fichier my_module.py
if __name__=="__main__":
# code exécuté seulement si on lance le fichier '.py ',
# pas si on l’ importe dans un autre fichier .

Modules standards
Modules Modules standards
2021-2022
• Quelques modules standards:
 String
 Math
 Time
 Sys
 os
• module sys: Informations système (version de python), options du système
sys.path:
 donne le python path où sont recherchés les modules lors de l'utilisation
d'import
 sys.path est une liste pour ajouter un élément : sys.path.append('...')
 Le premier élément est le répertoire courant
sys.exit: permet de quitter un script python

2021-2022
Programmation orientée objet
• Classes et objets
• Attributs et leurs types
• Méthodes et leurs types
• Héritage
• Méthodes spéciales
• Encapsulation
• Polymorphisme
• Classes abstraites

Programmation orientée objet
Programmation orientée objet Classes et objets
2021-2022
• Programmation Orientée Objet (POO) : paradigme de programmation
informatique
 Elaboré par Alan Kay, dans les années 70’
 Modélisation directe d’objets du monde réels
 Un programme est vu comme une somme d’objets qui
communiquent et agissent les uns sur les autres. Ce sont ces
interactions qui décrivent le programme
• Programmation Fonctionnelle : Le programme est vu comme un empilement
d’appels à des fonctions (au sens mathématique du terme) qui forment
l’algorithme.
• Programmation Impérative : Le programme est vu comme une somme
d’instructions chacune agissant sur la mémoire et qui, mis bout à bout,
décrivent l’algorithme (c’était le paradigme utilisé jusqu’ici).

Classes et objets
2021-2022
Classe : moule pour créer des données appelées objets
• une unité d’encapsulation : elle regroupe la déclaration des attributs et la
définition des méthodes associées dans une même construction syntaxique
Objet : donnée en mémoire qui est le représentant d’une classe
• Un objet est l’instance d’une classe
• Un objet est caractérisé par :
 un état : la valeur des attributs (solde, etc.)
 un comportement : les méthodes qui peuvent lui être appliquées (débiter,
créditer, etc.)
 une identité : identifie de manière unique un objet (p.ex. son adresse en
mémoire)
• Un objet est créé à partir d’une classe (en précisant les paramètres effectifs de
son constructeur, sauf le premier, self)

Classes et objets
2021-2022
• Standard de codage (CamlCase) : Le nom d’une classe est en CamlCase et
commence par une majuscule. Par exemple : ClassName ou CompteBancaire
• Notation pointée : On parle de notation pointée pour désigner l’accès à un
attribut ou à une méthode qui est propre à un objet.
Par exemple : myobject.var ou myobject.mymethod(arg1,arg2)
• self : Utilisée par convention à l’intérieur du code d’une classe pour faire
référence à l’objet lui-même
• Constructeur : Un constructeur est une méthode particulière appelée à la
création d’un objet pour l’initialiser. On utilise le nom de la classe pour
l’appeler, mais dans le code de la classe on l’appelle “__init__()”
• Méthodes ou variables “de Classe” : Un attribut ou une méthode est dite “de
classe” si elle dépend de la classe et non de l’objet

Exemple1
2021-2022
class Point:
def __init__(self,x,y):
self.x=x
self.y=y
def deplacer(self,dx,dy):
self.x+=dx
self.y+=dy
p1=Point(2,3)
print(p1.x,p1.y) #2 3
p1.deplacer(1,2)
Point.deplacer(p1,1,2)
class Point:
pass
p1=Point()
p2=Point()
print(p1) #<__main__.Point object at
0x000000000910B080>
print(p2) #<__main__.Point object at
0x000000000910B160>
p1.x=2
p1.y=3
p2.x=3
p2.y=4

Exemple2
2021-2022
class Salarie:
def __init__(self,nom,prenom,adresse,salaire):
self.nom=nom
self.prenom=prenom
self.adresse=adresse
self.salaire=salaire
def nomComplet(self):
return '{} {}'.format(self.nom,self.prenom)
#return self.nom+ " " +self.prenom
S1=Salarie('alami','laila','talborjt',6000)
S2=Salarie('majidi','ilias','salam',7000)
print(S1.adresse) #talborjt
print(S2.adresse) #salam
print(S1.nomComplet()) #alami laila
print(S2.nomComplet()) #majidi ilias
print(Salarie.nomComplet(S1)) #alami laila
class Salarie:
pass
S1=Salarie()
S2=Salarie()
print(S1) #<__main__.Salarie object at
0x000000000901E048>
print(S2) #<__main__.Salarie object at
0x000000000901E080>
S1.nom="alami"
S1.prenom="laila"
S1.salaire=6000
S1.adresse="Talborjt"
print(S1.nom) #alami
S2.pays="maroc"
S2.age=45
print(S2.age) #45

Types d'attributs
Programmation orientée objet Attributs et leurs types
2021-2022
• Attribut d'instance
 Attribut défini dans la méthode constructeur
 La valeur d'un attribut d'instance est propre à chaque instance
• Attribut de classe
 Attribut défini au niveau de la classe
 La valeur est partagée par tous les objets instanciés à partir de la classe
• L'ensemble des attributs d'instance sont regroupés dans un attribut spécial :
__dict__ de type dictionnaire
Exemple:
print(S1.__dict___) #{'nom': 'alami', 'prenom': 'laila', 'adresse': 'talborjt',
'salaire': 6000}

Attribut de classe (Exemple: taux)
2021-2022
class Salarie:
def __init__(self,nom,prenom,adresse,salaire):
self.nom=nom
self.prenom=prenom
def AugmenterSalaire(self):
self.salaire=int(self.salaire * 1.05)
print(S1.salaire) #6000
S1.AugmenterSalaire()
• A chaque changement du taux d’augmentation, il faut parcourir tout le code et
effectuer la modification => Utiliser une variable de classe taux=1.05

Attribut de classe (Exemple: taux)
2021-2022
class Salarie:
taux=1.05 #attribut de classe
def__init__(self,nom,prenom,adresse,salaire):
self.nom=nom
self.prenom=prenom
#self.salaire=int(self.salaire * Salarie.taux)
self.salaire=int(self.salaire * self.taux)
print(Salarie.taux) #1.05
print(S1.taux) #1.05
print(S1.__dict__) #{'nom': 'alami', 'prenom':
'laila', 'adresse': 'talborjt', 'salaire': 6615}
Salarie.taux=1.06
S1.taux=1.04
print(S1.__dict__)
#{'nom': 'alami', 'prenom': 'laila', 'adresse':
'talborjt', 'salaire': 6615, 'taux': 1.04}
print(S2.__dict__) #{'nom': 'majidi', 'prenom':
'ilias', 'adresse': 'salam', 'salaire': 7000}

Attribut de classe (Exemple: nombre salariés)
2021-2022
class Salarie:
taux=1.05 #attribut de classe: taux d’augmentation au sein de l’entreprise
nb_salarie=0 #attribut de classe: compteur des objets salariés criés
def__init__(self,nom,prenom,adresse,salaire):
self.nom=nom
self.prenom=prenom
Salarie.nb_salarie+=1
print(Salarie.nb_salarie) #0
print(Salarie.nb_salarie) #2

Types de méthodes
Programmation orientée objet Méthodes et leurs types
2021-2022
• Une méthode d’instance est un sous-programme qui exploite l’état d’un objet
(en accès et/ou en modification)
 Le premier paramètre désigne nécessairement l’objet. Par convention, on
l’appelle self
• Une méthode de classe est une méthode qui travaille sur la classe (et non
l’objet). Elle peut s'exécuter sans créer des instances de la classe
 Elle est décorée @classmethod
 Son premier paramètre est nommé cls par convention
• Une méthode statique est une méthode définie dans l’espace de nom de la
classe mais elle est indépendante de cette classe
 Elle est décorée @staticmethod
 Elle n’utilise ni self ni cls

Types de méthodes (Exemple)
Programmation orientée objet Méthodes et leurs types
2021-2022
class Salarie:
taux=1.05
nb_salarie=0
def__init__(self,nom,prenom,salaire):
self.nom=nom
self.prenom=prenom
@classmethod
def set_taux(cls,val):
cls.taux=val
@staticmethod
def is_workday(date):
if date.weekday()==5 or date.weekday==6:
return False
return True
@classmethod
def extraire(cls, txt):
nom, pr, sal=txt.split('-')
return cls(nom,pr,sal)
import datetime
S1=Salarie('alami','laila',6000)
Salarie.set_taux(1.06)
dt=datetime.date(2018,9,22)
print(Salarie.is_workday(dt))
#False
txt1="alami-laila-7000"
txt2="majidi-imad-9000"
S1=Salarie.extraire(txt1)
print(S1.nom,":",S1.salaire)
nom,pr,sal=txt2.split('-')
S2=Salarie(nom,pr,sal)
print(S2.nom,":",S2.salaire)

Héritage
Programmation orientée objet Héritage
2021-2022
• Principe : définir une nouvelle classe par spécialisation d'une (ou plusieurs)
classes existantes
• La sous-classe :
 Récupère automatiquement tous les attributs et les méthodes des supers
classes
 Peut spécialiser la super classe par l'ajout d’attributs et de méthodes
 Peut modifier les types des attributs héritées
 Peut modifier le comportement des méthodes héritées par redéfinition
• Redéfinition : Donner une nouvelle implémentation à une méthode déjà
présente dans une super classe (override, en anglais)

Héritage (Exemple1)
2021-2022
class Consultant(Salarie):
pass
cons1=Consultant("alami","laila",20000)
print(cons1.nomComplet()) #alami laila
print(cons1.salaire) #20000
cons1.AugmenterSalaire()
print(cons1.taux) #1.05
cons1.taux=1.06
print(cons1.__dict__)
taux=1.09
cons1=Consultant("alami","laila",20000)
S1=Salarie("majidi","imad",20000)
cons1.AugmenterSalaire()
taux=1.09
def __init__(self,nom,prenom,salaire,specialite):
super().__init__(nom,prenom,salaire)
#Salarie.__init__(self,nom,prenom,salaire)
self.specialite=specialite
cons1=Consultant("alami","laila", 20000,"BI")
cons2=Consultant("majidi","imad",30000,"Java")
print(cons1.specialite) #BI
print(cons1.nomComplet()) #alami laila
print(cons1.__dict__) #{'nom': 'alami',
'prenom': 'laila', 'salaire': 20000, 'specialite': 'BI'}
print(help(Consultant))

Héritage (Exemple2)
2021-2022
class Manager(Salarie):
def __init__(self,nom,prenom,salaire,list_sal=None):
super().__init__(nom,prenom,salaire)
if list_sal is None:
self.list_sal=[]
else: self.list_sal=list_sal
def ajouter_salarie(self, sal):
if sal not in self.list_sal:
self.list_sal.append(sal)
def supprimer_salarie(self, sal):
if sal in self.list_sal:
self.list_sal.remove(sal)
def afficher_salarie(self):
print("***liste des salariés****")
for sal in self.list_sal:
print(sal.nomComplet())
mg1=Manager("alami","imad",30000,
[cons1,cons2])
print(mg1.nomComplet())
mg1.afficher_salarie()
S1=Salarie("alaoui","hind",10000)
mg1.ajouter_salarie(S1)
mg1.supprimer_salarie(cons1)

Fonctions prédéfinies
Programmation orientée objet Fonctions prédéfinies
2021-2022
isinstance(obj,cls)
• Renvoie True si obj est instancié à partir de la classe cls
• Exemple:
print(isinstance(mg1,Manager)) #True
print(isinstance(mg1,Salarie)) #True
print(isinstance (mg1,Consultant)) #False
issubclass(classe1,classe2)
• Renvoie True si classe1 est une sous-classe de la classe2
• Exemple:
print(issubclass(Manager,Salarie)) #True
print(issubclass(Consultant,Salarie)) #True
print(issubclass(Consultant,Manager)) #False
print(issubclass(Salarie,Salarie)) #True

Méthodes spéciales
Programmation orientée objet Méthodes spéciales
2021-2022
• __init__(self, ...) : le constructeur, méthode d’initialisation appelée à la
création d'un objet
• __del__(self) : le destructeur, appelé quand une instance est sur le point
d’être détruite
• __repr__(self) : chaîne représentant un objet et qui devrait correspondre
(quand c’est possible) à une expression Python valide pour créer l’objet
• __str__(self) : utilisée par str() pour obtenir la représentation sous forme
d’une chaîne de caractères lisible de l’objet. Si non définie, retourne le résultat
de __repr__
• __len__(self): appelée quand souhaite connaitre la taille d’un objet
conteneur
• __add__(self, r): retourne self + r

Méthodes spéciales (Exemple)
Programmation orientée objet Méthodes spéciales
2021-2022
class Salarie:
taux=1.05
nb_salarie=0
def __init__(self, nom, prenom, salaire):
self.nom=nom
self.prenom=prenom
return '{} {}'.format(self.nom, self.prenom)
def __repr__(self):
#return "Salarie('%s','%s',%s)"%(self.nom,self.prenom,self.salaire)
return 'Salarie("{}","{}",{})'.format(self.nom, self.prenom,self.salaire)
def __str__(self):
return "{} : {}".format(self.nomComplet(), self.salaire)
def __len__(self):
return len(self.nomComplet())
def __add__(self, s):
return (self.salaire+s.salaire)
S1=Salarie('alami', 'laila',
6000)
S2=Salarie('majidi',
'ilias', 7000)
print(S1)
print(repr(S1))
#print(S1.__repr__())
print(str(S1))
#print(S1.__str__())
print(len(S1))
#print(S1.__len__())
print(S1+S2)
#print(S1.__add__(S2))

Encapsulation en POO
Programmation orientée objet Encapsulation
2021-2022
Encapsulation
• Principe qui consiste à cacher l'information contenue dans un objet et de ne
proposer que des méthodes de manipulation de cet objet
Principaux avantages
• Protéger: ne pas permettre l'accès à tout dès que l'on a une référence de l'objet
• Masquer l'implémentation: toute la décomposition du problème n'a besoin
d'être connue du programmeur client
• Evolutivité: possibilité de modifier tout ce qui n'est pas public sans impact
pour le programmeur client
Règles à respecter
• Rendre privés les attributs caractérisant l'état de l'objet
• Fournir des méthodes publiques permettant d’accèder/modifier l'attribut

Encapsulation en python
2021-2022
• Pas d’information privées en Python mais une convention :
 En Python tous les attributs sont des attributs publiques : accessibles à
partir d'autres classes : L'encapsulation n'est pas respectée !
Exemple : s1.salaire = 10000
 Il est possible de brouiller l'accès à un attribut en le nommant comme
suit : __nomAttribut => Simule une information privée
 Un attribut brouillé est renommé automatiquement à
_NomClasse__NomAttribut
• Les getters et setters permettent l'encapsulation, mais pas très pythonic

Getters et setters
2021-2022
class Salarie:
def __init__(self,nom,sal=2000):
self.__nom=nom
self.__salaire=sal
def getNom(self):
return self.__nom
def setNom(self,nom):
self.__nom=nom
def getSalaire(self):
return self.__salaire
def setSalaire(self,sal):
if 1000<=sal<=50000:
self.__salaire=sal
else: print("salaire non valide")
if __name__=='__main__':
s1=Salarie("alami hind",4000)
print(s1.__salaire)
#Erreur: Salarie' object has no
# attribute '__salaire'
print(s1.getNom()," : ", s1.getSalaire())
#alami hind : 4000
s1.setSalaire(30000)
print(s1.getSalaire()) #30000
s1.setSalaire(100) #salaire non valide
print(s1.getSalaire()) #30000

Propriétés
2021-2022
Propriétés sur les objets :
• Avoir une syntaxe identique à la manipulation d’un attribut (en accès ou
modification) mais par l’intermédiaire de méthodes et donc avec contrôle !
• Faire croire que l'on accède directement aux attributs
• Etre pythonic tout en préservant l'encapsulation
Principe de Python :
• On commence par définir un attribut normal
• Si on a besoin de le contrôler, on passer à une propriété : cette modification
ne remet pas en cause le code client qui reste inchangé

Propriétés (Première syntaxe)
2021-2022
class Salarie:
self.__nom=nom
self.__salaire=sal
def __getNom(self):
return self.__nom
def __setNom(self,nom):
self.__nom=nom
nom=property(__getNom,__setNom)
def __getSalaire(self):
def __setSalaire(self,sal):
if 1000<=sal<=50000:
self.__salaire=sal
salaire=property(__getSalaire,__setSalaire)
print(s1.nom," : ", s1.salaire)
s1.salaire=30000
print(s1.salaire)
s1.salaire=100
print(s1.salaire)

Propriétés (Deuxième syntaxe)
2021-2022
class Salarie:
self.__nom=nom
self.__salaire=sal
@property
def salaire(self):
@salaire.setter
def salaire(self,sal):
if 1000<=sal<=50000:
self.__salaire=sal
print(s1.__nom)
# Erreur: 'Salarie' object has no
attribute '__nom'
s1.salaire=30000
print(s1.salaire) # 30000
s1.salaire=100 # salaire non valide
print(s1.salaire) # 30000

Propriétés (Exemple 2)
2021-2022
class Salarie:
def __init__(self,nom,prenom):
self.nom=nom
self.prenom=prenom
self.email=nom+'.'+prenom+'@email.com'
return "{} {}".format(self.nom, self.prenom)
s1=Salarie("alami","laila")
print(s1.email) #alami.laila@email.com
print(s1.nomComplet()) #alami laila
s1.nom="ziyadi"
print(s1.nom) #ziyadi
print(s1.email) #alami.laila@email.com
print(s1.nomComplet()) #ziyadi laila

Propriétés (Exemple 2)
2021-2022
class Salarie:
def __init__(self,nom,prenom):
self.nom=nom
self.prenom=prenom
@property
def email(self):
return '{}.{}@email.com'.format(self.nom,self.prenom)
@property
return "{} {}".format(self.nom, self.prenom)
@nomComplet.setter
def nomComplet(self,nom):
n,pr=nom.split(' ')
self.nom=n
self.prenom=pr
s1=Salarie("alami","laila")
print(s1.email)
#alami.laila@email.com
print(s1.nomComplet)
#alami laila
s1.nom="ziyadi"
print(s1.nom) #ziyadi
print(s1.email)
#ziyadi.laila@email.com
print(s1.nomComplet)
#ziyadi laila
s1.nomComplet="alaoui imad"
print ("Nom: ",s1.nom)
#Nom: alaoui
print ("Prenom: ",s1.prenom)
#Prenom: imad

Polymorphisme
Programmation orientée objet Polymorphisme
2021-2022
Définition
• Le nom polymorphisme vient du grec et signifie qui peut prendre plusieurs formes
• Le polymorphisme peut être vu comme la capacité de choisir dynamiquement la
méthode qui correspond au type réel de l’objet
Avantages
• Permet une programmation beaucoup plus générique
• Utiliser un même nom de méthode pour plusieurs types d’objets différents
• Le développeur n’a pas à savoir le type précis de l’objet sur lequel la méthode va
s’appliquer. Il lui suffit de savoir que cet objet implémentera la méthode
Exemple: L’opérateur +
A+B
Si A=2 et B=3 le résultat sera 5
Si A="sa" et B="lut" le résultat sera "salut"

Exemple 1
2021-2022
class Document:
def __init__(self,nom):
self.nom=nom
def afficher(self):
raise NotImplementedError("Subclass must implement abstract method")
class Pdf(Document):
def afficher(self):
return "Show pdf content!"
class Word(Document):
def afficher(self):
return "Show Word content!"
if __name__=="__main__":
list_doc=[Pdf("doc1"),Pdf ("doc2"),Word ("doc3")]
for d in list_doc:
print(d.nom,d.afficher())

Exemple 2
2021-2022
import math
class Cercle:
def __init__(self,rayon):
self.rayon=rayon
def surface(self):
return math.pi*self.rayon**2
class Cylindre(Cercle):
def __init__(self,rayon,hauteur):
super().__init__(rayon)
self.hauteur=hauteur
def volume(self):
return super().surface()*self.hauteur
class Cone(Cylindre):
def volume(self):
return super().volume()/3
C1=Cylindre(5,8)
print("surface de base du cylindre
%.2f"%(C1.surface())) #78.54
print("volume du cylindre %.2f"%(C1.volume()))
#628.32
C2=Cone(5,8)
print("surface de base du cône",C2.surface())
#78.54
print("volume du cône",C2.volume()) # 209.43

Classes abstraites en POO
Programmation orientée objet Classes abstraites
2021-2022
• Une classe abstraite ne permet pas d’instancier des objets mais sert de base
pour créer des classes dérivées
• Formée de :
 méthodes et champs habituels
 méthodes abstraites
• Si une classe dérivée d’une classe abstraite ne redéfinit pas toutes les
méthodes abstraites de sa classe de base, elle est elle-même abstraite
• Une classe dérivée d’une classe abstraite peut être déclarée abstraite

Classes abstraites en POO
2021-2022
Utilité
• Le recours aux classes abstraites facilite la conception orientée objet :
• Permet de placer toutes les fonctionnalités qu’on veut faire figurer dans les
classes dérivées
 Soit sous forme d’une implémentation complète de méthodes (non-
abstraites) et de champs, lorsqu’ils sont partagés par toutes ses
descendantes
 Soit sous forme d’une méthode abstraite, dont l’implémentation
varie selon les classes dérivées, mais pour s’assurer qu’elle sera
présente dans toute classe dérivée instanciable
⇒ très utile pour le polymorphisme

Classes abstraites en python
2021-2022
• Utilisation du module abc (Abstract Base Class)
• Exemple
from abc import ABC,abstractmethod
class FormeGeo(ABC):
def __init__(self,couleur):
self.couleur=couleur
@abstractmethod
def Perimetre(self):
raise NotImplementedError("subclass
must define abstract method")
@abstractmethod
def Surface(self):
raise NotImplementedError("subclass
must define abstract method")
class Rectangle(FormeGeo):
def __init__(self,long,larg,color):
super().__init__(color)
self.longueur=long
self.largeur=larg
def Perimetre(self):
return (self.longueur+self.largeur)*2
def Surface(self):
return self.longueur*self.largeur
f=FormeGeo() #Erreur
r=Rectangle(2,3,"rouge")
print(r.Perimetre())
print(r.Surface())
print(r.__dict__)

Python For Data Science - French Course

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Python For Data Science - French Course

Similar a Python For Data Science - French Course (20)

Python For Data Science - French Course