Python UPB ASSRI MIAGE 2023 2024

Université Polytechnique de Bingerville
Année Académique 2023-2024
Filière/Niveau : MIAGE&ASSRI /L1
Cours :
PROGRAMMATION
PYTHON
Enseignant : Dr. ATTA Amanvon Ferdinand

Programmation Python
Chapitre 1: Programmation procédurale en Python
Chargé de cours:
Dr. ATTA Amanvon Ferdinand
Année académique 2023-2024
Note
Ce document est un ensemble de notes de cours du chapitre 1 du cours intitulé Pro-
grammation Python délivré par Dr. ATTA Amanvon Ferdinand en Licence 2/3EA. S’il
vous plaît, envoyez vos commentaires et/ou corrections à ferdinand.atta@outlook.fr.
1
TABLE DES MATIÈRES Programmation procédurale en Python
Table des matières

Pré-requis 4
Objectifs 4
1 Introduction 5
2 Caractéristiques de Python 5
3 Installation de l’environnement de travail 6
4 Premiers pas en Python 7

4.1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.1.1 Notion de variable . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.1.2 Déclaration de variable . . . . . . . . . . . . . . . . . . . . . . . . 7
4.1.3 Les différents types de base de variables . . . . . . . . . . . . . . . 7
4.1.4 Quelques manipulations de string et E/S Standard . . . . . . . . . . 8
4.2 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.1 Opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.2 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.3 Opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . 9
4.2.4 Assignation composée . . . . . . . . . . . . . . . . . . . . . . . . 9
5 Structures de contrôle de flux 10

5.1 Types de structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.2 Structures de décision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.2.1 La conditionnelle simple . . . . . . . . . . . . . . . . . . . . . . . 10
5.2.2 Conditionnelle composée . . . . . . . . . . . . . . . . . . . . . . . 10
5.2.3 Conditionnelle multiple . . . . . . . . . . . . . . . . . . . . . . . 11
5.2.4 Structure à choix . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.3 Structures répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.3.1 Structure répétitive POUR . . . . . . . . . . . . . . . . . . . . . . 13
5.3.2 Structure répétitive TANT QUE . . . . . . . . . . . . . . . . . . . 14
6 Structures de données essentielles 15

6.1 Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
6.2 Tuple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6.3 Ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6.4 Dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
7 Modularité 18
7.1 Fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
7.1.1 Écriture de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . 18
7.1.2 Quelques fonctions particulières . . . . . . . . . . . . . . . . . . . 19
7.2 Module et package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
©Dr. ATTA - Toute reproduction interdite 2/ 26

8 Fichier 21
9 Exercices d’application 23
9.1 Enoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
9.2 Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
10 Travaux dirigés 24
11 Conclusion 24

Pré-requis
— Les notions de base en algorithmique
Objectifs
— Apprendre les notions de base de Python
— Apprendre à manipuler les structures de données Python
— Se familiariser avec les concepts de module et package
— Apprendre à manipuler les fichiers en Python

2 CARACTÉRISTIQUES DE PYTHON Programmation procédurale en Python
1 Introduction
L’automatisation de la résolution d’un problème en informatique fait appel à deux éléments
clés :
1. Algorithme : Un algorithme est une suite finie et non ambiguë d’étapes permettant
de résoudre un problème ou d’obtenir un résultat. On attend d’un algorithme qu’il se
termine en un temps raisonnable, qu’il soit pertinent et efficace.
2. Programme : Un programme est une traduction d’un algorithme en un langage (tel
que le langage Python) compilable ou interprétable par un ordinateur. Il est souvent
écrit en plusieurs parties dont une qui pilote les autres : le programme principal.
La programmation désigne l’ensemble des activités qui permettent l’écriture des programmes.
Le génie logiciel étudie les méthodes de construction des programmes. Plusieurs para-
digmes (ou modèles) de programmation sont envisageables, entre autres :
— La programmation procédurale. On emploie l’analyse descendante (division des pro-
blèmes) et remontante (réutilisation d’un maximum de sous-algorithmes). On s’ef-
force ainsi de décomposer un problème complexe en sous-programmes plus simples.
Ce modèle structure d’abord les actions ;
— La programmation orienté objet. Centrée sur les données, elle est considérée plus
stable dans le temps et meilleure dans sa conception. On conçoit des fabriques (classes),
qui servent à produire des composants (objets), qui contiennent des données (attri-
buts) et des actions (méthodes). Les classes dérivent (héritage) de classes de base dans
une construction hiérarchique.
Python offre ces deux paradigmes, que l’on peut mélanger suivant les besoins et suivant ce
qui apparaît comme le plus adapté au problème à résoudre. Il arrive parfois qu’on construise
une solution sous forme procédurale pour ensuite la restructurer partiellement sous une
forme objet plus pérenne et plus réutilisable.
Ainsi, dans cette leçon 1, nous introduisons les bases du langage Python en se focalisant sur
le paradigme procédurale. L’étude du second paradigme en Python sera l’objet de la leçon
2.
2 Caractéristiques de Python
Les langages qui s’imposent sont ceux qui ont su se diversifier et permettre de répondre de
manière pertinente et efficace à une multiplicité de domaines d’application. Python entre
exactement dans ce cadre. Python a été crée par Guido Van Rossum. La première version
de Python a été divulguée en 1991, donc Python a fêté ses 30 ans en 2021 ! A l’automne
2023, nous avons assité à la naissance de la version 3.12 1 de Python.
le langage Python a plusieurs poins forts entre autres :
1. https://www.docstring.fr/blog/les-nouveautes-de-python312/

3 INSTALLATION DE L’ENVIRONNEMENT DE
Programmation
TRAVAIL procédurale en Python
— Simplicité : Python est très facile à apprendre. Ses programmes sont clairement défi-
nis et facilement lisibles. Il utilise peu de mots-clés et une syntaxe clairement définie.
Cela permet à n’importe qui de se familiariser rapidement avec ce langage.
— Open Source : Par conséquent, tout le monde peut utiliser librement le code pour
écrire de nouveaux programmes.
— Langage de programmation de haut niveau : Les programmeurs n’ont qu’à s’oc-
cuper de la solution du problème ; ils n’ont pas à penser aux détails de bas niveau.
— Indépendance de la plate-forme : La machine virtuelle Python convertit le code en
une forme compréhensible par la machine une fois écrit, il est donc indépendant de
la plate-forme.
— Typage dynamique : Python est considéré comme un langage dynamiquement typé,
car il n’est pas nécessaire de déclarer le type de données de la variable utilisée. Il
prend automatiquement son type de données alors qu’en Java, C, etc. les types de
données doivent être déclarés car ce sont des langages à typage statique.
— Procédural et orienté objet : Python permet un style de programmation orienté objet
et orienté procédure. Alors que la technique orientée objet encapsule les données et les
fonctionnalités dans des objets, la technique orientée procédure, quant à elle, construit
le programme autour de procédures ou de fonctions qui ne sont rien d’autre que des
morceaux de programmes réutilisables.
— Interprété : Il n’est pas nécessaire de compiler un programme avant de l’exécuter
car il est compilé au moment de l’exécution uniquement. Vous pouvez simplement
exécuter le programme (Jenkins 2004).
— Extensible : Python étant Open Source, n’importe qui peut y ajouter des modules.
Ces modules permettent aux programmeurs d’ajouter ou de personnaliser leurs outils
pour travailler plus efficacement.
— Vaste bibliothèque : Python fournit une riche bibliothèque intégrée, qui peut être
utilisée directement par le programmeur.
3 Installation de l’environnement de travail

Afin d’exécuter du code Python, nous vous conseillons de mettre en oeuvre un environne-
ment de travail constitué :
— D’un interpréteur Python (Python officiel) :
— https://www.python.org/downloads/
— D’un logiciel d’édition de code (par exemple Pycharm community) :
— https://www.jetbrains.com/pycharm/download/

4 PREMIERS PAS EN PYTHON Programmation procédurale en Python
4 Premiers pas en Python

4.1 Variables
4.1.1 Notion de variable
— les variables permettent d’identifier les objets manipulés par un programme. Ces va-
riables manipulées identifient donc :
— Les entrées (ou données)
— Les sorties (ou résultats)
— les intermédiaires (ou résultats intermédiaires)
— Pour caractériser une variable il faut nécessairement lui attribuer un nom (ou identi-
ficateur)
4.1.2 Déclaration de variable

Une variable est déclarée à l’aide d’une suite de caractères alphanumériques qui commence
par une lettre minuscule ou majuscule et qui ne contient que des lettres, des chiffres et le
caractère souligné. Par ailleurs, les mots réservés (ex : while) ne sont pas utilisables comme
nom de variable.
1 #Initialisation d'une variable

2 #ayant pour nom 'prix_ttc'
3 #et comme valeur 12000.
4 prix_ttc = 12000 # Donner à prix_ttc la valeur 12000
5 1_prix_ttc = 12000 #Mauvaise nomenclature de variable
4.1.3 Les différents types de base de variables
1 # Variable de type 'string' (chaine de caractères)

2 mon_nom = "ATTA"
3 # Variable de type 'integer' (nombre entier)
4 mon_nombre = 27
5 # Variable de type 'float' (nombre à virgule)
6 mon_nombre_a_virgule = 15.661415
7 # Variable de type 'boolean' (booléen en français)
8 # Un booléen peut être soit vrai, soit faux.
9 boolean_vrai = True
10 boolean_faux = False

4.1.4 Quelques manipulations de string et E/S Standard
1 # Variable de type 'string' (chaine de caractères)

2 mon_prenom = "Ferdinand"
3 longueur = len(mon_prenom) #longueur de string
4 # iemecaractere
5 ieme_caractere = mon_prenom[0] #premier caractère
6 sous_chaine = mon_prenom[0:5] #sous chaine
7 #remplacement des n par b
8 nouvelle_chaine = mon_prenom.replace("n","b")
9 #concatenation avec +
10 conc_chaine = mon_prenom+nouvelle_chaine
11 longueur_string = str(longueur)#convertir en chaine
12 #pour le reste help(str)
13 print(mon_prenom) #Sortie standard
14 age = int(input("Entrez votre age")) #Entrée standard
4.2 Opérateurs
4.2.1 Opérateurs arithmétiques
1 add = 10 + 5 # Addition
2 soust = 10 - 5 # Soustraction
3 divise = 10 / 5 # Division
4 multipli = 10 * 5 # Multiplication
5 print(add, soust, divise, multipli)
6 puissance = 10 ** 5 # Puissance
7 # Modulo : Retourne le reste de la division
8 modulo = 10 % 5
9 # Division 'Floor'
10 # Arrondi le resultat de la division
11 # meme si les deux nombre sont des float
12 division_normale = 11.0 / 5.0 #le resultat est 2.2
13 division_floor = 11.0 // 5.0 #le resultat est 2
4.2.2 Opérateurs logiques
1 #True si au moins 1e des propositions est vraie

2 a = True or False # Retourne True
3 b = False or True # Retourne True
4 c = True or True # Retourne True

5 d = False or False # Retourne False

6 # Renvoie True si les 2 propositions sont vraies
7 #False si au moins une des propositions est fausse.
8 a = True and False # Retourne False
9 b = False and True # Retourne False
10 c = False and False # Retourne False
11 d = True and True # Retourne True
12 # Retourne l'inverse de la proposition
13 a = not True # Retourne False
14 b = not False # Retourne True
4.2.3 Opérateurs de comparaison
1 # verifier si 2 propositions sont égales: ==

2 print(10 + 5 == 15) # Retourne True
3 print(10 + 5 == 20) # Retourne False
4 # verifier si 2 propositions diffèrent : !=
5 print(10 + 5 != 15) # Retourne False
6 print(10 + 5 != 20) # Retourne True
7 # verifier si 1 élément est plus petit ou plus
8 #grand qu'1 autre : < et >
9 print(5 < 10) # Retourne True
10 print(10 < 10) # Retourne False
11 # verifier si 1 élément est plus grand ou égal
12 # ou plus petit ou égal a 1 autre >= et <=
13 print(10 >= 10)# Retourne True
4.2.4 Assignation composée

Il s’agit de la combinaison des opérateurs arithmétiques et celui d’affectation.
Les combinaisons possibles sont : +=, **=, -=, *=, /=, %=
1 age = 15
2 age += 15 # Equivaut à: age = age + 15
3 print(age) #affiche 30

5 STRUCTURES DE CONTRÔLE DE FLUX Programmation procédurale en Python
5 Structures de contrôle de flux

5.1 Types de structures
Les structures de contrôle permettent de contrôler l’exécution des instructions dans le code.
Deux types de structures sont disponibles :
— Les Structures de Décision (SD) : Elles aiguillent l’exécution du code en fonction
des valeurs que pourra prendre un test.
— Les Structures de Répétition (SR) : Elles font exécuter une portion de code un cer-
tain nombre de fois, jusqu’à ce que une condition soit remplie ou tant qu’une condition
est remplie
5.2 Structures de décision

5.2.1 La conditionnelle simple
En algorithmique :
Si <condition> Alors
<séquence>
Finsi
Devient en Python :
Syntaxe conditionnelle simple
if<condition>:
<instructions>
Par exemple :
1 # Permet d’exécuter du code si condition est vraie

2
3 age = int(input("Entrez votre age: ")) # Entrée

4 if age <= 7:
5 print("Vous êtes un enfant!!! ")
5.2.2 Conditionnelle composée

En algorithmique :
Si <condition> Alors
<séquence1>
Sinon
<séquence2>

Finsi
Devient en Python :
Syntaxe conditionnelle composée
if<condition>:
<séquence1>
else:
<séquence2>
Par exemple :
1 # Permet d’exécuter du code si condition sinon

2 # aucune condition n'est vraie
3
4 age = int(input("Entrez votre age: ")) # Entrée

5 if age <= 7:
6 print("Vous êtes un enfant!!! ")
7 else:
8 print("Vous n'êtes pas un enfant!!! ")
5.2.3 Conditionnelle multiple

En algorithmique :
Si <condition1> Alors
<séquence1>
Sinon
Si <condition2> Alors
<séquence2>
...
Sinon
<séquenceN>
Finsi
Finsi
Devient en Python :

Syntaxe de conditionnelle multiple

if<condition1>:
<séquence1>
elif <condition2>:
<séquence2>
...
else:
<séquenceN>
Par exemple :
1 # Permet de vérifier plusieurs

2 # conditions à la suite
3 age = int(input("Entrez votre age: "))#Entrée au clavier
4 if age >= 45:
5 print("Vous êtes un adulte")
6 elif age >= 18:
7 print("Vous êtes un jeune!!! ")
8 elif age >= 8:
9 print("Vous êtes un adolescent!!! ")
10 else:
11 print("Vous êtes un gamin")
5.2.4 Structure à choix

En algorithmique : La structure SelonQue permet d’effectuer tel ou tel traitement en fonc-
tion de la valeur des conditions 1 ou 2 ou . . . n .
SelonQue <selecteur> faire
<cas 1> : <sequence1>
<cas 2> : <sequence2>
...
<cas n> : <sequenceN>
Sinon: <sequence_sinon>
FinSelonQue
Devient en Python :

Syntaxe choix multiple

match <selecteur>:
case <pattern_1>:
<sequence1>
case <pattern_2>:
<sequence_2>
...
case <pattern_N>:
<sequenceN>
case _:
<sequence_parDefaut>
Par exemple :
1 status = int(input("Quel est le code renvoyé par votre serveur"))

2 match status:
3 case 400:
4 return "Bad request"
5 case 404:
6 return "Not found"
7 case 418:
8 return "I'm a teapot"
9 case _:
10 return "Something's wrong with the internet"
N.B : L’alternative n’est possible qu’avec une version de Python au moins égale à
3.10
5.3 Structures répétitives

5.3.1 Structure répétitive POUR
structure répétitive "POUR" est utilisée dans le cas où on a un bloc d’instructions à répéter
n fois, avec n connu à l’avance, c-à-dire avant l’exécution de la boucle "POUR"
En algorithmique :
Pour <compteur> ← <debut> à <fin> [par Pas de val_pas] faire
<sequence>
FinPour
Devient en Python :

Syntaxe POUR
for <indice> in <itérateur>:
<séquenceInstructions>
N.B : <itérateur> ∈ { range([indice_debut,] indice_fin[, pas]), list, tuple, string, ...

}
Par exemple :
1 # Exemple: Affiche les températures 0C, ..., 10C,

2 #en Fahrenheit
3 # Differents types de variables : chaine, list,
4 for celsuis in range(0,11):
5 fahrenheit = (celsuis * 9)/5 + 32
6 print("{} C = {} F".format(celsuis, fahrenheit))
5.3.2 Structure répétitive TANT QUE

La structure répétitive TANT QUE est utilisée dans le cas où on a un bloc d’instructions à
répéter et le nombre de répétitions n’est pas connu à l’avance, c-à-dire avant l’exécution de
la boucle TANT QUE. Cependant, on doit pouvoir dans ce cas, déterminer quelle ou quelles
sont les conditions de répétitions.
En algorithmique :
Tant que <condition> faire
<séquence>
Fin Tant que
Devient en Python :
Syntaxe TANT QUE
while<condition>:
<sequence>
Par exemple :
1 # Cette boucle While affichera les nombres de 0-9

2 i = 0
3 while i < 10:
4 print(i)
5 i += 1
6 # ATTENTION! Une boucle While est dangereuse

6 STRUCTURES DE DONNÉES ESSENTIELLES
Programmation procédurale en Python
7 # Si on ne modifie pas la condition, on

8 #créé une boucle infinie.
9 while True:
10 print('Cette boucle ne se termine jamais.')
11 # Il faut toujours permettre à la condition de
12 #changer afin de pouvoir sortir de la boucle.
N.B : Une instruction break peut être utilisée à une itération donnée pour sortir d’une
structure répétitive
6 Structures de données essentielles

6.1 Liste
Un liste est une séquence d’éléments quelconques, ordonnées qui est mutable.
Syntaxe Liste
<nom_liste> =[suite_elements_separés_par_virgule]
Différentes opérations sont possibles dont :

— Accès à un élément : l[2], l[-2]
— Accès à une série d’éléments (slice) : l[2 :5], l[ :-2]
— Longueur : len(l)
— Trier : l.sort() ou sorted(l)
— Renverser : l.sort(reverse=True), sorted(l,reverse=True)
— retirer un élément : l.remove(<element>), del l[<indice>]
— Rajouter en fin : l.append(<element>)
— Fusionner : l1.extend(l2)
1 liste = ['Pierre', 'Paul']

2 # Rajoute l'élément à la fin de la liste
3 liste.append('Jacques')
4 # Insérer 1 élément à 1e position définie dans la liste
5 liste.insert(1, 'Kevin')
6 # Fusionne la liste ajoutée à la liste existante
7 liste.extend(['Bertrand', 'John','Pierre'])
8 #nombre d'occurences d'un éléments
9 pierres = liste.count("Pierre")
10 #parcourir une liste
11 for i in liste:
12 print(i)

13 #comprehenson de liste :
14 autre_liste1 = [1, 2, 3, 4, 5]
15 autre_liste2 = [i*2 for i in autre_liste1]
16 autre_liste3 = [i*2 for i in autre_liste1 if i >= 3]
17 autre_liste4 = [i**2 if i >= 3 else i*2 for i in autre_liste1]
6.2 Tuple
Un tuple est une séquence d’éléments quelconques, ordonnées qui est immutable.
Syntaxe Tuple
<nom_tuple> =(suite_elements_separés_par_virgule)

— Accès à un élément : t[2], t[-2]
— Accès à une série d’éléments (slice) : t[2 :5], t[ :-2]
— Longueur : len(t)
— Appartenance : in
— Concaténation : +
— Duplication : *
— maximum/minimum : max/min
N.B : Les 4 derniers points sont applicables également aux listes et au string
1 # Création d'un tuple

2 mon_tuple = (1, 2, 3)
3 # Recupération de la valeur minimale
4 valeur_min = min(mon_tuple)
5 # Recupération de la valeur maximale
6 valeur_max = max(mon_tuple)
7 #duplication par facteur = 2
8 autre_tuple = mon_tuple*2
6.3 Ensemble
Un ensemble ou set est un ensemble d’élements non redondant et qui est immutable où
l’on peut savoir si un élément est présent sans avoir à parcourir tous l’ensemble.

Syntaxe set
<nom_set> = set(<iterable>)
ou
<nom_set> = {elt1,...,eltn}

— Longueur : len(nom_set)
— Appartenance : in
— maximum/minimum : max/min
— Opérations ensemblistes : union, intersection, difference, issubset, issuperset, isdis-
joint
— Autre opérations : add, update, remove, etc.
Par exemple :
1 # Création de Sets
2 e1 = {1, 2}, e2 = {2, 3}
3 e3 = e1.union(e2) #Union d'ensembles
4 e4 = e1.intersection(e2) #Intersection d'ensembles
5 e5 = e1.difference(e2) #Différence d'ensembles
6 e6 = {2}
7 print(e6.issubset(e1)) #test d'inclusion
8 print(e1.issuperset(e6)) #test de super-ensemble
6.4 Dictionnaire
Un dictionnaire est une sorte de tableau associatif ou ensembles de couples (clé,valeur) ou
items où les clés sont immutable et les valeurs sont mutables.
Syntaxe dictionnaire
<nom_dico> = dict()
ou
<nom_dico> = {"cle_1": valeur_1, ... "cle_N": valeur_N}

— accéder à élément : h1["cle"]
— les clés : keys()
— les valeurs : values()
— les éléments : items()

7 MODULARITÉ Programmation procédurale en Python
— effacer le dictionnaire : clear()

Par exemple :
2 dico1 = {'Pierre': 40, 'Paul': 25}# Créer d'un dictionnaire

3 print(dico1['Pierre'])#Acceder a element
4 print(dico1.keys())
5 print(dico1.values())
6 dico1.items()#liste de tuples(cle,valeur)
7 dico1['Paul'] = 30 #Mis à jour
8 dico1.update({'Pierre': 42})
9 for cle in dico1.keys(): #les cles par une boucle
10 print(cle)
11 for valeur in dico1.values():
12 print(valeur) #les valeurs par une boucle
13 for cle,valeur in dico1.items():
14 print (cle, valeur) #les cles et valeurs par une boucle
15 del dico1['Pierre'] # Supprimer avec del
16 dico2 = {'Pierre': {'age': 40, 'profession': 'banquier'},
17 'Paul': {'age': 25, 'profession': 'ingenieur'}}
18 print(dico2['Pierre']['age'])
7 Modularité
7.1 Fonction
7.1.1 Écriture de fonction
Une fonction est une portion de code (sorte de sous-programme) que l’on peut appeler au
besoin. L’utilisation des fonctions permet :
— d’éviter la répétition
— de mettre en relief les données et les résultats : entrées et sorties de la fonction
— la réutilisation dans d’autres scripts par l’intermédiaire du mécanisme de l’import
— de décomposer une tâche complexe en tâches plus simples.
On obtient ainsi des programmes plus courts et plus lisibles.
1 # Syntaxe
2 def nom_de_la_fonction(<parametres_formels_eventuels>):
3 code_fonction
4 # Appel de la fonction
5 nom_de_la_fonction(<parametres_effectifs_eventuels>)
6 # Fonction sans paramètre et renvoie rien
7 def affiche_paragraphe():

8 print('Bonsoir, Ceci est un bloc de code')

9 print("qui s'affiche quand la fonction est appelée")
10 #Fonction avec paramètre et sans valeur de retour:
11 # Il s'agit donc d'une fonction au sens algorithmique
12 def addition(a=5, b=10):
13 print(a + b)
14 # Fonction avec paramètre et avec valeur de retour:
15 # Il s'agit donc d'une fonction au sens algorithmique
16 def addition(a=5, b=10):
17 c = a + b
18 return c
On peut avoir de déclarer des fonctions avec un nombre de paramètres ou arguments va-
riables. Pour ce faire :
— On passe les paramètres depuis ou vers des conteneurs
— l’opérateur * convertit des arguments non nommés en tuple
— l’opérateur ** convertit des arguments nommés en dictionnaire
1 # Utilisation de l’opérateur *
2 def test_var_args(farg, *args):
3 print('formel arg:', farg)
4 for arg in args :
5 print('autre arg:', arg)
6 test_var_args(1,'two', 3)
7 # Utilisation de l’opérateur **
8 def test_var_kwargs(farg, **kwargs):
9 print ("formel arg:", farg)
10 for key in kwargs :
11 print('autre clé arg: {}:{}'.format(key,kwargs[key]))
12 test_var_kwargs(farg=1,myarg2='two', myarg3=3)
7.1.2 Quelques fonctions particulières

— enumerate() : Produit un itérateur qui retourne un tuple contenant un compteur de
l’itération courante et la valeur obtenue à partir de l’itérateur passé en paramètre. Le
paramètre nommé start permet d’indiquer la valeur de départ du compteur (par défaut
0) :
1 week = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi",

2 "dimanche"]
3 for cpt, v in enumerate(week, start=1):
4 print(cpt, v)
5 # Affiche

6 # 1 lundi
7 # 2 mardi
8 # 3 mercredi
9 # 4 jeudi
10 # 5 vendredi
11 # 6 samedi
12 # 7 dimanche
— map() : Produit un itérateur qui accepte une fonction pour produire une nouvelle
valeur à partir de la valeur obtenue par l’itérateur passé en second paramètre :
1 week = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi",

2 for v in map(str.upper, week):
3 print(v)
4
5 # Affiche
6 # LUNDI
7 # MARDI
8 # MERCREDI
9 # JEUDI
10 # VENDREDI
11 # SAMEDI
12 # DIMANCHE
— filter() : Produit un itérateur qui retourne la valeur de l’itérateur passé en second paramètre que si la fonction passée en premier
paramètre retourne True pour cette valeur.
1 la_semaine = ["lundi", "mardi", "mercredi", "jeudi",

2 "vendredi", "samedi", "dimanche"]
3 for v in filter(lambda x: x.startswith("m"), la_semaine):
4 print(v)
5
6 # Affiche
7 # mardi
8 # mercredi
— zip() : Produit un itérateur qui produit un tuple regroupant les valeurs de chacun des itérateurs (listes, tuple, etc.) passés en
paramètre. L’itération s’arrête lorsque l’un des itérateurs se termine.
Zipper deux listes
1 listA = [19, 21, 46]

2 listB = ['un', 'deux', 'trois']
3 fusion_list = zip(listA, listB)
4 print(list(fusion_list))

8 FICHIER Programmation procédurale en Python
Dezipper deux listes
1 chiff_list = [19, 21, 46]

2 str_list = ['un', 'deux', 'trois']
3 fusion_list = zip(chiff_list, str_list)
4
5 x,y = zip(*fusion_list) #Dezipper = zip()+ operateur *

6 print("chiff_list= ", x)
7 print("str_list= ", y)
7.2 Module et package

Un module est un fichier (*.py ou *.pyc) contenant la définition d’un ensemble de fonctions,
variables, constantes, classes, etc.
Exemple de Module : puissance.py
1 def carre(valeur):
2 resultat = valeur**2
3 return resultat
4 def cube(valeur):
5 resultat = valeur**3
6 return resultat
Plusieurs manières d’utiliser un module

— import nom_module as nom_alias
— from nom_module import nom_fonction
— from nom_module import *
— from nom_package.nom_module import *
— etc...
Un package est un répertoire contenant des modules (et éventuellement des packages). Il
contient un fichier spécial forcément nommé __init__.py
8 Fichier
— Ouverture et fermeture de fichier texte :
1 #Emplacement propre à ma machine donc le changer

2 #selon votre machine
3 chemin = "/home/atta/file.txt" # ou chemin relatif e.g: "file.txt"
4 # Méthode 1:
5 f = open(chemin, mode = "r" encodage= "utf8") # Ouverture pour lecture

8 FICHIER Programmation procédurale en Python
Figure 1 – Exemple de package
6 # faire des opérations sur le contenu du fichier

7 f.close()
8
9 # Autre modes
10 #f = open(chemin, mode = "a" encodage= "utf8") # Ouverture pour ajout
11 #f = open(chemin, mode = "w" encodage= "utf8") # Ouverture pour écriture
12 # Ce dernier écrase le contenu si existant
13 #Méthode 2
14 with open(chemin) as f:
15 # faire des opérations sur le contenu du fichier
16 pass
— Ecriture dans fichier texte :
1 chemin = 'file.txt'
2 #Methode1 : sans with
3 #mode="w" écrit en écrasant le contenu exisant
4 # à sa suite
5 f = open(chemin, 'w', encoding="utf8")
6 f.write('Contenu1 ajouté \n') # ou f.writelines(liste_de_lignes)
7 f.writelines(['Contenu2 ajouté\n', 'Contenu3 ajouté\n'])
8
9 f.close()
10 #Methode2 : avec with
11 #Pour écrire dans un fichier et rajouter du contenu
12 with open(chemin, mode='a', encoding='utf8') as f:
13 f.write('Contenu4 ajouté\n')
14

9 EXERCICES D’APPLICATION Programmation procédurale en Python
15
— Lecture de fichier texte :
1 chemin = 'file.txt'
2 f = open(chemin, 'r', encoding="utf8")
3 #Méthode1:
4 # Récupérer le contenu complet du fichier dans
5 #une chaine de caractere avec f.read()
6
8 #Méthode2:
9 #contenu du fichier sous la forme d’un tableau de chaînes
10 #de caractères (un élément par ligne)
11 lignes = f.readlines()
12 for ligne in lignes:
13 print(ligne.rstrip('\n'))# supprimer caractère de fin de ligne
14 f.close()
15 #Possibilité d'utiliser with comme pour lecture
16 with open(chemin, mode='r', encoding='utf8') as f:
17 for l in f:
18 print(l.rstrip('\n'))
9 Exercices d’application
9.1 Enoncé
1. Lequel des éléments suivants est utilisé pour initialiser plusieurs variables avec une
valeur commune ?
a) x = y : y = 33 b) x = y = z = 33
c) x = z ; y = z ; x = 33 ; d) x & y & z = 33
2. Qu’est ce qui s’affiche après exécution du code précédent si on remplace la dernière
instruction par ?
b = 1
for a in range(1,6):
b = b+a
print(b)
a) 20 b) 16 c) 17 d) 15
3. Quelle sera la sortie après les déclarations suivantes ?
x = [25, 35, 45]
y = x[1]
print(y)

11 CONCLUSION Programmation procédurale en Python
a) x1 b) 25 c) 45 d) 35
4. Quelle est la bonne méthode pour charger un module ?
a) Using math b) #include math.h c) import math d) include math
9.2 Solution
1.b) 2.b) 3.d) 4.c)
10 Travaux dirigés
Voir fiche d’exercices n°1.
11 Conclusion
— Python est un langage simple, généraliste, très puissant et beaucoup utilisé aujour-
d’hui dans les domaines tels que l’IA, l’automatisation de taches (administration sys-
tème, réseau).
— La programmation procédure est implémenté par Python (voir Figure 2)
— Pour allez plus loin 2 :
— Fonction anonyme, fonction génératrice, décorateur
— Structure de données avancées : namedtuple, defaultdict, dataclass,
Counter
— Traitement de fichier csv, xlsx, etc.
2. compléments pour décorateurs,fichiers csv, etc.

11 CONCLUSION Programmation procédurale en Python
Figure 2 – Structure type d’un programme procédural python

RÉFÉRENCES Programmation procédurale en Python
Références
[1] Vijay Kumar Sharma, Vimal Kumar, Swati Sharma, and Shashwat Pathak. Python Pro-
gramming. Chapman and Hall/CRC, jul 2021.
[2] Bob Cordeau and Laurent Pointal. Python 3-2e éd. : Apprendre à programmer dans
l’écosystème Python. Dunod, 2020.
[3] Gérard Swinnen. Apprendre à programmer avec Python 3. Editions Eyrolles, 2012.
[4] Sébastien Chazallet. Python 3 Les fondamentaux du langage. ENI, 2019.
[5] https://gayerie.dev/docs/python/index.html

Programmation Python
Chapitre 2: Programmation orientée objet en Python
Chargé de cours:
Dr. ATTA Amanvon Ferdinand
Année académique 2023-2024
Note
Ce document est un ensemble de notes de cours du chapitre 2 du cours intitulé Pro-
grammation Python délivré par Dr. ATTA Amanvon Ferdinand en Licence 2/3EA. S’il
vous plaît, envoyez vos commentaires et/ou corrections à ferdinand.atta@outlook.fr.
1
TABLE DES MATIÈRES POO en Python
Table des matières

Pré-requis 3
Objectifs 3
1 Introduction 4
2 Objet et classe 4
2.1 Objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.2 Attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.3 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 Principes de la POO 8
3.1 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.1.2 Membres privés, Mutateur & Accesseur . . . . . . . . . . . . . . . 9
3.1.3 Exemples d’implémentations de l’encapsulation . . . . . . . . . . . 9
3.2 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.1 Définition de l’héritage . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.2 Exemple d’implémentation de l’héritage . . . . . . . . . . . . . . . 11
3.3 Polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3.1 Définition du polymorphisme . . . . . . . . . . . . . . . . . . . . 12
3.3.2 Exemple d’implémentation du polymorphisme . . . . . . . . . . . 12
4 Méthode et classe abstraite 13

4.1 Méthode abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2 Classe abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.3 Exemple d’implémentation de classe abstraite . . . . . . . . . . . . . . . . 13
5 Exceptions 14
5.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.2 Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.2.1 Levée d’exception . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.2.2 Capture des exceptions . . . . . . . . . . . . . . . . . . . . . . . . 15
6 Conclusion 17

TABLE DES MATIÈRES POO en Python
Pré-requis
— Les notions de programmation procédurale en Python
Objectifs
— Introduire les concepts de la POO
— Présenter l’implémentation des concepts de la POO en python
— Apprendre à traiter les exceptions

2 OBJET ET CLASSE POO en Python
1 Introduction
La Programmation Orientée Objet (POO) est un paradigme de programmation basé sur
le concept d’"objets", qui peuvent contenir des données et du code : des données sous la
forme de champs (souvent appelés attributs ou propriétés) et du code, sous la forme de
procédures (souvent appelées méthodes). La POO utilise des objets et des classes dans la
programmation, qui vise à mettre en œuvre des entités du monde réel comme l’héritage, le
polymorphisme, l’encapsulation, etc. L’idée principale de la POO est de lier les données
et les fonctions qui fonctionnent ensemble comme une seule unité. Il s’agit d’un paradigme
de programmation largement utilisé pour écrire des applications puissantes. Il modélise
des choses complexes sous forme de structures simples et reproductibles, ce qui permet la
réutilisation du code, l’évolutivité et l’efficacité.
Figure 1 – Programmation procédurale vs programmation Objet
Dans cette leçon, nous allons apprendre tous les concepts fondamentaux de la POO en Py-
thon. Nous commencerons par les bases de la POO, puis nous apprendrons l’héritage, l’en-
capsulation et le polymorphisme. Par ailleurs, nous introduirons la gestion des exceptions :
phénomène basée sur la POO.
2 Objet et classe
2.1 Objet
— L’objet est unité cohérente possédant :
— une identité
— un état, défini par des données (attributs, ou données membres)
— un comportement, défini par des fonctions (méthodes, ou fonctions membres).
— Un objet peut représenter :
— un objet concret du monde réel, ayant une réalité physique : une personne, une
voiture, un outil, un système mécanique. . .

— un concept abstrait : un compte bancaire, une contrainte mécanique, une vitesse.

..
— une activité produisant des effets observables : un calcul numérique, un pilote
d’impression
2.2 Classe
2.2.1 Définition
— Le concept de classe désigne un modèle représentant une famille d’objets partageant :
— La même structure de données (c.à.d. même liste d’attributs)
— Les mêmes méthodes
— La classe par elle-même ne contient pas les valeurs des données : c’est un modèle
qui décrit la structure des données. Chaque objet (instance d’une classe) donne des
valeurs aux attributs de la classe.
— création en python : on utilise le mot clé class avec pour constructeur __init__ .
Lorsque nous créons un objet à partir d’une classe, la première méthode qui est appe-
lée est la méthode __init__(). Elle est connue sous le nom de méthode "constructeur"
ou plus simplement constructeur. En d’autres termes, __init__() crée une instance
de la classe. En Python, chaque classe possède une méthode __init__(). Que vous la
définissiez explicitement ou qu’elle soit définie implicitement par Python, elle existe
dans chaque classe. Le premier paramètre de la méthode __init__() sera toujours self
(comme toutes les autres méthodes d’une classe). Après cela, vous pouvez déclarer
tous les arguments que vous voulez que votre classe accepte.
1 class Humain:
2 def __init__(self):
3 pass
2.2.2 Attributs
Un attribut d’instance est un attribut dont la valeur peut être différente pour chaque ins-
tance de la classe. En clair, la valeur d’un attribut A pour un objet1 n’est pas forcément
égale à la valeur de l’attribut A pour un objet2 : objet1 et objet2 étant des instances de la
même classe. Par exemple, dans la classe Humain ci-dessous, l’attribut nom est un attribut
d’instance.
1 class Humain:
2 def __init__(self, nom):
3 self.nom = nom #nom est un attribut instance
4 #humain avec pour attribut instance nom = "ATTA"
5 humain1 = Humain("ATTA")

6 #humain avec pour attribut instance nom = "ANOH"

7 humain2 = Humain("ANOH")
8 print(humain1.nom)
9 print(humain2.nom)
Un attribut de classe est un attribut dont la valeur est la même pour chaque instance de la
classe, c’est-à-dire pour chaque objet créé à partir de cette classe. Pour définir un attribut
au sein d’une classe, il suffit d’assigner une valeur à cet attribut dans le corps de la classe.
Par exemple, dans la classe Humain ci-dessous, l’attribut lieu_habitation est un attribut de
classe.
1 class Humain:
2 lieu_habitation = "Terre" #nom est un attribut de classe
5 humain1 = Humain("ATTA")
6 humain2 = Humain("ANOH")
7 print(humain1.lieu_habitation)
8 print(humain2.lieu_habitation)
9 print(Humain.lieu_habitation)
2.2.3 Méthodes
Une méthode d’instance est une méthode applicable que sur un objet. En clair, on ne
peut faire appel à une méthode d’instance qu’en passant par un objet (c’est-à-dire ob-
jetA.methode_instance()).
N.B : Une méthode d’instance doit avoir impérativement comme premier attribut self.
1 class Humain:
5 def parler(self, message): #Methode d’instance
6 print("{} a dit {}".format(self.nom, message))
7 humain = Humain("ATTA")
8 message = "bon apprentissage de la POO"
9 humain.parler(message)
Une méthode de classe est une méthode qui peut s’exécuter sans instancier la classe (pas
de création d’objet). Elle doit absolument avoir comme premier paramètre le mot clé cls.

1 class Humain:
7 #Methode de classe
8 def changer_planete(cls, nouvelle_planete):
9 Humain.lieu_habitation = nouvelle_planete
10 changer_planete = classmethod(changer_planete)
11 print("Planète actuelle: {}".format(Humain.lieu_habitation))
12 Humain.changer_planete("Mars")
13 print("Planete actuelle: {}".format(Humain.lieu_habitation))
Une méthode statique est très similaire à une méthode de classe, mais la différence est que
nous n’avons pas besoin d’utiliser le mot-clé ’cls’. Une méthode statique n’a pas accès à
l’état de la classe et ne peut donc pas la modifier. Alors pourquoi avons-nous besoin d’une
méthode statique ? Eh bien, une méthode statique peut être utilisée comme une méthode de
type utilitaire qui peut prendre des paramètres et effectuer certaines actions.
1 class Humain:
10 def definition():#Methode statique
11 print("L’humain est le plus haut être vivant de l’univers")
12 definition = staticmethod(definition)
13 Humain.definition()
En plus des méthodes de classe ordinaires, il y a un certain nombre de méthodes spéciales

que les classes Python peuvent définir. Au lieu d’être appelées directement par votre code
(comme les méthodes ordinaires) les méthodes spéciales sont appelées pour vous par Python
dans des circonstances particulières ou quand une syntaxe spécifique est utilisée.
Ces méthodes portent des noms prédéfinis, précédés et suivis de deux caractères de souli-
gnement. Entre autres :
— Représentation et comparaison de l’objet : __str__, __repr__, __unicode__, __cmp__,
__lt__, __gt__

3 PRINCIPES DE LA POO POO en Python
— Utilisation de l’objet comme fonction : __call__

— Accès aux attributs de l’objet : __getattr__, __setattr__
— Utilisation de l’objet comme conteneur : __getitem__, __setitem__, __delitem__,
__len__
— Utilisation de l’objet comme type numérique(surcharge d’opérateurs) : __add__, __sub__
à initialiser l’objet instancié(__init__ déjà vu) .
1 class Humain:
3 def __init__(self, nom = ""):
10 def definition():
11 print("L’humain est classé comme le plus haut être\
12 vivant de l’univers")
13 definition = staticmethod(definition)
14 def __str__(self):
15 return "L’humain {}".format(self.nom)
16 humain = Humain("ATTA")
17 print(humain)
3 Principes de la POO
3.1 Encapsulation
3.1.1 Définition
Dans certaines situations, nous pouvons souhaiter que personne n’accède aux attributs (ou
données) de notre classe. Nous pouvons vouloir contrôler l’accès. Cela se fait via l’encap-
sulation. Dans la terminologie de la POO, l’encapsulation est le regroupement des attributs
et des méthodes dans un seul objet. En faisant cela, nous pouvons cacher l’état interne de
l’objet de l’extérieur. L’encapsulation fournit un masquage de l’information :
— Les données de l’objet sont encapsulées dans l’objet
— Ne pas dévoiler les détails d’implémentation en dehors de l’objet
— Pas d’accès direct aux variables d’instance, et à certaine(s) méthode(s)
— Pas recommandé d’accéder directement aux variables d’instance

3.1.2 Membres privés, Mutateur & Accesseur

— Membre privées (attributs ou méthodes) sont des membres ne sont accessibles qu’à
l’intérieur de la classe. Un membre privée en Python est obtenu en préfixant son nom
avec __
— Ne pourra pas être accédée en dehors de la classe
— Accesseur : Accéder à une variable privée
— Méthode qui renvoie une variable d’instance
— Mutateur : Modification d’une variable privée
— Méthode qui change la valeur d’une variable d’instance
3.1.3 Exemples d’implémentations de l’encapsulation

Exemple (1/4) : Exemple "Méthode Java/C++ "
1 class compte:
2 """gestion d'un compte bancaire"""
3 def __init__(self,nom,numero,valeur):
4 self.nom = nom
5 self.numero = numero
6 self.setSolde(valeur)
7 def getSolde(self): #Accesseur
8 return self.__solde #variable privee
9 def setSolde(self,x): #Mutateur
10 if x>=0:
11 self.__solde += x
12 elif abs(x)>= 50000:
13 self.__solde = -50000
14 print("Compte suspendu")
15 monCompte = compte("ATTA",777,10000)
16 monCompte.setSolde(-50000)
17 print(monCompte.getSolde())
Exemple (2/4) : : Exemple 1 "property avec décorateur"
1 class compte:
3 self.nom = nom
5 self.solde = valeur
6 @property
7 def solde(self): #Accesseur
8 return self.__solde #variable privée
9 @solde.setter

10 def solde(self,x): #Mutateur

11 if x>=0:
13 elif abs(x)>= 50000:
16 monCompte.solde = -50000
17 print(monCompte.solde)
Exemple (3/4) : Exemple 2 "property sans décorateur"
1 class compte:
3 self.nom = nom
5 self.setSolde(valeur)
6 def getSolde(self): #Accesseur
8 def setSolde(self,x): #Mutateur
9 if x>=0:
11 elif abs(x)>= 50000:
13 solde = property(getSolde,setSolde) #property
Exemple (4/4) : Exemple 3 "Pythonique :Une seule façon de faire"
1 class compte:
3 self.nom = nom
5 self.__setSolde(valeur)
6 def __getSolde(self): #Methode privee
8 def __setSolde(self,x): #Methode privee
9 if x>=0:
11 elif abs(x)>= 50000:
13 solde = property(__getSolde,__setSolde)

3.2 Héritage
3.2.1 Définition de l’héritage
L’héritage est une relation de spécialisation/généralisation entre deux classes. Elle indique
qu’une classe dite classe fille (ou classe dérivée ou sous-classe) spécialise une autre classe
dite classe mère (ou classe de base, ou classe parente, ou super classe), i.e. qu’elle possède
les attributs et les méthodes de la classe mère plus d’autres qui lui sont propres. Il existe
deux principaux types d’héritage :
1. L’héritage simple : toute classe fille n’avait qu’une seule classe de base (ou classe
mère) ;
2. L’héritage multiple : toute classe fille peut avoir au moins deux classes de base : la
classe fille peut hériter de toutes les propriétés (ou attributs) et méthodes de plusieurs
classes. méthodes de plusieurs classes.
1 class classeMere1:
2 def __init__(self):
3 pass
4 class classeMere2:
5 def __init__(self,param2):
6 , self.param2 = param2
7 class classeFille1(classeMere1): #Heritage simple
8 def __init__(self,paramf1):
9 classeMere1.__init__(self) #ou: super().__init__(self)
10 self.paramf1 = paramf1
11 class classeFille2(classeMere1, classeMere2):#Heritage multiple
12 def __init__(self, param2,paramf2):
13 classeMere1.__init__(self)
14 classeMere2.__init__(self,param2)
15 self.paramf2 = paramf2
3.2.2 Exemple d’implémentation de l’héritage
1 class Pere(Humain): #Heritage simple

2 def __init__(self, nom, psa):
3 Humain.__init__(self,nom)
4 #taux d'Antigene prostatique specifique
5 self.psa = psa

6 class Mere(Humain): #Heritage simple

7 def __init__(self, type_cheveux=""):
8 Humain.__init__(self,nom)
9 self.type_cheveux = type_cheveux
10 class Enfant(Pere, Mere): #Heritage multiple
11 def __init__(self, jouet,nom,psa,):
12 Pere.__init__(self)
13 Mere.__init__(self)
14 self.jouet_prefere = jouet
15 enfant = Enfant("velo","ATTA",2.5)
3.3 Polymorphisme
3.3.1 Définition du polymorphisme
Le polymorphisme est le mécanisme qui permet à une classe fille de redéfinir une méthode
dont elle a hérité de sa classe mère, tout en gardant la même signature(nom et liste de para-
mètres en python).
L’intérêt majeur est d’adapter le traitement qu’effectue la méthode aux spécificités de la
classe fille. Et ce sous un même nom ce qui permet d’avoir des codes génériques.
En Python il n’y a aucune difficulté à mettre en oeuvre le polymorphisme, il suffit juste
d’implémenter la méthode en question dans la classe mère et la classe fille. Le choix de
la "bonne" méthode à utiliser se fera alors automatiquement selon la nature de l’objet, i.e.
selon qu’il appartienne à la classe mère ou à la classe fille.
3.3.2 Exemple d’implémentation du polymorphisme
1 class rectangle:
2 def __init__(self,x,y):
3 self.x = x
4 self.y = y
5 def surface(self):
6 print("methode fille")
7 return self.x * self.y
8 class paveDroit(rectangle):
9 def __init__(self,x,y,z):
10 super().__init__(x,y)
11 self.z = z
12 def surface(self):
13 print("methode fille")
14 return 2*(self.x *self.y+self.x*self.z+self.y*self.z)
15 photo = rectangle(3,4)
16 print(photo.surface())

4 MÉTHODE ET CLASSE ABSTRAITE POO en Python
17 weston = paveDroit(3,4,10)
18 print(weston.surface())
4 Méthode et classe abstraite

4.1 Méthode abstraite
Méthode abstraite = méthode sans implémentation :
— Spécification d’un concept
— Dont la réalisation diffère selon les sous-classes :
⇒ doit être redéfinie et implémentée dans les sous-classes (sinon elles ne pouront pas
être instanciées)
4.2 Classe abstraite

— Une classe abstraite est une classe qui contient au moins une méthode abstraite
— Une classe abstraite est une classe de base qui va servir uniquement à dériver des
classes complémentaires
— Elle ne permet pas être instanciée ⇔ création d’objets impossibles
— Si une classe dérivée d’une classe abstraite ne redéfinit pas toutes les méthodes abs-
traites alors elle est aussi abstraite
— Pour utiliser une classe abstraite on doit définir une classe fille qui fournit les réalisa-
tions des méthodes abstraites de la classe (mère) abstraite
— Objectif :
⇒ Exhiber des concepts communs à un ensemble de classes (abstraction)
En Python, le module abc permet de simuler ce type d’approche. Le nom de ce module est
la contraction de abstract base classes. Ce module fournit une méta-classe appelée ABC-
Meta qui permet de transformer une classe Python en classe abstraite. Ce module fournit
également le décorateur @abstractmethod qui permet de déclarer comme abstraite une
méthode, une méthode statique, une méthode de classe ou une propriété. Cela signifie qu’il
n’est pas possible de créer une instance d’une classe qui hérite d’une classe abstraite tant
que toutes les méthodes abstraites ne sont pas implémentées.
4.3 Exemple d’implémentation de classe abstraite

1. Définition d’une classe abstraite

5 EXCEPTIONS POO en Python
1 from abc import ABCMeta, abstractmethod

2
3 class Animal(metaclass=ABCMeta):
4 @abstractmethod
5 def crier(self):
6 pass
N.B : Toute tentative de créer un objet de type Animal échouera à l’exécution.

2. Définition d’une classe dérivée héritant de la classe abstraite
1 # Si les deux classes ne sont pas dans le même module alors

2 # Importer la classe depuis son module
3
4 class Chien(Animal):
5 def crier(self):
6 print("whouaf whouaf !")
7
8 c = Chien()
9 c.crier()
— La classe Animal est en quelque sorte devenu un contrat qui indique que toute classe
qui en hérite doit fournir une implémentation pour la méthode crier().
5 Exceptions
5.1 Définition
Il arrive que lors de l’exécution d’un programme Python, le programme ne s’exécute pas du
tout ou le programme s’exécute mais génère une sortie inattendue ou se comporte anorma-
lement. Cela se produit lorsqu’il y a des erreurs de syntaxe, d’exécution ou de logique dans
le code.
Les exceptions 1 font partie d’un mécanisme de gestion des erreurs en Python. Elles per-
mettent de baliser les étapes d’un programme pour faire face à des situations pour lesquelles
celui-ci n’a pas été prévu. L’exception permet de définir le type d’erreur rencontrée et de
donner des indications à l’utilisateur quant à la nature de cette erreur. Même si une instruc-
tion ou une expression est syntaxiquement correcte, une erreur peut survenir pendant son
exécution. Par exemple, essayer d’ouvrir un fichier qui n’existe pas, une division par zéro,
etc.
1. Voir la sémantique des exceptions natives en Python: https://docs.python.org/fr/3/library/exceptions.html

Figure 2 – Exemple
5.2 Gestion des exceptions

Chaque exception doit être gérée par le programmeur pour éviter que le programme ne s’ar-
rête brusquement. Pour ce faire, il faut écrire du code supplémentaire dans un programme
afin de donner des messages ou des instructions appropriés à l’utilisateur lorsqu’il rencontre
une exception. Ce processus est connu sous le nom de gestion des exceptions.
5.2.1 Levée d’exception

Toutes les erreurs qui se produisent lors de l’exécution d’un programme Python sont re-
présentées par une exception. Une exception est une instance d’une classe qui contient des
informations sur le contexte de l’erreur.
Figure 3 – Classes d’exceptions standards
Des exceptions sont automatiquement levées par les fonctions built-in de python. Cependant,
il est possible de lever ses propres exception à l’aide du mot-clé raise.
Exemple :
5.2.2 Capture des exceptions

On dit qu’une exception est capturée (ou traitée) lorsqu’un code qui est conçu pour gérer
une exception particulière est exécuté. Les exceptions, s’il y en a, sont capturées dans le bloc

Figure 4 – Classes d’exceptions standards
try et le bloc try comporte les clauses suivantes :

Syntaxe de capture
try:
# Code que vous voulez protéger des exceptions
except <ClassException> as <ex>:
# Code qui gère l'exception
else:
# Code qui s'exécute si "try" s'exécute normalement (une
#clause "except" doit être présente)
finally:
# Code qui s'exécute toujours, que l'exception se
# produise ou non
N.B : les deux dernières clauses sont facultatives Exemple :
1 print ("Gestion des exceptions à l'aide de try...except...else...finally")

2 try:
3 numerateur=50
4 denominateur=int(input("Enter le denominateur: "))
5 quotient=(numerateur/denominateur)
6 print ("Division effectuée avec succès")
7 except ZeroDivisionError:
8 print ("Zéro comme Dénominateur n'est pas permis")
9 except ValueError:
10 print ("Uniquement des entiers doivent être saisis")
11 else:
12 print ("Le résultat de l'opération de division est ", quotient)
13 finally:
14 print ("Terminé.")

6 CONCLUSION POO en Python
6 Conclusion
La Programmation Orientée Objet (POO) est très utile car nous pouvons écrire un morceau
de code et réutiliser ce code en créant différentes classes et instances de ces classes. Cha-
cune de ces classes peut ajouter de nouvelles fonctionnalités sans avoir à écrire/changer ou
modifier le code existant. Les programmes complexes nécessitent l’utilisation de classes et
d’objets car nous pouvons créer plusieurs morceaux de code gérables.
La POO est basée sur les principes suivant :
— Encapsulation
— Héritage
— Le polymorphisme
Pour allez plus loin :
— Méta classe
— Personnalisation d’exception

RÉFÉRENCES POO en Python
Références
[1] Vijay Kumar Sharma, Vimal Kumar, Swati Sharma, and Shashwat Pathak. Python Pro-
gramming. Chapman and Hall/CRC, jul 2021.
[2] Bob Cordeau and Laurent Pointal. Python 3-2e éd. : Apprendre à programmer dans
l’écosystème Python. Dunod, 2020.
[3] Gérard Swinnen. Apprendre à programmer avec Python 3. Editions Eyrolles, 2012.
[4] Sébastien Chazallet. Python 3 Les fondamentaux du langage. ENI, 2019.

RÉFÉRENCES POO en Python
Annexe
Figure 5 – Structure type d’un programme POO

Python UPB ASSRI MIAGE 2023 2024

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

Python UPB ASSRI MIAGE 2023 2024

Transféré par

Droits d'auteur :

Formats disponibles

Université Polytechnique de Bingerville

Année Académique 2023-2024

Filière/Niveau : MIAGE&ASSRI /L1

Enseignant : Dr. ATTA Amanvon Ferdinand

Table des matières

3 Installation de l’environnement de travail 6

4 Premiers pas en Python 7

5 Structures de contrôle de flux 10

6 Structures de données essentielles 15

©Dr. ATTA - Toute reproduction interdite 2/ 26

©Dr. ATTA - Toute reproduction interdite 3/ 26

©Dr. ATTA - Toute reproduction interdite 4/ 26

©Dr. ATTA - Toute reproduction interdite 5/ 26

3 Installation de l’environnement de travail

©Dr. ATTA - Toute reproduction interdite 6/ 26

4 Premiers pas en Python

4.1.2 Déclaration de variable

1 #Initialisation d'une variable

4.1.3 Les différents types de base de variables

1 # Variable de type 'string' (chaine de caractères)

©Dr. ATTA - Toute reproduction interdite 7/ 26

4.1.4 Quelques manipulations de string et E/S Standard

1 # Variable de type 'string' (chaine de caractères)

4.2.2 Opérateurs logiques

1 #True si au moins 1e des propositions est vraie

©Dr. ATTA - Toute reproduction interdite 8/ 26

5 d = False or False # Retourne False

4.2.3 Opérateurs de comparaison

1 # verifier si 2 propositions sont égales: ==

4.2.4 Assignation composée

©Dr. ATTA - Toute reproduction interdite 9/ 26

5 Structures de contrôle de flux

5.2 Structures de décision

1 # Permet d’exécuter du code si condition est vraie

3 age = int(input("Entrez votre age: ")) # Entrée

5.2.2 Conditionnelle composée

©Dr. ATTA - Toute reproduction interdite 10/ 26

1 # Permet d’exécuter du code si condition sinon

4 age = int(input("Entrez votre age: ")) # Entrée

5.2.3 Conditionnelle multiple

©Dr. ATTA - Toute reproduction interdite 11/ 26

Syntaxe de conditionnelle multiple

1 # Permet de vérifier plusieurs

5.2.4 Structure à choix

©Dr. ATTA - Toute reproduction interdite 12/ 26

Syntaxe choix multiple

1 status = int(input("Quel est le code renvoyé par votre serveur"))

5.3 Structures répétitives

©Dr. ATTA - Toute reproduction interdite 13/ 26

N.B : <itérateur> ∈ { range([indice_debut,] indice_fin[, pas]), list, tuple, string, ...

1 # Exemple: Affiche les températures 0C, ..., 10C,

5.3.2 Structure répétitive TANT QUE

1 # Cette boucle While affichera les nombres de 0-9

©Dr. ATTA - Toute reproduction interdite 14/ 26

7 # Si on ne modifie pas la condition, on

6 Structures de données essentielles

Différentes opérations sont possibles dont :

1 liste = ['Pierre', 'Paul']

©Dr. ATTA - Toute reproduction interdite 15/ 26

Différentes opérations sont possibles dont :

1 # Création d'un tuple

©Dr. ATTA - Toute reproduction interdite 16/ 26

Différentes opérations sont possibles dont :

5 x,y = zip(fusion_list) #Dezipper = zip()+ operateur

— Utilisation de l’objet comme fonction : call