Python Parcours Complet Integral

Programmation Python :
Parcours complet
Pr Mamadou BOUSSO
Maitre de conférence en Informatique
UIDT / UFR SES
M. Mansour DIOUF
Doctorant en Informatique ED2DS – UIDT
Introduction à l’algorithmique
PARTIE 1
Introduction à Instructions Séquentielles
l’algorithmique
en Python
Structures Conditionnelles
Structures Itératives
01/02/2021 Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 2

• Avez-vous déjà ouvert et utilisé un livre de recettes de cuisine ?
• Avez vous déjà déchiffré un mode d’emploi traduit directement du chinois pour faire
marcher un téléphone ?
Si oui, sans le savoir, vous avez déjà exécuté des algorithmes.
• Plus fort : avez-vous déjà indiqué un chemin à un touriste égaré ?
• Avez vous fait chercher un objet à quelqu’un par téléphone ?
Si oui, vous avez déjà fabriqué – et fait exécuter – des algorithmes.
Comme quoi, l’algorithmique n’est pas un savoir ésotérique réservé à quelques rares initiés
touchés par la grâce divine, mais une aptitude partagée par la totalité de l’humanité.
Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 3

NOTION D’ALGORITHME ET FORMALISME
DÉFINITION
§ Un algorithme est une suite d’instruction qui permet de
résoudre un problème en un nombre fini d’étapes ;
§ Art de décomposer un problème en une suite

d’instructions simples pouvant être exécutées par un
ordinateur ;
§ Suite finie de règles à appliquer dans un ordre déterminé

a un nombre fini de données pour arriver en un nombre
fini d’étapes, a un certain résultat (Encyclopeadia Univ.)
Le terme Algorithme
Vient du mathématicien arabe
Muhammmad ibn Musa alKharezmi

NOTION D’ALGORITHME ET FORMALISME
EXEMPLES D’ALGORITHMES
§Itinéraire de voyage
§Préparer un repas
§Gestion de la file d’attente
§Allocation de ressource
§Etablir un plan
§ Un nombre fini d’étapes;
§ Un nombre fini d’opérations par étape;
§ Une suite d’opérations primitives;
§ Fournit un résultat (décidabilité)
Chaque opération est :
• Non ambiguë
• Effective
Indépendant :
• Du langage de programmation dans lequel il est traduit
• De l’ordinateur sur lequel le programme doit être exécuté
Historiquement, deux façons pour représenter un algorithme :
v L’organigramme : Représentation graphique avec des symboles (carrés, losanges, etc.)
§ Offre une vue d’ensemble de l’algorithme ;
§ Représentation quasiment abandonnée aujourd’hui.
v Le pseudo-code : Représentation textuelle avec une série de conventions
§ Plus pratique pour écrire un algorithme ;
§ Représentation largement utilisée ;

Initialisation (Entrées)
– Repérer les données nécessaires à la résolution du problème.
Les données sont dans l’énoncé du problème ou fournies par l’utilisateur
Ex: Liste des ingrédients pour une recette de cuisine.
• Traitement (Méthode)
– Déterminer les étapes élémentaires (instructions) pour aboutir au résultat attendus
Ex: Mélanger les ingrédients, cuire pour une recette
• Restituer le résultat (Sortie)
Ex: présenter le plat cuisiné

Algorithme : Calcul du prix TTC d’un produit acheté
Initialisation :
- Prendre connaissance du prix unitaire et du nombre d’article acheté
- Prendre connaissance du taux de TVA
Traitement :
- Multiplier le prix unitaire avec le nombre d’article pour connaitre le prix hors taxe
- Ensuite multiplier le prix hors taxe avec le taux de la TVA
- Additionner les deux valeurs retrouvées
Restituer le résultat :
- Afficher la valeur de la somme effectuée dans le traitement
Un algorithme doit être compréhensible et lisible par plusieurs personnes.
Il doit donc suivre des règles.
Un algorithme est composé d’une en-tête et d’un corps
L’en-tête contient :
• Le nom de l’algorithme
• La déclaration de tous les objets locaux à l’algorithme
Le corps contient :
• Le mot clé début
• Une suite d’instructions
• Le mot clé fin
• Un programme est la description d’un algorithme avec un langage accepté
par la machine (ordinateur) ;
• Un algorithme, à l’inverse d’un programme, est indépendant du langage de
programmation (et donc de ce machine).
ALGORITHME PROGRAMME

Spécification
algorithmique
Problème
Traduction
Algorithme
Exécution
Programme
Résultats

• Analyse et définition des besoins : Ce que le programme devra réaliser comme tâche. L’analyse et la
spécification du problème se fera dans un « langage naturel »
• Spécification du programme : Définir spécifiquement chaque fonctionnalité du programme.
• Conception : Décomposition du programme en sous problème (définition des modules du programme) ainsi
que le développement des algorithmes nécessaires au fonctionnement du programme.
• Programmation : Traduction des algorithmes dans le langage de programmation choisi pour la réalisation
du programme. On parle d’implémentation.
• Tests et validation : Phase durant laquelle le bon fonctionnement, ainsi que la conformité du programme
aux spécifications sont vérifiés.
• Maintenance : Activité qui assure l’entretien et le bon fonctionnement du programme tant et aussi
longtemps qu’il sera utilisé.
ORDINATEUR
SOFT WARE
HARD WARE

• Construit autour d’un ensemble de circuits électroniques
(le courant passe, le courant ne passe pas) ;
• Traite donc que des signaux assimilables à 0 ou 1 ;
• Une opération élémentaire → suite de 0 et de 1 = suite de bits (BInary digiT) ;
• Un champ de 8 bits constituant ce qu'on appelle 1 octet ;
• Pour que les programmes et les données soient compréhensibles par
l’ordinateur il faut effectuer un codage binaire ;

• Constitué de 0 et de 1
• Directement exécutable par la machine
• Non portable : Chaque famille de processeur possède son langage
• Ne manipule que des registres de taille fixée (64 bits en général)
• Ne permet d’effectuer que des opérations élémentaires
(accès mémoire, additions, soustractions, etc.)

L'ENIAC (acronyme de l'expression anglaise
Electronic Numerical Integrator And
Computer) est en 1945 le premier ordinateur
entièrement électronique construit pour être
Turing-complet. Il peut être reprogrammé
pour résoudre, en principe, tous les
problèmes calculatoires.

ENIAC
MACBOOK 1945
2006

1. Unité de commande et de contrôle : Conduit le calcul (ordre des instructions) voulu par le programmeur
2. Unité Arithmétique et logique : Exécute les opérations arithmétiques et logiques (+-*/ et ou …) d’un
programme sous le contrôle de l’unité de Commande
3. Mémoire Centrale : Permet de stocker et de restituer des informations
• Correspond à un ensemble fini de cellules
• Une case mémoire (cellule) contient une donnée ou une instruction
• Chaque cellule est numérotée : adresse
• Le processeur peut y accéder à n’importe quel moment en lecture (consultation) ou en écriture (modification)

Périphériques : Echangent avec l’environnement externe (utilisateur)
Nous avons les périphériques de communication et de mémorisation
Périphérique de communication
• 4. Entrées : Clavier, Souris, Scanner, Web Cam, Micro
• 5. Sorties : Ecran, Haut Parleur, Imprimante,
Périphérique de mémorisation
Disque Dur, Disquette (ancêtre de la clé USB et de la carte mémoire), CDROM...

Ordre compréhensible par l’ordinateur Composants d’un ordinateur :
• Déclaration d’emplacement mémoire • MP : Mémoire Centrale
• Calcul et Comparaison • UAL : Unité Arithmético - Logique
• Lecture • PE : Périphérique d’Entrée
• Ecriture • PS : Périphérique de Sortie
• Tests • UCC : Unité de Commande et de Controle
• Boucles (Répétitions)

§ Pour être compris et exécuté par un ordinateur, un algorithme doit être traduit
dans un langage spécifique, qu’on appelle langage de programmation ;
§ On obtient ainsi ce qu’on appelle un programme informatique qui contient
l’ensemble des actions consécutives que l’ordinateur doit exécuter ;
§ Ces actions sont appelées instructions ;

Langage assembleur
– Langage symbolique textuel d’un peu plus haut niveau,
– Lisible par un humain!
– Non portable
– La traduction en langage machine se fait via un assembleur
• Exemple de programme assembleur affichant "Hello World!" sous Windows :
ORG 100h
MOV AH, 09h
MOV DX, message
INT 21h
RET
message db "Hello World !", '$
Langage de haut niveau
– Permettent de comprendre plus facilement le code écrit
– Portables (abstraction des caractéristiques du matériel)
– Manipulent des concepts plus élaborés (variables, tableaux, fonctions)
Plusieurs paradigmes (logique de fonctionnement) :
• La programmation impérative : Décrit les opérations en séquences d'instructions
exécutées par l'ordinateur pour modifier l'état du programme (la plupart des
langages sont impératifs).
• La programmation objet : Consiste en la définition et l'interaction de briques
logicielles appelées objets regroupant les données et les traitements qui sont liés.
• La programmation fonctionnelle déclarative : Considère le calcul en tant
qu'évaluation de fonctions mathématiques
Langage de haut niveau
– Exemple de programme affichant "Hello World!" en Langage C
#include <stdio.h>
int main() {
printf("Hello World!\n");
return 0; }
– Exemple de programme affichant "Hello World!" en Python 3.x
print("Hello World!")

Compilation
• Traduction du source en langage objet.
• Elle comprend au moins quatre phases (trois phases d’analyse : lexicale,
syntaxique et sémantique puis une phase de production de code objet).
• Pour générer le langage machine, il faut encore une phase particulière :
l’édition de liens.
• Elle est contraignante mais offre au final une grande vitesse d’exécution.

Interprétation
• Chaque ligne du source analysé est traduite au fur et à mesure en instructions
directement exécutées.
• Technique très souple mais les codes générés sont peu performants.

Interprétation du bytecode compilé (Mixte)
• Compromis entre facilité de développement et rapidité d’exécution ;
• Le bytecode (forme intermédiaire) est portable sur tout ordinateur muni de la
machine virtuelle du langage.

• Crée en 1989 aux Pays-Bas par Guido Van Rossum
• Syntaxe simple (Typage Dynamique, Indentation significative, gestion automatique
de la mémoire) permettant de passer de l’algorithme au programme
• Portable sur tous les systèmes d’exploitation :
Windows, Linux, Macintosh
• Langage open source
• Disponibilité de plusieurs milliers de bibliothèques
• Deux modes d’utilisation :
- script (écriture du programme dans un fichier)
- interactif (similaire à une calculatrice)
• Langage interprété rapide
• Permet de mettre en œuvre les trois paradigmes
(impérative, objet et fonctionnel)
Préambule
Variable et Constante
Instructions
Séquentielles Expression, Affectation et Calcul
Lecture
Ecriture

KARIM POSSÈDE 3 SEAUX :
• UN SEAU EN PLASTIQUE D’UNE CONTENANCE DE 10 LITRES,
• UN SEAU EN BOIS D’UNE CONTENANCE DE 7 LITRES
• UN SEAU EN FER D’UNE CONTENANCE DE 9 LITRES
10H00 : KARIM VIDE SES 3 SEAUX
10H05 : KARIM VA RENDRE VISITE A DEMBA, CELUI-CI MET 6 LITRES DANS LE SEAU EN BOIS DE KARIM
10H10 : KARIM TRANSVERSE LE CONTENU DE SON SEAU EN BOIS DANS LE SEAU EN FER
10H15 : KARIM REVIENT VERS OUMAR REMPLIR À RAS BORD SON SEAU EN PLASTIQUE
10H20 : KARIM DÉVERSE LA MOITIÉ DE SON SEAU EN PLASTIQUE À L’ÉGOUT
10H25 : KARIM TRANSVASE LE CONTENU DE SON SEAU EN PLASTIQUE DANS CELUI EN BOIS
10H30 : KARIM TRANSVASE 2 LITRES DE SON SEAU EN BOIS DANS CELUI EN FER
10H35 : KARIM INFORME HABIB DU NOMBRE DE LITRES CONTENU DANS SES SEAUX EN PLASTIQUE, EN BOIS, EN FER.
QUELLES SONT LES QUANTITÉS DES TROIS SEAUX QUE HABIB REÇUES ?

PLASTIQUE 0L
(10L)
0L 0L 0L 10L 5L 0L 0L
BOIS
3L
(7L)
0L 6L 0L 0L 0L 5L 3L
FER
(9L) 8L
0L 0L 6L 6L 6L 6L 8L
10h00 10h05 10h10 10h15 10h20 10h25 10h30

Définition :
C’est un emplacement mémoire dont la valeur peut changer au cours de l’exécution d’un programme.
• Une variable possède un nom, on parle d'identifiant ;
• Une variable possède une valeur ;
• Une variable possède un type qui caractérise l'ensemble des valeurs que peut prendre la variable.
Formalisme de déclaration d’une variable en algorithme :
VARIABLE nom_de_la_variable : type_de_la_variable

On peut faire l'analogie avec notre énigme précédente :
• Les seaux seraient les variables ;
• Le contenu d’un sceau serait la valeur de la variable correspondante ;
• La matière du sceau serait le type de la variable (plastique, verre, fer)

Choix des identificateurs
Le choix des noms de variables est soumis à quelques règles qui varient selon le langage,
mais en général :
l Un nom doit commencer par une lettre alphabétique
Exemple valide : A1
Exemple invalide : 1A
l Doit être constitué uniquement de lettres, de chiffres et du soulignement _
(Eviter les caractères de ponctuation et les espaces)

Valides : msda2020, msda_2020
Invalides : msda 2020, msda-2020, msda;2020
l Doit être différent des mots réservés du langage
(par exemple en Python : int, float, else, def, for, if , while, return, …)

Définition du type
Le type d’une variable détermine l’ensemble des valeurs qu’elle peut prendre.
Il y a deux grandes catégories de type :
• Les types simples ;
• Les types composés.

Définition du type
l Type numérique (entier ou réel)
l Byte (codé sur 1octet): de 0 à 255
l Entier court (codé sur 2 octets) : -32 768 à 32 767
l Entier long (codé sur 4 ou 8 octets)
l Réel simple précision (codé sur 4 octets)
l Réel double précision (codé sur 8 octets)
l Type logique ou booléen : Deux valeurs VRAI ou FAUX
l Type caractère : lettres majuscules, minuscules, chiffres, symboles, …
Exemples: ’A’, ’a’, ’1’, ’?’, …

l Type chaîne de caractères : Toute suite de caractères,
Exemples: " Nom, Prénom", "code postale: 1000", …
Attention : La définition de type n’est pas obligatoire pour tous les langages.

Définition :
C’est un objet qui ne possède pas d’emplacement mémoire réservé.
l Sa valeur est directement placé dans le code du programme ;
l Elle ne peut pas voir sa valeur modifiée.
Exemple :
Constante PI = 3,14
l La constante a un typage dynamique

Python permet de manipuler toutes sortes de données :
l Entiers : 0, -12, 3569
l Flottants : 0.232, 3.1415, -12.0
l Booléens : True, False (vrai, faux)
l Chaines de caractères : ”Bonjour les amis”
Python étant un langage de programmation interprété donc la déclaration de
variable n’est pas nécessaire.
Il suffit juste d’écrire l’identifiant de la variable puis de lui fournir une valeur ensuite
Python se chargera de calculer le type et de l’attribuer à la variable.
Les mots reserves et regle de nomination:
Regle de nomination
d'une variable:
- Snake Case pour les
noms de fonctions et de
variables:
number_of_college_grad
uates
- Pascal Case pour les
noms de
classes: NumberOfColle
geGraduates
Exemple :
type(identifiant_variable)
permet de retourner le
type d’une variable.

Les types de base : les entiers (int)
§ Permet de représenter n’importe quel entier positif ou négatif
§ On utilise l’écriture en base du 10 du nombre avec un signe optionnel

La fonction standard int()
§ Permet de convertir n’importe quelle valeur compatible vers l’entier correspondant

Les types de base : les réels (float)
§ Permet de représenter une partie des nombres à virgule ;
§ La séparation entre partie entière et partie décimale se fait avec un point ;
§ On peut également utiliser l’écriture scientifique avec un E ou un e suivi d’une puissance de 10.

La fonction standard float() :
§ Permet de convertir n’importe quelle valeur compatible vers le nombre réel

correspondant.

Les types de base : les booléens (bool)
• Permet de représenter les valeurs logiques VRAI et FAUX
• Deux mots réserves en python : True et False
• N’importe qu’elle donnée en Python possède une valeur logique :
– les valeurs non nulles valent True
– les valeurs vides ou nulles valent False

Les types de base : les chaines de caractères (str)
§ Permet de représenter les textes ;
§ Les valeurs littérales sont entourées :

par des apostrophes (’), des guillemets (”) ou bien des triples quottes (’’’ ou ”””)

La fonction standard str() :
§ Permet de convertir la plupart des valeurs dans leur représentation en texte.

En Python, les chaines de caractères sont dits immutables
(une fois constituée en mémoire, elles ne sont plus modifiables)
Les opérations de modification sur les chaînes produisent donc de nouvelles chaînes.

l Un opérateur est un symbole d'opération qui permet d'agir sur des variables
ou de faire des calculs ;
l Une opérande est une entité (variable, constante ou expression) utilisée par
un opérateur ;
l Une expression est une combinaison d'opérateur(s) et d'opérande(s), elle

est évaluée durant l'exécution de l'algorithme, et possède une valeur (son
interprétation) et un type.

Par exemple dans a + b :
• a est l'opérande gauche
• + est l'opérateur
• b est l'opérande droite
• a + b est appelé une expression
• Lorsque a vaut 4 et 5 vaut 3, l'expression a + b vaut 9
• Lorsque a et b sont des entiers, l'expression a + b est un entier

L'évaluation de l'expression fournit une valeur qui est le résultat de l'opération ;
Les opérateurs dépendent du type de l'opération, ils peuvent être :
§ des opérateurs arithmétiques : +, -, *, /, % (modulo), ^ (puissance)
§ des opérateurs logiques : NON, OU, ET
§ des opérateurs relationnels : = , != , < , > , <= , >=
§ des opérateurs sur les chaînes : & (concaténation)
Une expression est évaluée de gauche à droite mais en tenant compte de priorités

Pour les opérateurs arithmétiques donnés ci-dessus, l'ordre de priorité est le
suivant (du plus prioritaire au moins prioritaire) :
^ : (élévation à la puissance)
* , / (multiplication, division)
% (modulo)
+ , - (addition, soustraction)
Exemple : 4 + 3 * 5 vaut 19
En cas de besoin (ou de doute), on utilise les parenthèses pour indiquer les
opérations à effectuer en priorité (ou en premier)
Exemple : (2 + 3) * 7 vaut 35

Nous avons les opérateurs relationnels suivants :
– Égalité (= ou ==)
– Inégalité (<> ou !=)
– Supérieur (>)
– Supérieur ou égal (>=)
– Inférieur (<)
– Inférieur ou égal (<=)
• Remarque :
Un operateur relationnel retourne une valeur booléenne (vrai/faux)

Nous avons les opérateurs booléens suivants : et, ou, non
– non p est vraie si l’expression p est fausse et faux si l’expression p est vrai.
– p et q est vraie si et seulement si les expressions p et q sont vraies.
– p ou q est vraie est vraie si au moins l’une des expressions p,q est vraie.
– Priorités sur les opérateurs : non, et, ou
– Associativité et Distributivité des opérateurs et,ou
– Lois de Morgan
• non (p ou q) = non p et non q
• non (p et q) = non p ou non q

Exemples En Python :

Evaluez l’expression suivante :
not 16/2**2+10 != 15 % 8*2 and 0.5**-2/2*5 >= 10**2**(1/2)

L’affectation consiste à attribuer une valeur à une variable
(ça consiste en fait à remplir où à modifier le contenu d'une zone mémoire)
En algo, l'affectation se note avec le signe ←

A ← x : Ceci attribue la valeur de x à la variable A
§ x peut être une valeur, une autre variable ou une expression
§ A et x doivent être de même type ou de types compatibles
§ L’affectation ne modifie que ce qui est à gauche de la flèche

En python
– Il n’est pas symétrique (3 = a ne marche pas)
– Il est associatif à droite! (a = b = c veut dire a = (b = c))
– Il peut servir pour des affectations multiples (a, b = 2,3)

Exemple : Calcul de la surface du cercle
Algorithme surfaceCercle #Programme Python surfaceCercle

Constante pi = 3.14
pi = 3.14
rayon = 2.0
Variable
surface = 0.0
rayon, surface: réel
Début_Algo surface = rayon * rayon * pi
rayon ← 2
surface ← rayon * rayon * pi
Fin_Algo

Exercice 1 : Donnez les valeurs des variables A, B et C en fin d’exécution ?
Variables A, B, C: Entier;
Début
A ← 3;
B ← 7;
A ← B;
B ← A+5;
C ← A + B;
C ← B – A;
Fin

Exercice 2 :
Donnez les valeurs des variables A, B après exécution des instructions suivantes ?
Variables A, B : Entier;
Début
A ← 1;
B ← 2;
A ← B;
B ← A;
Fin
Les deux dernières instructions permettent-elles d’échanger les valeurs de A et B ?
Exercice 3 :
Ecrire un programme permettant d’échanger les valeurs de deux variables A et B

§ Un algorithme peut avoir des interactions avec l'utilisateur (usage des périphériques);
§ Il peut afficher un résultat (du texte ou le contenu d’une variable) et demander à l'utilisateur de
saisir une information afin de la stocker dans une variable ;
En tant que programmeur on se met à la place de la machine
• Pour afficher une information on utilise la commande ECRIRE suivie entre parenthèses de la
chaîne de caractères entre guillemets et/ou des variables de type simple à afficher séparées par
des virgules, par exemple :
ECRIRE ("La valeur de la variable a est : ", a) ;
• Pour donner la possibilité à l'utilisateur de saisir une information, on utilise la commande LIRE
suivie entre parenthèses de la variable de type simple qui va recevoir la valeur saisie par
l'utilisateur, par exemple :
LIRE (b)

Exemple :
Variable A, B : entier
Début_Algo
ECRIRE ("Saisir la valeur de A ");
LIRE (A);
B ← 2*A;
ECRIRE ("Le double de ", A, " est : ", B);
Fin_Algo
Pour chaque instruction séquentielle
(Déclaration des variables et constante, Affectation, Lecture et Ecriture…) nous pouvons proposer
sa représentation sous forme d’algorigramme :
Exemple : B ← B+1 Exemple : LIRE (A)
Représentation en algorigramme Représentation en algorigramme
LIRE (A)
B ← B+1
Exemple : ECRIRE (B)

Représentation en algorigramme
ECRIRE (B)

Soit l’exemple suivant :
Variable A, B : entier ECRIRE ("Entrer la valeur de A ");
Début
ECRIRE ("Entrer la valeur de A "); LIRE (A)

LIRE (A);
B ← 2*A; B ← 2*A
Fin

Lecture en Python (input)
§ Elle est directement accessible (built in).
§ Elle peut prendre en argument une chaîne de caractères qui est affichée afin de
donner des indications à l’utilisateur.
§ Elle stoppe l’exécution du programme jusqu’a ce que l’utilisateur ait saisi une
valeur validée par l’appui sur la touche Entrée.
§ Elle retourne une donnée de type str contenant la saisie, ce qui fait que la saisie
nécessite parfois un transtypage (conversion de type)

Ecriture en Python (print)
§ Elle est directement accessible (built in) ;
§ Elle prend un nombre variable d’arguments, séparés par des virgules, qu’elle
affiche sous forme de texte lisible, en les séparant par des espaces et en
terminant par un retour à la ligne ;
§ Les arguments de la fonction peuvent être des valeurs littérales, des variables,
ou toute expression permettant de calculer un résultat.

Soit l’exemple suivant traduisons le sur Python :
Variable A, B : entier
Début ALGO
ECRIRE ("Entrer la valeur de A ");
LIRE (A);
B ← 2*A;
Fin
A = int(input("Entrer la valeur de A"))

B = 2*A
PYTHON
print("Le double de",A,"est",B)

Ecriture en Python (print)
Les chaînes littérales formatées ou f-string :
§ Simplification syntaxique introduite dans Python 3.6 pour le formatage de chaînes ;
§ Chaînes de caractères dont la déclaration est préfixée par un f (f"..."), et qui peuvent
comporter des champs indiqués entre accolades { } ;
§ Les champs contiennent des variables ou des expressions dont la valeur est évaluée
lors de la construction de la chaine à l’exécution du programme.

A = int(input("Entrer la valeur de A"))
B = 2*A
print(f"Le double de {A} est {B}")

Qu’est ce qu’une structure conditionnelle ?
Expression booléenne
Structures
Conditionnelles Evaluation d’une expression booléenne
Implémentation d’une expression booléenne
Structures conditionnelle en Python

La décision est le fait d'un acteur (ou d'un ensemble plus ou moins cohérent d'acteurs) qui effectue un choix
entre plusieurs solutions susceptibles de résoudre le problème, ou la situation, auquel il est confronté.
D'une manière générale, la décision est l'action de l'esprit qui décide quelque chose ou se décide après
délibération individuelle ou collective :
• En psychologie, la décision est l'action volontaire et réfléchie de l'esprit qui se détermine à l'occasion d'un
choix d'une des issues au terme d'un processus de délibération ;
• En droit ou dans les domaines administratifs, la décision est une disposition arrêtée par une autorité
compétente collégiale ou unique, après délibération, ou une instruction de service émanant d'une autorité
hiérarchique (par exemple : couvre feu) ;
• En économie, les micro ou macro décisions correspondent aux décisions prises par des agents
économiques simples ou complexes ;
• En stratégie, la décision est d'abord un courage opposé constamment aux détracteurs, appliqué à une
situation d'incertitude, se révélant perspicace dans la capacité à anticiper et réactualisé constamment pour
s'adapter aux aléas de l’adversité.

• Dans la vie, on a souvent besoin de décider du déroulement des choses en fonction de
certaines conditions. Par exemple : "s’il pleut, je prends mon parapluie"
• De même, dans les langage de programmation, il est possible de décider de n'exécuter une
action, que lorsqu’une condition particulière est remplie.

Une structure conditionnelle c’est un bloc d’instructions, qui peut effectuer différentes actions en
fonction de l'évaluation d'une condition.
Nous avons :
- Les structures conditionnelles simple et / ou composées (Si)
- Les structures conditionnelles alternatives (Si…Sinon)
- Les structures conditionnelles imbriquées (Si…Sinon…Si…Sinon)
- Les structures à choix multiple (Selon...Que)
Formulation générale d’une structure conditionnelle :

Si (expression booléenne) Alors
Début
Instructions à exécuter
Fin

Expression booléenne :
C’est une expression qui après évaluation admet soit un résultat vrai ou faux.
Expression : Combinaison d'opérateur(s) et d'opérande(s), qui est évaluée durant l'exécution
de l'algorithme, et possède une valeur (son interprétation) et un type
En structure conditionnelle, les opérateurs de comparaison / relationnel sont utilisés :
== != < > >= <=

Egalité Différence Strictement Strictement Supérieur Inférieur
Inférieure Supérieur ou Egal ou Egal
Lorsque l’expression booléenne est vraie, le bloc d’instruction est exécuté intégralement
Au cas échéant l’algorithme saute les instructions, puis exécute ce qui suit.

Nature et évaluation de l’expression booléenne
- L’expression booléenne peut être simple ou composée
Elle est simple lorsque nous avons deux opérandes séparés par un opérateur de comparaison
Exemple :
A == 2 ; B>=5 ; D != 7 ; X<B
Elle est composée lorsque nous avons plusieurs expressions booléennes séparées par des
opérateurs logiques (ET, OU, NON)
Exemple :
(A == 1 OU B >= 2)
(B == 3 ET C != 4)
Attention :
L’évaluation d’une expression booléenne composée se fait par le biais d’une table de vérité

Nature et évaluation de l’expression booléenne
La table de vérité, c’est une table mathématique pour représenter de manière sémantique des
expressions logiques et calculer la valeur de leur fonction relativement à chacun de leurs
arguments fonctionnels. Chaque opérateur logique admet une table de vérité :
Avec une expression composée séparée par un opérateur logique ET
- Si au moins l’une des expressions est FAUSSE la résultante est FAUSSE
(Pas d’exécution du bloc d’instruction)
Avec une expression composée séparée par un opérateur logique OU
- Si au moins l’une des expressions est VRAIE la résultante est VRAIE
(Possibilité d’exécution du bloc d’instruction)

TABLES DE VERITE
E1 E2 E1 ET E2 E1 E2 E1 OU E2
VRAI VRAI VRAI VRAI VRAI VRAI
VRAI FAUX FAUX VRAI FAUX VRAI
FAUX VRAI FAUX FAUX VRAI VRAI
FAUX FAUX FAUX FAUX FAUX FAUX
E1 NON E1
VRAI FAUX
FAUX VRAI

Exercice d’application
Exercice 1 : Evaluez chaque expression Exercice 2 : Evaluez chaque expression

Soit A = 8 Soit A = 2 ; B = 5 ; C = 3
§ (A != 8) " Vrai ou faux ? " • (A != 0 ET B == A) " Vrai ou faux ? "
§ (A <= 2) " Vrai ou faux ? " • (B >=2 OU C >= A) " Vrai ou faux ? "
§ (A > 8) " Vrai ou faux ? " • (C==0 ET B > 8) " Vrai ou faux ? "
§ (A == 9) " Vrai ou faux ? " • ((C==0 ET B <= 4) OU (A>0)) " Vrai ou faux ? "
§ (A >= B) avec B = 9 " Vrai ou faux ? " • (A <= B OU B > 9) " Vrai ou faux ? "
§ (B <= A) avec B = 10 " Vrai ou faux ? " • ((A >= 0 ET B != 0) " Vrai ou faux ? "
§ (B == A) avec B = 8 " Vrai ou faux ? "

- Les structures conditionnelles simple et / ou composées
VRAIE
SI (expression booléenne) ALORS CONDITION
Début
Instructions…
Fin Instructions
Expression booléenne :
FAUSSE
Elle peut être simple ou composée et n’admet que deux éventualités
(Vraie ou Fausse)
- Si elle est VRAIE : les Instructions… sont exécutées
- Si elle est FAUSSE: les Instructions… ne sont pas exécutées

Exemple :
Ecrire un algorithme qui permet de vérifier si un nombre est positif.
VARIABLE A : ENTIER
DÉBUT
ECRIRE ("ENTRER LA VALEUR DE A ")
LIRE (A)
SI (A>0) ALORS
DÉBUT_SI
ECRIRE ("LE NOMBRE " & A & " EST POSITIF")
FIN_SI
FIN

- Les structures conditionnelles alternatives (SI…SINON)
VRAIE FAUX
SI (expression booléenne) ALORS Condition
Début
Instructions1
SINON
Début Instructions 1 Instructions 2
Instructions2
Fin
Fin
• Même principe d’exécution que le modèle précédent
• A la seule différence l’exécution du SINON inverse le contenu de
l’expression booléenne.

- Les structures conditionnelles alternatives (Si…SINON)
Avec le SINON l’inversion de l’expression booléenne sera basée sur les opérateurs de comparaison.
SI == != < > >= <= ET OU

SINON != == >= <= < > OU ET

Exemple :
Ecrire un algorithme qui permet de vérifier si un nombre est positif ou nul.
VARIABLE A : ENTIER
DÉBUT_ALGO
ECRIRE ("ENTRER LA VALEUR DE A ")
LIRE(A)
SI (A>0) ALORS
DÉBUT_SI
ECRIRE ("LE NOMBRE "& A &" EST POSITIF")
SINON // AVEC LE SINON, (A>0) EST INVERSÉE POUR DEVENIR (A<=0)
DÉBUT_SINON
ECRIRE ("LE NOMBRE "& A &" EST NEGATIF")
FIN_SINON
FIN_SI
FIN_ALGO

VRAIE FAUX
- Les structures conditionnelles imbriquées Condition
SI (expression booléenne) ALORS
Début
Instructions1
VRAIE
Fin Instructions 1 Condition
SINON
SI (expression booléenne) ALORS
FAUX
Début
Instructions 2
Instructions2
Fin
Fin
Exemple :
Ecrire un algorithme qui permet de vérifier l’état de l’eau selon une température.
VARIABLE TEMP : ENTIER
DÉBUT_ALGO
ECRIRE("ENTRER LA VALEUR DE TEMPÉRATURE ")
LIRE(TEMP)
SI (TEMP<0 OU TEMP==0) ALORS
DÉBUT_SI
ECRIRE("GLACE")
SINON
DEBUT_SINON
SI (TEMP<100) ALORS
DÉBUT_SI
ECRIRE("LIQUIDE")
FIN_SI
SI (TEMP>=100) ALORS
DÉBUT_SI
ECRIRE("VAPEUR")
FIN_SI
FIN_SINON
FIN_SI
FIN_ALGO
SYNTAXE
SELONQUE permet d'effectuer tel ou tel traitement en fonction de la valeur des conditions 1 ou 2 ou...n
SELONQUE
<condition 1> : <action 1>
<condition 2> : <action 2>
...
<condition n> : <action n>
SINON : <action_sinon>
FINSELONQUE

FONCTIONNEMENT
1 : la condition 1 est évaluée :
• Si la condition 1 est vraie, alors on exécute l'action correspondante et on quitte la structure selon-que
• Si la condition 1 est fausse, on évalue la condition 2...et ainsi de suite.
2 : Si aucune n'est vraie on effectue l'action sinon
( au cas où l'action sinon n'existe pas alors aucune action n'est exécutée !)

Exemple :
Ecrire un algorithme qui permet de retourner la mention d’une note
Variable Note : numérique
Debut_algo
Lire (Note)
Selon Que
Debut_selon_que
Note > 10 : Ecrire « passable »
Note > 12 : Ecrire « assez bien »
Note > 14 : Ecrire « bien »
Note > 16 : Ecrire « très bien »
Sinon : Ecrire « ajourné »
Fin_selon_que
Fin_algo

Bloc if :
Lorsque la condition logique est vérifiée, le bloc d’instructions (instruction1 et instruction2) est exécuté.
Si la condition n’est pas vérifiée le bloc n’est pas exécuté et on passe aux instructions après le if.
N = int(input("Entrer la valeur de N "))

if N>0:
print(f"Le nombre {N} est positif")

Bloc if...else :
Spécifie un second bloc d’instructions qui est exécuté lorsque la condition du if n’est pas vérifiée
if N>0:
else:
print(f"Le nombre {N} est négatif ou nul")

Bloc if...elif...else :
Spécifie des conditions ou des choix multiples avec une batterie de tests.

if N>0:
elif N<0:
print(f"Le nombre {N} est négatif")
else:
print(f"Le nombre {N} est nul")

Qu’est ce qu’une structure itérative ?
Structures Boucle à événement ou indéfinie
Itératives
Boucle à compteur ou définie
Structure itérative en Python

Dans la vie, on a souvent besoin de répéter une action en cas de non atteint d’un objectif.
Par exemple :
• A tout instant que j’ai faim, je continue à manger.
• Ma voiture continuera à rouler tant que j’ai de l’essence.
De même que les langages de programmation, il est possible d'exécuter autant de fois une action
selon un ensemble de critère. C’est là qu’intervient les structures itératives.

Une structure itérative c’est un bloc d’instructions dont leur but est de répéter un traitement selon des critères
bien définis. Généralement il existe deux types de boucles :
• Les boucles à événement ou indéfinie

- On ne sait pas à l’avance le nombre de fois que la boucle sera exécutée.
Ça peut dépendre du nombre de données à traiter.
Ça peut dépendre du nombre d’essais que l’usager a effectué.
Ce sont les boucles : Tant Que et Jusqu’à
• Les boucles à compteur ou définie

- On sait à l’avance combien de fois la boucle devra tourner
Choisir 10 nombres au hasard.
On fera dix fois l’opération choisir un nombre au hasard.
C’est la boucle : Pour

VRAIE
TANT QUE (expression_booléenne) Condition Instructions
Début {tant_que}
Instructions
Fin {tant_que} FAUSSE
Principe :
• 1 - Le programme va tester avant chaque tour de boucle si la condition est vraie
• 2 - Dans l’affirmative il exécute les instructions jusqu’au fin tant que,
• 3 - Puis il revient au test de la condition.
• 4 - Lorsque la condition devient fausse, la boucle tant que se termine et le programme continue normalement
son exécution après l’instruction qui suit le fin{tant que}

Exemple :
Ecrire un algorithme qui détermine le premier nombre entier N tel que la somme de 1 à N dépasse strictement 10.
Variable som, i : entier;
Debut_Algo
i ← 0 ;
som ← 0 ;
TantQue (som <10)
Debut_TantQue
i ← i+1;
som ← som+i;
Fin_TantQue
Ecrire ("La valeur cherchée est N = " & i);
Fin_Algo

Attention, pour le bon fonctionnement d’une boucle :
1. Il faut vérifier qu’à un moment on peut entrer dans la boucle pour y exécuter les instructions,
Ceci afin d’éviter les boucles inutiles.
2. Il faut vérifier également qu’à un moment on sort de cette boucle,
Il faut éviter les boucles infinies.

FAIRE
Instructions
TANT QUE (expression_booléenne)
On exécute une première fois les instructions puis on Instructions

effectue le test de la condition pour éventuellement
reprendre l’exécution des instructions.
VRAI
Condition
FAUSSE

Exemple : Ecrire un programme qui oblige la saisie de valeur strictement positive
Variables val: Entier
Début_Algo
Faire
Ecrire(" Entrez une valeur numérique positive")
Lire(val)
Tant que (val<0)
Ecrire(" la valeur saisie est " & val)
Fin_Algo

POUR cpt ALLANT DE valeur_initiale A valeur_finale
DÉBUT
INSTRUCTIONS i ← 1
FIN
i ← i + 1
VRAIE
i n’a pas
atteint finale
Instructions
FAUSSE

Principe :
• 1 - Pour une variable de boucle dont le contenu varie de val_Initiale à val_Fin par pas de val_pas
Exécuter les instructions.
• 2 - L’instruction de contrôle Pour permet d’exécuter les instructions un nombre déterminé de fois.
Ce nombre est connu avant de commencer à exécuter la boucle Pour.
• 3 - La boucle ne s’arrête que lorsque le nombre de répétition des instructions demandé a été réalisé.

Il faut éviter de modifier la valeur du compteur (et de finale) à l'intérieur de la boucle.
En effet, une telle action :
§ perturbe le nombre d'itérations prévu par la boucle Pour
§ rend difficile la lecture de l'algorithme
§ présente le risque d'aboutir à une boucle infinie
Exemple :
Pour i allant de 1 à 5
Debut_Pour
i←i-1
Ecrire("i = "&i)
Fin_Pour

Remarque :
§ La boucle POUR est un cas particulier de TANT QUE
(cas où le nombre d'itérations est connu et fixé)
§ Tout ce qu'on peut écrire avec POUR peut être remplacé avec TANT QUE
(mais pas la réciproque)

Bloc while :
Ecrire une boucle qui détermine le premier nombre entier N tel que la somme de 1 à N dépasse strictement 10.
Variable som, i : entier;

Debut_Algo
i ← 0 ALGO
som ← 0
TantQue(som <10)
Debut_TantQue
i ← i+1;
som ← som+i;
Fin_TantQue
Ecrire ("La valeur cherchée est N = " & i);
Fin_Algo

Bloc for :
Ecrire une boucle qui affiche la table de multiplication d’un entier N
Variable N, m, i: entier;
Debut_Algo
LIRE(N) ALGO
i ← 0
Pour i ← 1 à 12
Debut_Pour
m = N*i
Ecrire(N,"x",i,"=",m)
Fin_Pour
Fin_Algo

Bloc for :
Ecrire une boucle qui affiche la liste des nombres impairs d’un intervalle fourni
for i in range(1,11,2):
print(f"{i}")

Principe de modularité
Fonction et Procédure
PARTIE 2 Portée et Paramétres
Modularité Fonction Imbriquée et Closure
Décomposition fonctionnelle
Module

La modularité consiste à décomposer tout problème complexe en plusieurs sous problèmes plus
simples qui seront résolus séparément et éventuellement décomposés de manière encore plus fine.
La modularité reprend l'idée de fabriquer un produit (le programme) à partir de composants reliés.
Ainsi elle décompose un programme complexe en modules (groupes de fonctions) de méthodes et de
traitements, pour pouvoir les développer et les améliorer indépendamment, puis les réutiliser.
Exemple :
Par analogie la conception d’une chaise passe par :
1. Créer les pieds et le support ;
2. Créer le siège et le dossier ;
3. Assemblage le tout avec des vis.

Qu’est ce qu’un sous programme ?
Un sous-programme est un sous-ensemble du programme dans sa hiérarchie fonctionnelle.

Les sous programmes sont essentiellement utilisés pour :
• Rendre le programme plus lisible ;
• Éviter de dupliquer le même code à plusieurs endroits du programme ;
• Faciliter la maintenance et le débogage du programme ;
• Être éventuellement réutilisés dans un autre programme ;
Il existe deux types de sous programmes : les fonctions et les procédures

Bloc d’instructions autonomes
Fonction
(peut prendre en entrée des paramètres) Procédure
(peut prendre en entrée des paramètres)
Retourne un paramètre destiné

à un autre bloc d’instructions
Ne retourne rien

La portée est l’ensemble des sous programmes où la variable est connue.
– Variable avec une portée globale :
• Variable déclarée en dehors de tout sous programme et du programme principal
(celui qui résout le problème initial).
• Le programme principal et tous les sous-programmes peuvent utiliser cette variable.
– Variable avec une portée locale :
• Variable déclarée au sein d’un sous programme.
• Seul le sous-programme où elle est déclarée peut utiliser cette variable.

Analogie de la maison
ELECTRICITE
Chambre 1
fermée
Les chambres 1 et 2 étant fermées, la
personne B ne sera pas en mesure de
Personne A voir les personnes A et C.
L’électricité malgré le fait qu’elle a été
Personne B installée en dehors de la maison est
accessible dans les chambres.
• Les personnes A et C étant visible

Chambre 2 qu’a l’intérieur des chambres peuvent
fermée
être vues comme locale
• L’électricité étant accessible partout
Personne C peut être vu comme globale

Une variable a la même durée de vie que l’entité dans laquelle elle a été déclarée.
• Variable globale :
– Même durée que le programme principal :
Elle est créée quand le programme est lancé et est "détruite" quand le programme s’arrête.
• Variable locale :
– Même durée que le sous programme :
Elle est créée quand le sous programme est appelé et est "détruite" quand il se termine.

Le rôle d’un paramètre est de transmettre de l’information entre programmes
Il existe deux types de paramètres:
– Les paramètres formels :
Ils ont un type et constituent des variables locales au sous programme du coup ils sont
déclarés dans l’entête de celui ci.
– Les paramètres effectifs :
Ce sont les variables avec lesquelles le sous programme est effectivement appelé.
Remarque : Les paramètres effectifs doivent être au même nombre et de même type que les
paramètres formels.

Ecrire une fonction en Python qui fait la somme la somme de deux entiers.
Ecrire une procédure qui appelle la fonction somme pour afficher un resultat
def somme (x,y) : fonction

def appel() : procédure
x et y : paramètres formels
s : variable locale
c : paramètre effectif

Ecrire une fonction en Python qui retourne la valeur d’un écart entre deux entrées
c = 0.1
Représente un paramètre par défaut
Passage par nom

Une fonction définie dans une autre fonction est appelée une fonction imbriquée.
Les fonctions imbriquées peuvent accéder aux variables de la portée englobante.
En Python, ces variables non locales sont en lecture seule par défaut et nous devons les déclarer
explicitement comme non locales (en utilisant un mot clé non local) afin de les modifier.
On voit que la fonction imbriquée printer() a pu accéder

à la variable non-local msg de la fonction englobante.

Nous avons une closure en Python lorsqu'une fonction imbriquée fait référence à une valeur dans
sa portée englobante. Les critères qui doivent être remplis pour créer une closure en Python sont
résumés dans les points suivants.
• Nous devons avoir une fonction imbriquée (fonction à l'intérieur d'une fonction).
• La fonction imbriquée doit faire référence à une valeur définie dans la fonction englobante.
• La fonction englobante doit renvoyer la fonction imbriquée.

Exemple de closure :
La valeur de la portée englobante est

mémorisée même lorsque la variable sort
de la portée ou que la fonction elle-même
soit supprimée de l'espace de noms actuel.

• En Informatique la décomposition fonctionnelle se définit comme une méthode d’analyse,
qui prend une tâche complexe et la dissèque pour visualiser les différentes étapes qui la
composent.
• Elle permettra ensuite d’analyser et de comprendre les relations entre tous les éléments
constitutifs afin d’avoir une vision globale et détaillée des actions à réaliser pour aboutir à
la réalisation de notre tâche principale.
• Ainsi la décomposition fonctionnelle prend un problème complexe et le simplifie.

Principe :
§ Si une instruction n'est pas assez explicite pour qu'un ordinateur l'interprète directement,
elle doit être décomposée en instructions primitives.
§ Chaque décomposition sera encapsulée dans un bloc d’instructions autonome.
§ L‘analyse descendante (subdiviser un grand programme en plusieurs sous-
programmes plus faciles à concevoir, de la même façon qu’on divise un problème
en sous-problèmes) est une des méthodes pour obtenir cette décomposition.
§ La décomposition fonctionnelle permet de rapides construction de programmes, la
possibilité de leur réutilisation pour en construire d’autres en plus d’en assurer une rapide
et efficace maintenance.

SOUS-PROGRAMME presenter(plat)
DEBUT
placer(plat)
Analogie du restaurant placer(couverts_pour_plat)
FIN
SOUS-PROGRAMME mettre_la_table()
DEBUT PROGRAMME prendre un repas
placer(nappe) DEBUT
placer(assiettes) mettre_la_table()
placer(couverts) presenter(plat_du_jour) SOUS-PROGRAMME ranger_la_table()
placer(verres) manger(plat_du_jour) DEBUT
FIN presenter(dessert) ranger(couverts)
manger(dessert) nettoyer (nappe)
ranger_la_table() FIN
FIN
SOUS-PROGRAMME manger(plat)
DEBUT
mon_assiette = se_servir (plat)
manger_dans(mon_assiette, mes_couverts)
boire_dans(mon_verre)
FIN

La mise en œuvre d’un programme par décomposition fonctionnelle peut passer par quatre étapes :
1. Ecriture des commentaires de spécification internes à un bloc d’instruction
2. Tableau des flux entre les blocs
3. Diagramme des flux
4. Implémentation et test

Les commentaires de spécification servent à spécifier un bloc d’instructions
• Ce qu’il fait
• La façon dont il procède pour atteindre son but
• Les données nécessaires
• Les résultats qu’il fournit
Ces commentaires au nombre de huit sont internes aux blocs d’instructions.
Ils aideront au développement rapide des blocs, ainsi qu’à leur validation de façon plus efficace.

Les commentaires de spécification servent à spécifier un bloc d’instruction :
§ Objectifs : Ce commentaire sert à décrire le but visé par le bloc
§ Méthode : La façon dont on procède pour atteindre le but décrit au commentaire précédent
§ Besoins : Toutes les données dont le bloc aura besoin pour atteindre son but
§ Connus : Les données que l’on connaît d’avance, pas besoin de le demander au bloc appelant ni à l’usager
§ Entrées : Les données qui parviennent du bloc appelant
§ Sorties : Les données que le bloc renvoie au bloc appelant
§ Résultats : Toute conséquence du bloc qui n’est pas visible par les autres blocs, exemple: les affichages.
§ Hypothèses : Les conditions nécessaires au bon fonctionnement du bloc.
Ces hypothèses concernent :
• Les données en entrée du bloc;
• Les données lues (saisies) dans le bloc

Le digramme de flux :
Un diagramme de flux de données schématise le flux d'informations de n'importe quel processus ou
système. Il utilise des symboles définis comme des rectangles, des cercles et des flèches, ainsi que
des étiquettes aux libellés courts, pour représenter les entrées de données, les sorties, les points de
stockage et les trajets entre chaque destination.
Le tableau de flux :
C’est la représentation du diagramme de flux sous forme d’un tableau.

Exemple :
Ecrire un programme modulaire qui permet de calculer l’expression suivante :
!
𝑥
𝑄=
𝑛!
1. Ecriture les commentaires de spécification internes aux blocs d’instruction
2. Tableau des flux entre les blocs
3. Diagramme des flux
4. Implémentation et test des blocs d’instruction en Python

Exemple :
!
𝑥
𝑄=
𝑛!
Listing des blocs d’instruction
Fonction 1 : Puissance
Fonction 2 : Factorielle
Fonction 3 : Quotient
Fonction 4 : Saisie
Procédure : Programme principal

Exemple :
!
𝑥
𝑄=
𝑛!
Fonction 1 : Puissance
§ Objectifs : Calcul de la puissance de x selon n
§ Méthode : Usage d’une structure itérative
§ Besoins : x,n,P,i
§ Connus : -
§ Entrées : x,n
§ Sorties : P
§ Résultats : -
§ Hypothèses : x>0, n>0, P>=1
Exemple :
!
𝑥
𝑄=
𝑛!
Fonction 2 : Factorielle
§ Objectifs : Calcul de la factorielle de n
§ Méthode :Usage d’une structure itérative
§ Besoins : n,F,i
§ Connus : -
§ Entrées : n
§ Sorties : F
§ Résultats : -
§ Hypothèses : n>0, P>=1
Exemple :
!
𝑥
𝑄=
𝑛!
Fonction 3 : Quotient
§ Objectifs : Calcul du quotient entre la puissance et la factorielle
§ Méthode : Usage d’une expression arithmétique affectée à une sortie
§ Besoins : q,P,F
§ Connus : -
§ Entrées : P,F
§ Sorties : q
§ Résultats : -
§ Hypothèses : P>=1, F>=1
Exemple :
!
𝑥
𝑄=
𝑛!
Fonction 4 : Saisie
§ Objectifs : Donner la possibilité a l’usager de saisir des entrées
§ Méthode : Usage d’une instruction de lecture avec contrôle de saisie
§ Besoins : x,n
§ Connus : -
§ Entrées : -
§ Sorties : x,n // En python on peut faire sortir deux variables en même temps
§ Résultats : -
§ Hypothèses : x>=1, n>=1
Exemple :
!
𝑥
𝑄=
𝑛!
Procédure : Programme principal
§ Objectifs : Faire appel aux fonctions et effectuer le calcul et l’affichage
§ Méthode : Appel de fonction et usage des paramètres formels et effectifs
§ Besoins : a,b,c,d,e
§ Connus : -
§ Entrées : -
§ Sorties : -
§ Résultats : La valeur du quotient
§ Hypothèses : a>=1, b>=1, c>=1, d>=1, e>=1
Exemple :
!
𝑥 saisie
𝑄=
𝑛! x,n
principal
F x,n
n
P
factorielle
puissance

Exemple :
!
𝑥
𝑄=
𝑛!
Programme Principal Fournit (Entrées) Recoit (Sortie)
Saisie Rien x,n
Puissance x,n P
Factorielle n F
Quotient P,F q

Exemple :
!
𝑥
𝑄=
𝑛!

Qu’est ce qu’un module ?
Un module est un fichier «.py » contenant un ensemble de variables, fonctions et
classes que l’on peut importer et utiliser dans le programme principal (ou dans
d’autres modules).
Les modules permettent la séparation et donc une meilleure organisation du code.
En effet, il est courant dans un projet de découper son code en différents fichiers qui
vont contenir des parties cohérentes du programme final pour faciliter la
compréhension générale du code, la maintenance et le travail d’équipe si on
travaille à plusieurs sur le projet.

Simplicité : plutôt que de se concentrer sur l'ensemble du problème, un module se concentre généralement sur une
partie relativement petite du problème.
Maintenabilité : les modules sont généralement conçus de manière à imposer des limites logiques entre les différents
domaines de problèmes.
Réutilisabilité : les fonctionnalités définies dans un seul module peuvent être facilement réutilisées par d'autres
parties de l'application.
Portée : les modules définissent généralement un espace de noms distinct, ce qui permet d'éviter les collisions entre
les identifiants dans différentes zones d'un programme.
Les fonctions, modules et packages sont tous des constructions en Python qui favorisent la modularisation du code.
En Python, on peut distinguer trois grandes catégories de module :
• Les modules standards ne font pas partie du langage en soi mais sont intégrés automatiquement
par Python. Exemple : random, math, os, re...
• Un module peut être écrit en C et chargé dynamiquement au moment de l'exécution,
comme le module re (expression régulière).
• Les modules développés par des développeurs externes qu’on va pouvoir utiliser. Exemple :
panda, networkx...
• Les modules qu’on va développer nous mêmes.
https://docs.python.org/3/library/

Chargement de module avec import
Utilisation de la fonction
puissance depuis le module math

§ Ne rend pas le contenu du module directement accessible à l'appelant.
§ Chaque module a sa propre table privée de symboles privée, qui sert de table de symboles
globale pour tous les objets définis dans le module. Ainsi, un module crée un espace de noms
séparé.
§ L'instruction import <nom_du_module> place uniquement <nom_du_module> dans

la table des symboles de l'appelant.
§ Les objets définis dans le module restent dans la table privée de symboles du module.
§ Depuis l'appelant, les objets du module ne sont accessibles que s'ils sont préfixés par
<nom_du_module> via la notation ‘.’

§ Après l'instruction import ci_dessous, surfapolygone est placé dans la table de
symboles locale. Ainsi, surfapolygone a un sens dans le contexte local de
l'appelant :

Une autre forme de l'instruction import qui permet d'importer des objets
individuels du module directement dans la table des symboles de l'appelant

Problemes
• Étant donné que cette forme d'importation place les noms d'objet directement dans la table des
symboles de l'appelant, tous les objets qui existent déjà avec le même nom seront écrasés.
• Ce n'est pas nécessairement recommandé dans le code de production à grande échelle. C'est un
peu dangereux parce que vous entrez en masse des noms dans la table des symboles locaux. À
moins que vous ne les connaissiez tous bien et que vous soyez sûr qu'il n'y aura pas de conflit, vous
avez de bonnes chances d'écraser un nom existant par inadvertance.
• Cependant, cette syntaxe est assez pratique lorsque vous vous contentez de jouer avec l'interpréteur
, à des fins de test ou de découverte, car elle vous donne rapidement accès à tout ce qu'un module a
à offrir sans trop de frappe.

§ Le contenu du module peut être importé à partir d'une définition de fonction. Dans
ce cas, l'import n'a lieu qu'une fois la fonction appelée :

§ La fonction intégrée dir() renvoie une liste de noms définis dans un espace de
noms. Sans arguments, il produit une liste de noms triés par ordre alphabétique
dans la table de symboles locale actuelle :

La mise en œuvre d’un module se fait comme suit :
- Tout d’abord on implémente l’ensemble des fonctions sur un fichier (nom_du_fichier.py)
- Puis on crée un autre fichier python sur lequel on importe notre module :
import nom_de_notre_module

§ Lorsque l'interpréteur exécute une instruction import, il recherche le module dans
une liste de répertoires assemblée à partir des sources suivantes :
§ Le répertoire à partir duquel le script d'entrée a été exécuté ou le répertoire actuel si

l'interpréteur est exécuté de manière interactive
§ La liste des répertoires contenus dans la variable d'environnement PYTHONPATH, si elle
est définie. (Le format de PYTHONPATH dépend du système d'exploitation mais doit
imiter la variable d'environnement PATH.)
§ Une liste de répertoires dépendant de l'installation configurée au moment de l'installation
de Python
§ Le chemin de recherche résultant est accessible dans la variable Python sys.path,
qui est obtenue à partir d'un module nommé sys

§ Le chemin de recherche résultant est accessible dans la variable Python sys.path,
qui est obtenue à partir d'un module nommé sys:

§ Ainsi, pour vous assurer que votre module est trouvé, vous devez effectuer l'une
des opérations suivantes :
§ Mettez le module dans le répertoire où se trouve le script d'entrée ou le répertoire
courant, s'il est interactif
§ Modifiez la variable d'environnement PYTHONPATH pour qu'elle contienne le répertoire

où se trouve module avant de démarrer l'interpréteur
§ Ou : Mettre le module dans un des répertoires déjà contenus dans la variable

PYTHONPATH
§ Placez le module dans l'un des répertoires dépendant de l'installation, auxquels
vous pouvez ou non avoir accès en écriture, selon le système d'exploitation

Il existe en fait une option supplémentaire : vous pouvez
placer le fichier du module dans n'importe quel
répertoire de votre choix, puis modifier sys.path au
moment de l'exécution afin qu'il contienne ce
répertoire.

§ Une fois qu'un module a été importé, vous pouvez déterminer l'emplacement où il
a été trouvé avec l'attribut __file__ du module :

Exemple :
Ecrire un module nommé "perimetre" qui implémente les périmètres des figures suivantes :
• Rectangle = (long + larg) * 2
• Carré = cote * 4
• Cercle = 2 * pi * rayon

On implémente l’ensemble des fonctions sur un fichier (perimetre.py)

La fonction dir()
• Sans arguments donne la liste des noms dans
l’espace de nommage local.
• Avec un argument, elle essaye de donner une liste
d’attributs valides pour cet objet.

La fonction help()
• Permet d’afficher le Nom, la Description et le
contenu des différentes fonctions du module

Usage de notre module périmètre

§ Tout fichier .py qui contient un module est essentiellement aussi un script Python,
et il n'y a aucune raison pour qu'il ne puisse pas être exécuté comme tel.

Qu’est ce que la structure des données ?
Tuple
PARTIE 3 Liste et Chaine
Structures de Dictionnaire
données Set
Algorithmes de tri

En informatique, une structure de données est une manière
d'organiser les données pour les traiter plus facilement.
Exemple : Le répertoire téléphonique
§ Par exemple on peut présenter des numéros de téléphone par
département, par nom, par profession, par numéro téléphonique par
rue et/ou une combinaison quelconque de ces classements.
À chaque usage correspondra une structure d'annuaire appropriée.
§ En organisant d'une certaine manière les données, on permet
un traitement automatique de ces dernières plus efficace et rapide

Différentes structures de données répondant à des contraintes algorithmiques différentes :
1. Structures finies :
• Constantes,
• Variables,
• Enregistrements,
• Structures composées finies ;
2. Structures indexées :
• Tableaux
• Tableaux multidimensionnels
• Tableaux associatifs,
• Vecteurs...
3. Structures récursives :
• Listes chainées,
• Arbres,
• Graphes.
Tuple
Structures de données
Liste
indexées sur Python
Dictionnaire
Set

Tableau statique en lecture seule d’objets hétérogènes.
§ Collection d’objets de types hétérogènes
§ Taille et contenu fixé lors de l’écriture du programme
§ Impossible de modifier : objet non mutable
§ La variable de type Tuple est en réalité une référence
§ Accès indicé, plage d’indices possible, indices négatifs possibles aussi

#Définition d’un tuple
t1 = (9,8,7,6,5,4,3,2,1,0)
print(t1) # 1-Le résultat sera (9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
print(len(t1)) # 2-Le résultat sera 10
a = t1[3]
print(a) # 3-Accés à la valeur d'indice 3
t1[2] = 3 # 4-Modification impossible
# Plage d'indice
b = t1[2:5]
print(b) # 5-Le résultat sera (7, 6, 5)
c = t1[:4]
print(c) # 6-Le résultat sera (9, 8, 7, 6)
d = t1[-1]
print(d) # 7-Le résultat sera (0)
e = t1[-3:]
print(e) # 8-Le résultat sera (2, 1, 0)

'''Concaténation'''
t1 = (9,8,7,6,5)
t2 = (4,3,2,1,0)
t3 = t1 + t2
print(t3) # Le résultat sera (9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
'''Réplication'''
t4 = 2*t1
print(t4) # Le résultat sera (9, 8, 7, 6, 5, 9, 8, 7, 6, 5)
'''Hétérogénéité'''
t5 = (3,6,"modou",True,3.14)
print(t5) # Le résultat sera (3, 6, 'modou', True, 3.14)
'''Tuple de tuple'''
t6 = ((1,2,3),(4,5,6),(7,8,9))
print(t6) # Le résultat sera ((1, 2, 3), (4, 5, 6), (7, 8, 9))
'''Accés indicé'''
print(t6[2][1]) # Le résultat sera 8
'''Accés aux tailles'''
print(len(t6)) # Le résultat sera 3
print(len(t6[2])) # Le résultat sera 3

Tableau dynamique en lecture - écriture d’objets hétérogènes
#Définition d'une liste
l1 = [9,8,7,6,5,4,3,2,1,0]
print(ll) # Le résultat sera [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
#Taille de la liste
print(len(l1)) # Le résultat sera 10
#Accés indicé
a = l1[0]
print(a) # Le resultat sera 9
#Modification autorisé
l1[2] = 3
print(l1) # Le résultat sera [9, 8, 3, 6, 5, 4, 3, 2, 1, 0]

#Définition d'une liste
l1 = [9,8,7,6,5,4,3,2,1,0]
#Ajout d'un élément sur la liste
l1.append(-1)
print(l1) # Le résultat sera [9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1]
#Insertion d'une valeur avec l'indice 3
l1.insert(3,'six')
print(l1) # Le résultat sera [9, 8, 7, 'six', 6, 5, 4, 3, 2, 1, 0, -1]
#Suppression de l'élément n°3
del l1[3]
print(l1) # Le résultat sera [9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1]
# Accés puis suppression de l'élément n°10
a = l1.pop(10)
print(a) # Le résultat sera -1
#Inversion de la liste
l1.reverse()
print(l1) # Le résultat sera [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#Extension, ajout d'élément à partir de la fin
l1.extend([10,11])
print(l1) # Le résultat sera [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
#Vider la liste
l1.clear()
#Rechercher un élément dans une liste
l1 = [3,5,3,9,2,4,9,2,0]
trouver = 6 in l1
print(trouver) # Le résultat retourné sera False
#Rechercher un indice
indice = l1.index(4)
print(indice) # Le résultat retourné sera 5
#Comptage
nb = l1.count(3)
print(nb) # Le résultat retourné sera 2
#Retrait par valeur
l1.remove(4)
print(l1) # Le résultat retourné sera [3, 5, 3, 9, 2, 9, 2, 0]

# Soit la liste l1 = [3,5,3,9,2,4,9,2,0]
l1 = [3,5,3,9,2,4,9,2,0]
#Affectation
l2 = l1
print(l2) # Resultat retourné [3, 5, 3, 9, 2, 4, 9, 2, 0]
#Modification d'une valeur
l2[1] = 'cinq'
print(l1) # Resultat retourné [3, 'cinq', 3, 9, 2, 4, 9, 2, 0] l1 est impacté
#Copier une liste
l3 = l2.copy()
print(l3)
#Modification d'une valeur
l3[1] = 'on revient à 6'
print(l3) # Resultat retourné [3, 'on revient à 6', 3, 9, 2, 4, 9, 2, 0]
print(l2) # Resultat retourné [3, 'cinq', 3, 9, 2, 4, 9, 2, 0] l2 non impacté

Parcours itératif d’une liste
Que permettent de faire les scripts ci-dessous ?

Avec Python, définir la liste suivante :
liste = [3,2,9,5,7,8,1,6,0]
1. Triez puis affichez la liste
2. Ajoutez l’élément 4 à la liste puis affichez la liste
3. Renversez et affichez la liste
4. Affichez l’indice de l’élément 7
5. Enlevez l’élément 8 et affichez la liste
6. Affichez la sous liste du 2e au 3e élément
7. Affichez la sous liste du début au 4e élément
8. Affichez le dernier élément en utilisant un indiçages négatif

#Définir une chaine
s1 = "Hello les étudiants du MSDA"
print(s1) # Resultat retrouné : Hello les étudiants du MSDA
#Longueur
long = len(s1)
print(long) # Resultat retrouné : 27
#Accés indicé
s2 = s1[:7]
print(s2) # Resultat retrouné : Hello l
#Non modifiable
s1[5]='-'
s = s1.upper()
print(s) # Resultat retrouné : HELLO LES ETUDIANTS DU MSDA
#Recherche d'une sous chaine
ok = s.find("EL")
print(ok) # Resultat retrouné : 1
#Nombre d'occurence
cpt = s.count("E")
print(cpt) # Resultat retrouné : 2
#Remplacement d'occurence
rp = s.replace("MSDA","Master en Science des Données et Applications")
print(rp) # Resultat retrouné : HELLO LES ENFANTS DU Master en Science des Données et Applications
#Définir une chaine
s1 = "Nitou Thies"
#Transformation de chaine en liste
liste = list(s1)
print(liste) #['N', 'i', 't', 'o', 'u', ' ', 'T', 'h', 'i', 'e', 's']
#Découpage par séparateur
decoupe = s1.split(" ")
print(decoupe) # ['Nitou', 'Thies’]
#Former une chaine à partir d'une liste
ok = "/".join(decoupe)
print(ok) # Nitou/Thies

Collection non ordonnée d’objets s’appuyant sur le mécanisme associatif « clé – valeur »
Mamadou UGB
Mansour UIDT
Dame UCAD
CLE VALEUR

Collection non ordonnée d’objets s’appuyant sur le mécanisme associatif « clé – valeur »
#Définir un dictionnaire
d1 = {'Macky Sall':58,'Abdoulaye Wade':94,'Abdou Diouf':85}
print(d1) # {'Macky Sall': 58, 'Abdoulaye Wade': 94, 'Abdou Diouf': 85}
print(d1.items())
#Liste des clés
print(d1.keys()) # dict_keys(['Macky Sall', 'Abdoulaye Wade', 'Abdou Diouf'])
#Liste des valeurs
print(d1.values()) # dict_values([58, 94, 85])
#Accés à l'age de Abdoulaye Wade
print(d1['Abdoulaye Wade']) # Resultat retourné 94
#Si clé n'existe pas
print(d1['Leopold Senghor'])

Le type intégré de Python set a les caractéristiques suivantes :
• Les ensembles ne sont pas ordonnés
• Les éléments de l'ensemble sont uniques
• Les éléments en double ne sont pas autorisés
• Un ensemble peut être modifié, mais les éléments de l'ensemble doivent être d'un type immuable.

Le type intégré de Python set est un itérable qui a les caractéristiques suivantes :
• Les ensembles ne sont pas ordonnés
• Les éléments de l'ensemble sont uniques
• Les éléments en double ne sont pas autorisés
• Un ensemble peut être modifié, mais les éléments de l'ensemble doivent être d'un type immuable.

x1.union(x2[, x3 ...])
x1 | x2 [| x3 ...]

x1.intersection(x2[, x3 ...])
x1 & x2 [& x3 ...]

x1.difference(x2[, x3 ...])
x1 - x2 [& x3 ...]

x1.symmetric_difference(x2[, x3 ...])
x1 ^ x2 [& x3 ...]

La notion de tri
Un algorithme de tri est, en informatique ou en mathématiques, permet d'organiser une
collection d'objets selon une relation d'ordre déterminée.
Les objets à trier sont des éléments d'un ensemble muni d'un ordre total.
Les algorithmes de tri sont utilisés dans de très nombreuses situations.
Ils sont en particulier utiles à de nombreux algorithmes plus avancés
Ils peuvent également servir pour mettre des données sous forme canonique ou les rendre
plus lisibles pour l'utilisateur.

Nous avons les tris suivants :
- Tri par insertion
- Tri par sélection
- Tri bulle
- Tri fusion (à voir sur la partie Récursivité)

• Au départ la main est vide, on prend la première carte, puis on tire une carte et on l'insère à la
bonne place dans la main
• Pour trouver la bonne place, on regarde les cartes de droite à gauche t dès que l'on rencontre une
carte plus petite on insère la carte à droite de cette carte.
• Donc lorsqu'on tire la j ième carte, les j-1 premières cartes sont triées

Parcours itératif d’une liste / Tri par insertion (algorithme)

Tri par sélection (principe)
Pour chaque élément en partant

du début de la liste on cherche le
plus petit élément dans le reste
de la liste et on l'échange avec
l'élément courant.

Parcours itératif d’une liste / Tri par sélection (algorithme)

Tri bulle (principe)
L'idée est de comparer chaque élément

du tableau avec tous les autres.
On compare l'élément avec son voisin.
La plus petite valeur est permutée à
gauche. La comparaison continue jusqu'à
la fin du tableau de façon à ce que la plus
grande valeur se retrouve à la fin.
À la seconde itération, on recommence
sur la longueur du tableau moins 1
élément, car on sait que la plus grande
valeur est déjà en place.
À la troisième itération, on recommence
sur la longueur du tableau moins 2
éléments etc.

Parcours itératif d’une liste / Tri bulle (algorithme)

Ecrire un programme en Python qui demande à l’utilisateur de saisir une liste
d’entiers puis à l’aide d’un parcours itératif effectue les actions suivantes :
1. Afficher la liste
2. Afficher la liste en colonne de manière à afficher l’index et son contenu
3. Additionner tous les éléments de la liste
4. Créer une nouvelle liste qui sera le multiple (3) de tous les éléments de la liste
5. Obtenir le plus grand entier de la liste
6. Obtenir le plus petit entier de la liste
7. Compter le nombre des entiers pairs présents dans la liste
8. Calculer la somme de tous les nombres impairs de la liste

Principe de la récursivité
Récursivité croisée
PARTIE 3 Récursivité multiple
Récursivité et
Complexité
Récursivité imbriquée
Le paradigme diviser pour régner
Compléxité

• En informatique un programme est dit récursif s’il s’appelle lui-même.
• Le mot récursif vient du latin recurrere signifiant courir en arrière
Le moi est haïssable, mais pas dans l‘univers de la récursivité…

• L'idée sous-jacente est que pour résoudre un problème ou effectuer un
calcul, on se ramène à la résolution d’un problème similaire mais
de complexité moindre.
• On itère le processus jusqu’à obtenir un problème élémentaire que l'on
sait résoudre.

• Le programme en question va s'appeler lui-même avec un paramètre plus "petit".
• Cet appel en induira un autre, puis un autre, etc.
• D'appel en appel, la taille du paramètre va ainsi diminuer.
• On s'arrêtera quand cette taille sera celle d'un problème immédiatement résolvable.

• Les différents problèmes intermédiaires, ceux permettant de passer du problème initial au
problème élémentaire, sont stockés successivement en mémoire dans ce que l'on appelle
une pile.
• Structure de données dans laquelle on accède aux éléments dans l'ordre inverse de leur
ajout en mémoire. (Voir partie sur les Types Abstraits de Données)
• On utilisera ainsi en premier le résultat du problème élémentaire, puis de proche en proche
on arrivera à celui du problème initial.

Ecrire une fonction en Python permettant de calculer la factorielle d’un entier.
Ecriture itérative : Ecriture récursive :
def facto(n): def facto(n):
F = 1 F = 1
for i in range(1,n+1): if (n==0 or n==1):
F = F * i F = 1
return F else:
F = n * facto(n-1)
return F

Ecrire une fonction en Python permettant de calculer la factorielle d’un entier.
Ecriture récursive : Pile d’exécution : 24
def facto(n): facto (4) = 4 * facto(3) facto (4) = 4 * 6
F = 1
if (n==0 or n==1):
F = 1 6
else: facto (3) = 3 * facto(2) facto (3) = 3 * 2
F = n * facto(n-1)
return F
2
facto (2) = 2 * facto(1) facto (2) = 2 * 1
NB: Il est indispensable de prévoir
une condition d’arrêt à la récursion
sinon le sous-programme va 1
s'appeler une infinité de fois.
facto (1) = 1
Itérative vs Récursivité
Récursivité Itération
Signification § La fonction appelle elle-même. § Permet d’exécuter plusieurs fois l’ensemble des instructions.
§ L’itération comprend l’initialisation, la condition, l’exécution de l’instruction

§ Dans une fonction récursive, seule la condition de
Format dans une boucle et la mise à jour (incrémenter et décrémenter) la variable
terminaison est spécifiée.
de contrôle.
§ Une instruction conditionnelle est incluse dans le
corps de la fonction pour forcer la fonction à § L’instruction d’itération est exécutée plusieurs fois jusqu’à ce qu’une
Terminaison
retourner sans que l’appel de récurrence soit certaine condition soit atteinte.
exécuté.
§ Si la fonction ne converge pas vers une condition
§ Si la condition de contrôle dans l’instruction d’itération ne devient jamais
Condition appelée (cas de base), elle conduit à une récursion
fausse, elle conduit à une itération infinie.
infinie.
Répétition infinie § Une récursion infinie peut bloquer le système. § Une boucle infinie utilise les cycles du processeur de manière répétée.
Application § La récursivité est toujours appliquée aux fonctions. § L’itération est appliquée aux instructions d’itération « ex : des boucles ».
§ La pile est utilisée pour stocker l’ensemble des

Pile nouvelles variables et paramètres locaux chaque § N’utilise pas la pile.
fois que la fonction est appelée.
La vitesse § Lent § Rapide
Taille du code § La récursivité réduit la taille du code. § L’itération rend le code plus long.

Itérative vs Récursivité

Principalement on distingue les types de récursivité suivants :
• RECURSIVITE CROISEE (MUTUELLE)
• RECURSIVITE MULTIPLE
• RECURSIVITE IMBRIQUEE

"Drawing hands"
Maurits Cornelis Escher
• C’est une fonction récursive qui elle-même appelle la première.
Exemple : Déterminons la parité d’un entier
- n est pair ssi n - 1 est impair.
- n est impair ssi n - 1 est pair. def pair(n):
if n==0:
- De plus 0 est pair. return True
else:
return impair(n-1)
def impair(n):
if n==0:
return False
else:
return pair(n-1)

• C’est lorsqu’une fonction récursive réalise plusieurs appels à elle même
Exemple : Construisons le triangle de Pascal avec le coefficient de Binomial

Rappelons la définition d’un coefficient binomial :
𝑃𝑜𝑢𝑟 𝑛 𝜖 𝑁 𝑒𝑡 𝑘 ∈ 𝑁 𝑎𝑣𝑒𝑐 0 ≤ 𝑘 ≤ 𝑛
𝑛 1, 𝒔𝒊 𝒌 = 𝟎 𝒐𝒖 𝒔𝒊 𝒌 = 𝒏
= $ 𝑛 −1 𝑛 −1
𝑘 + 𝒔𝒊𝒏𝒐𝒏
𝑘 −1 𝑘
Etape 1 : Implémentons la fonction récursive du coefficient binomial

def coeff_bin(n,k):
if k==0 or k==n:
return 1
elif k>n:
return ""
else:
return coeff_bin(n-1,k-1) + coeff_bin(n-1,k)
Etape 2 : Implémentons une boucle faisant appel à coeff_bin pour afficher le triangle de Pascal
def coeff_bin(n,k):
if k==0 or k==n:
return 1
elif k>n:
return ""
else:
return coeff_bin(n-1,k-1) + coeff_bin(n-1,k)
n = 10
k = 10
for i in range(0,n+1):
s = ''
for j in range(0,k+1):
X = coeff_bin(i,j)
s=s+" "+str(X)
print(s)
C’est une fonction récursive dont l’appel à lui même contient un autre appel à lui même
Exemple : Fonction de Ackermann
𝑛 + 1 𝒔𝒊 𝒎 = 𝟎
𝐴(𝑚, 𝑛) = 4 𝐴 𝑚 − 1,1 𝒔𝒊 𝒎 > 𝟎 𝒆𝒕 𝒏 = 𝟎
𝐴 𝑚 − 1, 𝐴 𝑚, 𝑛 − 1 𝒔𝒊 𝒎 > 𝟎 𝒆𝒕 𝒏 > 𝟎
def ackermann(m,n):
if m==0:
return n+1
elif m>0 and n==0:
return ackermann(m-1,1)
elif m>0 and n>0:
return ackermann(m-1,ackermann(m,n-1))
Des problèmes plus complexes se résolvent aussi naturellement de façon récursive,
avec des algorithmes s’appéllant eux-mêmes une ou plusieurs fois sur des données
de tailles inférieures.
• Obtenir des problèmes de taille élémentaire,
• Résolvables immédiatement.
Enfin combiner les résultats issus de chacun de ces appels.

Des classiques algorithmiques sont résolus avec le Divide and Conquer
- Algorithmes de tri fusion
- Maximum d’une liste
- Recherche d’un élément dans une liste
- Algorithme de karatsuba

1. Diviser : On divise les données initiales en plusieurs sous-parties.
2. Régner : On résout récursivement chacun des sous-problèmes associés
(ou on les résout directement si leur taille est assez petite).
3. Combiner : On combine les différents résultats obtenus pour obtenir une solution au problème initial.

Tri fusion
L'algorithme est naturellement décrit de façon récursive.
1.Si le tableau n'a qu'un élément, il est déjà trié.
2.Sinon, séparer le tableau en deux parties à peu près égales.
3.Trier récursivement les deux parties avec l'algo du tri fusion.
4.Fusionner les deux tableaux triés en un seul tableau trié.

Tri fusion (Etape A : Fonction récursive pour fusionner deux listes)
def fusion(T1,T2):
if T1==[]:return T2
if T2==[]:return T1
if T1[0]<T2[0]:
return [T1[0]]+fusion(T1[1:],T2)
else:
return [T2[0]]+fusion(T1,T2[1:])
T1 = [-1,4,5,7,9,3]
T2 = [8,9,6]
print(fusion(T1,T2))

Tri fusion (Etape B : Fonction récursive pour trier les listes fusionnées)
def trifusion(T):
if len(T)<=1:return T
T1=[T[x] for x in range(len(T)//2)]
T2=[T[x] for x in range(len(T)//2,len(T))]
return fusion(trifusion(T1),trifusion(T2))
print(trifusion(X))

Maximum et minimum d’une liste
def maximumListe(tab,debut,fin):
if debut == fin:
return L[debut]
else:
# Diviser
m = (debut+fin)//2
# Régner
x = maximumListe(tab,debut,fin)
y = maximumListe(tab,debut+1,fin)
# Combiner
themax = x if (x > y) else y
return themax
# Test
arr = [-1,4,5,7,9,3]
print(maximumListe(arr,0,5))

Rechercher un élément dans une liste
La recherche dichotomique, ou recherche par dichotomie (en anglais : binary search),
est un algorithme de recherche pour trouver la position d'un élément dans un tableau trié.

Rechercher un élément dans une liste
def dicho(tableau,elm_a_trouver,debut,fin):
if debut>fin:
return False
else:
# Diviser
m = (debut+fin)//2
if tableau[m]==elm_a_trouver:
return True
else:
# Régner
if elm_a_trouver<tableau[m]:
return dicho(tableau,elm_a_trouver,debut,fin-1)
else:
return dicho(tableau,elm_a_trouver,debut+1,fin)
arr = [-1,4,5,7,9,3]
print(dicho(arr,19,0,5))

Algorithme de Karatsuba
Propose une méthode de calcul pour la multiplication de deux nombres x et y comportant n chiffres :
- Séparer chaque nombre en deux parties de n/2 chiffres.
n est le nombre de chiffres du plus grand des deux
- Dans ce cas x*y sera égal à:
- En utilisant :
- La multiplication de x*y revient à effectuer récursivement ces trois produits a×c,b×d,(a+b)×(c+d)

- Combiner les résultats

Le calcul de la complexité d’un algorithme permet de mesurer sa performance.
Il existe deux types de complexité :
§ Complexité spatiale :
Permet de quantifier l’utilisation de la mémoire
• Complexité temporelle :
Permet de quantifier la vitesse d’exécution

L’objectif d’un calcul de complexité algorithmique temporelle est de pouvoir comparer
l’efficacité d’algorithmes résolvant le même problème. Dans une situation donnée, cela permet donc
d’établir lequel des algorithmes disponibles est le plus optimal.

Réaliser un calcul de complexité en temps revient à compter le nombre d’opérations
élémentaires (affectation, calcul arithmétique ou logique, comparaison…) effectuées par
l’algorithme. Puisqu’il s’agit seulement de comparer des algorithmes, les règles de ce calcul
doivent être indépendantes :
• du langage de programmation utilisé ;
• du processeur de l’ordinateur sur lequel sera exécuté le code ;
• de l’éventuel compilateur employé.
Par soucis de simplicité, on fera l’hypothèse que toutes les opérations élémentaires sont
à égalité de coût, soit 1 « unité » de temps.
Exemple : a = b * 3 : 1 multiplication + 1 affectation = 2 « unités »

La complexité en temps d’un algorithme sera exprimé par une fonction, notée T qui dépend :
• de la taille des données passées en paramètres
• de la donnée en elle-même
Cette remarque nous conduit à préciser un peu notre définition de la complexité en temps.
En toute rigueur, on peut en effet distinguer deux formes de complexité en temps :
ü La complexité dans le meilleur des cas : c’est la situation la plus favorable,
par exemple : recherche d’un élément situé à la première position d’une liste
ü La complexité dans le pire des cas : c’est la situation la plus défavorable,
par exemple : recherche d’un élément dans une liste alors qu’il n’y figure pas

Pour comparer des algorithmes, il n’est pas nécessaire d’utiliser la fonction T, mais seulement l’ordre de grandeur
asymptotique, noté O (« grand O »).

Paradigme Type de Données Abstrait
Construction de TDA en Python
PARTIE 4 Rappel sur le paradigme orienté objet
TDA et OO Classe, Objet
Heritage, Encapsulation
Polymorphisme, Agrégation

v Qu’est-ce qu’un nombre ?
• Une longueur ? comme 3 cm ;
• Une quantité d’objet ? trois carottes ;
• Un symbole ? le chiffre "3" ;
• Un ensemble ? en théorie des ensembles, on a : 𝐄 = 𝐍 𝐙 𝐃 𝑸 …
v Les nombres se définissent par leur propriétés.
• on peut leur appliquer des opérations (+, −,×,÷)
• on peut les ordonner (<, >, ≤, ≥)
• Ils vérifient certaines propriétés (distributivité, commutativité, etc.)
Les types de données manipulés jusque là sont prévus par l’environnement de programmation.
Et si nous voulons utiliser voire manipuler des types de données non existants, quoi faire ???

Qu’est ce qu’un type de données abstrait (TDA) ?
Un TDA c’est un type de données, doté d’un ensemble d’opérations dont les détails
d’implémentation restent cachés (abstrait).
Exemple : Manipulation d’une matrice
- Objectif : Construire une bibliothèque pour les opérations sur une matrice
- Démarche :
- Vision externe :
• Quels sont les services attendus d’une telle bibliothèque
- Vision interne :
• Quelle est la meilleure représentation d’une matrice
• Comment implémenter les opérations

Principalement le TDA peut se comprendre sous trois aspects :
- Abstraction des données
Identification des caractéristiques importantes par rapport aux opérateurs
- Encapsulation
Intégrer ces données dans une entité logicielle (structure)
- Modularité
Diviser un gros système en entités plus petite

Généralement en Génie Logiciel on construit un TDA pour trois raisons :
1. Maîtriser la complexité
2. Réutiliser du code existant
3. Capitaliser les efforts

• Maîtriser la complexité
C’est-à-dire diviser pour régner grâce à la modularité
Découper un problème en modules :
– Aussi indépendants que possible
– Faciles à comprendre.
– Testables.
• Quelles découpes en modules semblent judicieuses ?

• La réutilisation de code
Résoudre une fois pour toute une famille de problèmes
– Exemple : logiciel utilisant les nombres complexes
• Combien de fois seront programmés la somme, le produit de 2 nombres complexes ?
• Intérêt de créer des fonctions réutilisables pour ces opérations.
Bibliothèques d’usage général
– Le calcul avec les nombres complexes est un problème général.
– Pas lié à une application particulière
– Intérêt de créer une bibliothèque générale, réutilisable.
– Une telle bibliothèque existe-t-elle déjà ?

• Capitalisation des efforts
Abstraction
– Créer des fonctions offrant un service clair.
– Compréhensible et utilisable sans lire le code.
– Permet de traiter des problèmes de haut niveau, en s’affranchissant des problèmes de
niveau inférieur
Isolation des modules
– Si l’interface d’un module est juste, la correction ou la modification d’une fonction n’a pas
d’influence sur le code utilisateur.
– Sécurisation des développements.

Une pile c’est un TDA qui permet : Sommet
- d'ajouter un élément à son sommet (empiler)
- d'ôter l'élément à son sommet (dépiler)

bol 3
Le principe d'une pile est dernier entré, premier sorti
bol 2
(LIFO : Last In First Out)
Exemple : Rangement de bol à la cuisine bol 1

EMPILER DEPILER
bol 3 bol 3
bol 3 bol 2
bol 2
bol 2 bol 2 bol 2
bol 1 bol 1 bol 1 bol 1 bol 1

Définissons le TDA pile, pour cela nous avons les opérations suivantes :
1. Création de la pile
2. Possibilité d’empiler
3. Possibilité de dépiler
4. Accès au sommet de la pile
5. Vider la pile

Définissons une bibliothèque (module) intitulée pile.py avec ses opérations :
PileErreur=ValueError('Pile vide')
def nouvelle_pile():
#Creation de la pile
return []
def empile(L,e):
#Empilement
L.append(e)
def depile(L):
#Depilement
if L == []: raise PileErreur
L.pop()
def sommet(L):
#Accés au somment de la pile
if L == []: raise PileErreur
return L[len(L)-1]
def est_vide():
#Vider la pile
return L==[]

Importons le TDA pile puis testons

Les piles sont souvent utiles pour stocker des calculs intermédiaires comme en récursivité.
Typiquement pour le calcul de la factorielle.
• Il faut calculer fact(n-1) avant de faire le * n
• On met les calculs « * n » dans la pile.
• Et dès qu’on tombe sur 0! (condition d’arrêt) on dépile et applique les calculs
def facto(n):
F = 1
if (n==0 or n==1):
F = 1
else:
F = facto(n-1) * n
return F

Une file c’est une TDA qui permet :
- d'ajouter un élément qu’a sa queue (enfiler)
- d'ôter l'élément à son sommet (dépiler)
Le principe d'une file est premier entré, premier sorti
(FIFO : First In First Out)
Exemple : Des étudiants qui font la queue au resto
Et1 Et2 Et3 Et4 Et5

ENFILER
Et6
DEFILER
Et2 Et3 Et4 Et5
Et1

Définissons le TDA pile, pour cela nous avons les opérations suivantes :
1. Création de la file
2. Possibilité de faire un enfilement
3. Possibilité de défiler
4. Accès à la tête de file
5. Vider la file

Définissons une bibliothèque (module) intitulée file.py avec ses opérations
FileErreur=ValueError('File vide')
def nouvelle_file():
#Creation de la file
return []
def enfile(L,e):
#Enfilement
L.append(e)
def defile(L):
#Defilement
if L == []:
raise FileErreur
L.pop(0)
def tete(L):
#Tête de file
return L[0]
def vider_file():
#Vider la file
return L==[]

Importons le TDA file puis testons

1. Il y a deux acteurs dans notre histoire :
• Le développeur qui écrit le module
• L’utilisateur qui fait appel aux fonctions du module.
• Entre les deux il y a le type abstrait (ici Pile et File)
2. L’interface définie un type abstrait
• Elle doit être documentée.
• C’est le nom des fonctions et ce qu’elles font (sémantiques)
• Elle ne doit jamais changer!
3. Le développeur fait le choix de la structure.
• Il écrit les fonctions de l’interface
• Il peut modifier la structure (pour gagner en efficacité par exemple)
• Il ne doit pas toucher à l’interface.
4. L’utilisateur écrit des algorithmes/programmes en utilisant l’interface
• Une documentation suffit, avec la complexité des fonctions.
• Il n’as pas à se soucier des changements fait par le développeur
• Il ne doit pas utiliser la structure interne.

Qu’est ce que le paradigme orienté objet ?
Le paradigme orienté objet consiste en la définition et l'interaction de briques logicielles
appelées objets ; un objet représente un concept, une idée ou toute entité du monde
physique, comme une voiture, une personne ou encore une page d'un livre.
L’idée c’est donc de représenter ces objets et leurs relations et l'interaction entre les
objets via leurs relations permet de concevoir voire réaliser les fonctionnalités
attendues, de mieux résoudre des problèmes.
Dès lors, l'étape d’analyse et de conception revêt une importance majeure et
nécessaire pour la programmation. C'est elle qui permet de transcrire les éléments du
réel sous forme virtuelle.

L’objectif principal du paradigme OO c’est de réduire la complexité logiciel via :
- Une décomposition modulaire
- Regrouper des fonctions, des propriétés en rapport à un type donné dans un module
- Cacher la complexité des fonctions et celle de leurs actions
- Fournir une interface d’accès aux services du module
- Communication par envoie de message

Méthode d’analyse et de conception
Une méthode comprend
Des modèles :
Une démarche : Facilitent les retours sur la
Explique la marche à suivre en conception et l’évolution des
exploitant au mieux les principes de systèmes
modularité, d’abstraction, de
réutilisation, etc
Un formalisme de représentation :
Facilite la communication,
l’organisation et la vérification

Méthodes fonctionnelles :
Diviser pour régner
Méthodes
existantes Méthodes systémiques :
Séparation des données
et des traitements
Méthodes objets :
Intégration des données et des
traitements dans un objet unique

Description abstraite d’un ensemble d’objets ayant
- Une structure identique
(liste des attributs)
- Un même comportement
(liste des opérations/méthodes/comportements)
- Une même sémantique
- Les mêmes relations

Représente une entité physique, logicielle, ou conceptuelle
Exemples : Livre, Voiture, Maison, Personne …
Un objet possède :
– Une identité :
Permet de distinguer chaque objet par rapport aux autres
– Un état :
Correspond aux valeurs de tous ses attributs à un instant donné
– Un comportement :
Ensemble des opérations qu’il peut exécuter en réaction aux messages provenant des autres objets
L’objet c’est l’instanciation de la classe

Analogie du gâteau

Mécanisme de transmission des propriétés d’une classe (attributs et méthodes)
vers une sous classe évitant les duplications d'information.
Ce mécanisme permet de se servir d'une classe préexistante (mère) pour en créer une
nouvelle (fille) qui possédera des fonctionnalités supplémentaires ou différentes.

PUBLIC (+)
• Attribut ou Méthode visible partout
PRIVE (-)
• Attribut ou Méthode visible à l’intérieur de la classe
PROTÉGÉ (#)
• Attribut ou méthode visible juste à l’intérieur d’une classe et de par ses sous classe

Technique consistant à regrouper les données et les méthodes d’un objet et à
masquer les détails de leur implémentation.
Personne
Attribut privé +nom
+prenom
+age
-cerveau
Méthode privée
+manger()
+marcher()
-réfléchir()

Faculté d’une méthode de s’exécuter différemment suivant le contexte de la
classe ou elle se trouve.
Surface du rectangle = (Long + Larg) * 2
Surface du triangle = (Base * Hauteur) / 2

Relation entre plusieurs classes, spécifiant qu’une classe est composée d’une ou
de plusieurs autres classes.
• Les losanges noir : Forte agrégation

(Relation obligatoire)
• Les losanges blanc : Faible agrégation
(Relation facultative)

• Une interface n’est pas une classe, c’est une liste d’opérations
• Une interface, comme une classe abstraite, ne peut pas servir à créer un objet
• Une interface exprime un contrat à respecter par les classes qui « réalisent » cette interface
<<interface>>
Forme
calculAire()
Triangle Rectangle

L’existant en Python
Les objets groupent des données et des méthodes (fonctions) logiquement liées.
Exemple 1 : Le cas de la structure de données Liste

L’existant en Python
Exemple 2 : Le cas de la structure de données Tuple

Un paradigme procédural convient à manipuler intuitivement le concept d’objet.
Et si nous voudrions concrètement créer des objets personnalisés et du même type ?
D’où l’intêret de construire une classe en Python
Une classe est un modèle pour un objet dans le code.
Elle permet de construire plusieurs objets du même type (appelés instances de la
même classe) plus facilement, rapidement et en toute fiabilité.

Soit la classe Vecteur, construisons la avec Python
Vecteur import math

class Vecteur:
+x : float """La classe vas représenter un vecteur"""
+y : float def __init__(self, a, b):
self.x = a
+norme(x,y) : float self.y = b
def norme(self):
return math.sqrt(self.x**2+self.y**2)
norme = racine_carre(x² + y²

Soit la classe Vecteur, construisons la avec Python Constructeur :
Fonction qui est appelée
quand on procède à
l’instanciation de la
import math classe
class Vecteur:
"""La classe vas représenter un vecteur"""
def __init__(self, a, b):
self.x = a
self.y = b
def norme(self):
return math.sqrt(self.x**2+self.y**2) Méthode :
Permet le calculer de la
norme du vecteur

Instance de la classe Vecteur :
• On vient de créer un objet
nommé vec1 ;
• On peut appeler la méthode
norme depuis l’objet vec1 ;
• On peut retourner la valeur d’un
attribut.

Une méthode statique est définie
directement sur la classe en
utilisant la notation @staticmethod
Cela signifie que vous ne pouvez
pas appeler une méthode statique
sur l'objet (p1) mais juste sur la
classe (Personne)

Getter (Accessor) et Setter (Mutator) :
Ces méthodes permettent la recupération
et la modification dynamique des valeurs
des attributs d’un objet.
Le getter récupère l’ancienne valeur

Le setter place la nouvelle valeur

class fille
Rectangle
+long : float
+larg : float Classe mère
+surface(long,larg) : float
Classe fille
Pavé
+hauteur : float
+volume(surf,haut) : float

class fille
En informatique, l’héritage multiple est un mécanisme de programmation orientée objet dans lequel
une classe peut hériter de comportements et de fonctionnalités de plus d'une super-classe.
Il s'oppose à l'héritage simple, dans lequel une classe ne peut hériter que d'une seule super-classe.
Carnivore Herbivore
+ consV : float + consH : float
+devorer(cons) : string +brouter(cons) : string
Omnivore

class fille

L’exécution de la méthode .mro() sur une classe fille nous
renseigne sur l’hiérarchie employée lors du parcours de l’héritage.

L’usage du _ "underscore"
Rectangle
rend l’attribut protégé
#long : float
#larg : float
+surface(long,larg) : float
L’usage du double __ "underscore"
rend l’attribut privé
L’attribut __haut étant privé donc il a une

visibilité cachée ce qui fait que l’on ne pas y
Pavé accéder directement
-hauteur : float
+volume(surf,haut) : float

L’écriture du getter (accesor) get_h()
permettra d’accéder à l’attribut haut de la
classe Pave malgré le fait qu’il ait une
visibilité cachée

En Python, on s'intéresse aux méthodes implémentées par un
objet et non pas à son « type » Duck typing :
" If it quacks like a duck, it's a duck "
"Si je vois un oiseau qui vole comme un canard, cancane comme
un canard, et nage comme un canard, alors j'appelle cet oiseau
un canard." (test du canard de James Whitcomb Riley)

Rectangle
Coin inférieur
Coin supérieur

Une classe peut implémenter certaines opérations que l'on invoque par une syntaxe spéciale (telles que
les opérations arithmétiques) en définissant des méthodes aux noms particuliers.
Méthode Description
__init__ Méthode appelée automatiquement lors de la création d’un objet. Elle permet d’initialiser l’objet.
__new__ Cette méthode en réalité s’agit véritablement du constructeur.
__del__ Méthode appelée implicitement lors de la destruction d’un objet.
__name__ Méthode pour renvoyer le nom de la classe.
__doc__ Méthode renvoie le doc String de la classe interrogée.
__dict__ Méthode pour renvoyer un dictionnaire des méthodes et attributs disponibles pour l’objet.
__module__ Permet de connaitre le nom du module dans lequel est codé une fonction
__class__ Pour connaitre à partir de quelle classe l’objet a été créé
__repr__ Méthode pour donner la représentation textuelle de n’importe quel objet

Catégorie Nom des méthodes spéciales
Représentation __repr__, __str__, __format__, __bytes__
Conversion en nombre __abs__, __bool__, __complex__, __int__, __float__, __hash__, __index__
Collections __len__, __getitem__, __setitem__, __delitem__, __contains__
Itérateurs __iter__, __reversed__, __next__
Création et destruction d'instances __new__, __init__, __del__
Gestion des attributs __getattr__, __getattribute__, __setattr__, __delattr__, __dir__
Comparaison __lt__<, __le__<=, __eq__==, __ne__!=, __gt__>=, __ge__>=
Opérateurs arithmétiques __add__+, __sub__, __mul__*, __truediv__/, __floordiv__//, __mod__%, __round__

Python utilise les méthodes spéciales pour la surcharge d'opérateur, permettant à une classe de définir son
propre comportement vis-à-vis des opérateurs du langage.
La méthode __add__ permet de surcharger l'opérateur +.
Dans l'exemple suivant, une classe Fraction est définie et l'opérateur __add__ est surchargé.

Les listes en python sont en fait implémentées comme des tableaux dont la taille peut être
modifiée dynamiquement (mais avec un coût caché).
Il existe d’autres manières d’implémenter les listes, avec des coûts différents.
La liste chaînée en est une des nombreuses possibilités.
Qu’est ce qu’une liste chainée ?
Une liste chaînée est une structure de données composées d’une séquence d’éléments de liste.
• Chaque enregistrement d’une liste chaînée est souvent appelé élément , nœud ou maillon.
• La tête d’une liste est son premier nœud.
• La queue d’une liste peut se référer soit au reste de la liste après la tête, soit au dernier nœud.
• Le champ de chaque nœud qui contient l’adresse du nœud suivant ou précédent est
généralement appelé lien ou pointeur.
• Le contenu est placé dans un ou plusieurs autres champs appelés données ou valeurs.

Les opération possibles pour une liste chainée
• est_vide(L) : renvoie vrai si la liste est vide
• taille(L) : renvoie le nombre d’éléments de la liste
• get_dernier_maillon(L) : renvoie le dernier élément de la liste
• get_maillon_indice(L, i) : renvoie le maillon d’indice i
• ajouter_debut(L, d) : ajoute un élément au début de la liste
• ajouter_fin(L, d) : ajout un maillon à la fin de la liste
• inserer_apres(L, i, M) : insert un maillon à l’indice i
• supprimer_apres(L, M) : supprime le maillon suivant le maillon M
• …

Insertion d’un maillon
Pour insérer un maillon nM après un maillon M, il faut :
1. Faire pointer le pointeur nM.suiv vers M.suiv
2. Faire pointer le pointeur M.suiv vers nM

Suppression d’un maillon
Pour supprimer le maillon suivant un maillon M , il faut :
1. Faire pointer le pointeur M.suiv vers M.suiv.suiv
2. Détruire (effacer de la mémoire) le maillon M.suiv

Une liste chainée est une structure de données comportant les aspects suivants :
• une constante, la liste vide, souvent notée nil ;
• un test qui indique si la liste à laquelle il s’applique est vide ;
• deux accesseurs, historiquement appelés car et cdr, qui, appliqués à une liste, renvoie son premier
élément et la liste (éventuellement vide) obtenue à partir de la liste initiale en supprimant son
premier élément ;
• un constructeur, historiquement appelé cons, qui à un élément et une liste associe une nouvelle
liste, dont l’élément fourni est le premier et la liste des suivants est celle qu’on a donnée.
Autrement dit, pour une liste chainée L non vide, on a :
L ≡ cons(car(L),cdr(L)).
C’est cette équivalence qui, s’il on veut, définit la sémantique de cette structure de données.
car(L) s’appelle la tête de la liste L, cdr(L) s’appelle sa queue.

Insérons l’élément 3 entre le 2 et le 4
Ecrire la fonction qui permet de supprimer un élément de la liste chainée

Qu’est ce que l’architecture logicielle ?
PARTIE 5 Styles, Patrons, Idiomes

Design
Patterns Patrons de conception
Strategy, Factory, Decorator, Iterator

Génie logiciel (Software engineering)
• L’application systématique et disciplinée d’approches quantifiables de
développement et de maintenance de logiciels, et l’étude de ces approches.
(IEEE 610.12)
Architecture logicielle (Software architecture)
• L’architecture logicielle d’un programme ou d’un système est la structure ou
les structures du système, comprenant les composantes logicielles, les
propriétés exposées de ces composantes et les interactions entre celles-
ci.(Bass, Clements et Kazman 2003)

L’architecture logicielle est une abstraction d’un logiciel
• Collection de composantes
Client, serveur, filtre, couche, contrôleur, agent
• Topologie de composantes (relations)
Agrégation, classification, généralisation
• Interactions entre les composantes
Connecteurs : Propriétés des composantes
Mode d’interaction : Par ex. RPC, Partage de mémoire, synchronisation

Composantes
• Perspective orientée objet
Un module (package, librairie)
Un groupe de classes
Encapsulation des fonctions
• Perspective procédurale
Un groupe de fonctions et de structures de données
• Connecteurs
• La signature des composantes
• La définition des interfaces, des services offerts par une composante
• Les fonctions et les propriétés des composantes

• Satisfaire les besoins du propriétaire
• Assurer la longévité de la maison (revente, charpente, catastrophe)
• Planifier pour permettre les extensions possibles
• Faciliter l’entretien et le confort
• Contenir les coûts
• Guider les travailleurs qui vont la construire

• Assurer la stabilité et la robustesse du système
• Permettre une maintenance relativement facile
• Permettre les évolutions futures
• Contenir les coûts
• Minimiser les complications
• Guider les programmeurs dans leurs efforts de développement

Des questions importantes auxquelles l’architecture doit répondre
Quelle est la nature des composantes ?
• Des processus, des programmes ou les deux ?
• Comment sont organisées les composantes ?
• Comment sont déployées les composantes ?
Quelles sont les responsabilités des composantes ?
• Que font les composantes ?
• Quelle est leur rôle dans le système ?

Comment les composantes communiquent-elles ?
• Messages, Appels, Synchronisation, Partage, Négociation, … ?
• Quels sont les mécanismes de communication utilisés?
• Quelles informations sont transmises par ces mécanismes?
Comment sont organisés les composantes ?
• Topologie

• Indique le partitionnement d’un système en sous parties
• Spécifie ce qui fait fonctionner les parties ensemble
• Donne une vision globale (i.e. de haut niveau et non détaillée) de la conception du système
Module 3
Module 2
Module 1

• Communique une vision du logiciel qui est partagée et comprise par les différents intervenants du projet
• Indique les moyens retenus pour atteindre les objectifs en terme de qualité
• Communique aux développeurs ce qui doit être concrétisé

• L’architecture est une forme de conception
• Les conceptions ne sont pas toutes architecturales
• Plusieurs détails de bas niveau ne sont pas spécifiés dans une architecture
Ex. Le choix d’une structure de données
Ex. Le choix d’un algorithme
• L’architecture ne définit pas une implémentation du logiciel
• Mise plutôt sur la structure et moins sur le domaine d’application
• Les fonctionnalités sont orthogonales à la structure

Termes fréquemment utilisés pour décrire
• Les structures utilisées pour la conception de logiciel
• Des recettes éprouvées et reconnues des praticiens
• Des exemples de bonnes pratiques
ü Par opposition aux mauvaises pratiques (antipatterns)
• Des trucs et astuces
• Des spécificités utiles de certaines technologies

Styles (macro patterns)
Structures de haut niveau pour décrire un logiciel d’un point de vue global
Ex. Modèle par couche (layered), MVC, …

Patrons (micro patterns)
Solutions abstraites applicables à différents contextes mais qui offrent les
mêmes avantages chaque fois. Correspond aux Design Pattern

Idiomes
Décrit de bonnes pratiques liées à un formalisme de programmation à un
langage en particulier.

D’après Christopher Alexander :
« Chaque modèle décrit un problème qui se manifeste constamment
dans notre environnement, et donc décrit le cœur de la solution de ce
problème, d’une façon telle que l’on peut réutiliser cette solution des
millions de fois, sans jamais le faire deux fois de la même manière »

Les patrons de conception sont des solutions classiques à des problèmes récurrents
de la conception de logiciels. Ce sont des sortes de plans ou de schémas que l’on peut
personnaliser afin de résoudre un problème récurrent dans notre code.

Un design patterns est composé de quatre éléments essentiels :
• Un nom qui permet de décrire en un ou deux mots un problème de
conception, ses solutions et leurs conséquences;
• Un problème qui décrit les situations où le modèle s’applique;
• Une solution qui décrit les éléments qui constituent la conception, les
relations entre eux, leurs parts dans la solution, leur coopération;
• Les conséquences qui sont les effets résultants de la mise en œuvre du
modèle et les variantes de compromis que celle-ci entraine.

Les conséquences sont liées à:
• Des compromis d’encombrement mémoire et de rapidité d’éxecution;
• Des aspects du langage et du codage;
• La flexibilité du système;
• L’extensibilité du système;
• La portabilité du système.

§ Nom du patron :
Il contient succinctement son principe;

§ Intention:
Que fait effectivement le modèle?

Quelle est sa raison d’être?
Quel problème résout-il?
§ Alias :
Autres noms reconnus du modèle;
§ Motivation :
Scénario qui illustre un cas de conception et qui montre comment la structure de classe et
d’objet du modèle contribuent à la solution de ce cas.

§ Indications d’utilisation :
Quels sont les cas qui justifient l’utilisation du modèle?
Quelles situations de conception peu satisfaisantes peuvent tirer avantage de l’utilisation du modèle ?
Comment reconnaitre ces situations?
§ Structure :
Représentation graphique des classes du modèle basée sur UML;
§ Constituants :
Classes et objets intervenant dans le modèle avec leurs responsabilités;

§ Collaborations :
Comment les constituants collaborent-ils pour assumer leurs responsabilités ?
§ Conséquences :
Comment le modèle de conception assument-ils ses objectifs
Quels compromis implique son utilisation et quel en est l’impact ?
Quelles parties de la structure d’un système permet-il de modifier ?
§ Implémentation :
De quels pièges astuces, ou techniques faut-il être averti lors de l’implémentation du modèle.

§ Exemples de code :
Extraits de programme illustrant qu’il convient de développer le modèle dans un langage donné?
§ Utilisations remarquables :
Exemples de modèles appartenant à des systèmes existants
§ Modèle apparentés:
§ Quels modèles de conception sont en relation étroite avec celui traité ?
§ Quelles sont les différences importantes ?
§ Avec quel autre modèle peut-il être employé ?

§ Concepts importants qui reviennent dans les patrons plus complexes
§ Vocabulaire de base
§ Certains sont partie intégrante de plusieurs langages de programmation orientée objet

§ Interface & Marker Interface
Encapsuler la signature d’un service offert par plusieurs classes
Marquer une classe d’un signe distinctif
§ Abstract Parent Class
Permettre différentes définitions de services pour des classes similaires
§ Private Methods
Limiter l’accès au comportement interne d’une classe

§ Accessor Methods
Contrôler l’accès aux propriétés des instances d’une classe
§ Immutable Objet
S’assurer que l’état d’une instance ne peut être modifiée
§ Constant Data Manager
Regrouper dans une classe centralisée les constantes d’une application

INTERFACE
§ Problème
§ Un même service peut être offert par plusieurs classes
§ On ne veut pas lier le client à un classe précise
§ Solution
§ Définir une interface spécifiant le service offert (Abstraction)
§ Les classes serveur implantent cette abstraction
§ Les clients réfèrent au type de l’interface et travaillent avec une instance d’une classe
implantant cette interface
§ Conséquences
§ Améliore la maintenabilité
§ Améliore l’adaptabilité
§ Si sur-utilisation alors on a une perte de performance

INTERFACE
Exemple :
Algorithme de recherche dans une liste
§ Plusieurs algorithmes possibles (Séquentielle, Binaire)
§ L’interface IRecherche définit la signature du service
§ Le service est implanté par les classes RechercheSequentielle et RechercheBinaire
§ Le client travaille avec une référence de type IRecherche

MARKER INTERFACE
§ Dans certains cas, il est utile de pouvoir marquer une classe d’un signe distinctif indiquant
certaines caractéristiques de la classe.
§ L’interface de marquage ne définit aucune méthode
§ Peut également s’exprimer par d’autres mécanismes selon le langage
ü Exemple :
Annotations, Propriétés
ü Exemple :
En Java l’interface cloneable indique que la classe supporte totalement la méthode clone
ü Véritable clonage

Problème
Un service implanté par différentes classes diffère sur certaines parties
Solution
• Définir une classe abstraite qui sert de base
Parties communes Méthodes concrètes
Parties variables Méthodes abstraites
• Redéfinir les parties variables dans des sous-classes (spécialisation)

ABSTRACT PARENT CLASS
§ Une classe abstraite ne peut directement être instanciée
§ Les méthodes non abstraites du parent sont héritées
Partie invariable redondante entre les classes

Note :
En Java, l’héritage multiple n’est pas permis.
Donc, l’utilisation des interfaces est privilégié.
Cependant, apporte de la redondance dans l’implantation des méthodes communes.

§ Permet différentes définitions de services pour des classes similaires
Spécialisation
§ Classe abstraite
Classe qui contient une ou plusieurs méthodes abstraites

Peut contenir des méthodes concrètes (implantées) qui sont la partie invariable de la classe
§ Méthode abstraite
Méthode déclarée mais qui n’est pas implantée

Les méthodes abstraites représentent la partie variable de la classe abstraite

§ Plusieurs sous-classes peuvent être définies pour implanter des comportements différents
pour les méthodes abstraites
§ Une classe qui hérite d’une classe abstraite doit implanter toutes les méthodes abstraites
de la classe parent
§ Sinon, la sous-classe devient également abstraite

Exemple : Comptes bancaires
Compte épargne
- Intérêt = 5 % par mois
- Frais de transaction = 0.50$
Compte chèque
- Intérêt = 1 % par mois
- Frais de transaction = 0.15$ si solde < 1000, sinon =0 $

Exemple : Comptes bancaires
§ Partie commune
Obtenir le solde – double getSolde()
Déposer un montant – void deposer(double montant)
Retirer un montant – void retirer(double montant)
§ Partie variable
Calculer les intérêts sur le solde – double
calculerInterets()
Calculer les frais de transaction – double
calculerFraisTransaction()
§ Les comptes spécialisés doivent implanter les méthodes de la partie variable.

PRIVATE METHOD
Permet de définir des méthodes utilitaires qui ne sont pas visibles aux clients
class Base: class Derived(Base):
def __init__(self):
# Declaring public method
def fun(self): # Calling constructor of
print("Public method") # Base class
Base.__init__(self)
# Declaring private method
def __fun(self): def call_public(self):
print("Private method")
# Calling public method of base class
print("\nInside derived class")
self.fun()
def call_private(self):
# Calling private method of base class

self.__fun()

ACCESSOR METHOD
§ L’état d’un objet est défini par la valeur de ses différentes variables d’instance
§ Variables d’instance publiques
§ Variables d’instance privées
§ Les Accessor Methods permettent de contrôler l’accès aux variables d’instance
§ Les Accessor Methods permettent de contrôler les changements d’état de l’objet
§ État sources vers État cible

ACCESSOR METHOD
Problème
§ On veut contrôler l’accès aux variables d’instance de l’objet
§ On veut contrôler les changements d’état de l’objet
§ On veut limiter les problèmes de maintenance
Solution
§ Rendre toutes les variables d’instance privées
§ Définir des méthodes pour l’accès aux valeurs des variables d’instance
§ Définir des méthodes de modification de l’état et des valeurs des variables d’instance
§ Utiliser les méthodes d’accès et de modification même à l’interne de la classe

ACCESSOR METHOD
§ Conséquences
§ Améliore la maintenabilité
§ Limite le nombre de modifications si un attribut est modifié
§ Permet le changement de représentation de l’état interne de la classe
§ Cache si l’attribut est directe ou dérivé

IMMUTABLE OBJECT
§ Permet de s’assurer que l’état d’une instance ne peut être modifié
§ S’applique aux classes qui ne présentent pas de comportement spécifique, mais agissent
comme conteneurs de données
§ Problème
§ L’état d’une instance ne doit pas être modifié durant toute sa durée de vie

MUTABLE vs IMMUTABILITY
Exemple : Liste vs Tuple Python

Modèles de conception complexe
CREATEUR COMPORTEMENTAL
STRUCTUREL

ROLE
CREATEUR STRUCTUREL COMPORTEMENTAL
Interprète
CLASSE Fabrication Adaptateur
Patron de méthode
Fabrique abstraite Adaptateur Chaine de responsabilité
Monteur Pont Commande
Prototype Composite Itérateur
Singleton Décorateur Médiateur
OBJET Façade Mémento
Poids Mouche Observateur
Procuration Etat
Stratégie
Visiteur

Les patrons de création fournissent
des mécanismes de création
d’objets qui augmentent la flexibilité
et la réutilisation du code.

Les patrons de création fournissent des mécanismes de création d’objets qui
augmentent la flexibilité et la réutilisation du code.





Les patrons structurels vous guident
pour assembler des objets et des
classes en de plus grandes
structures tout en gardant celles-ci
flexibles et efficaces.

Les patrons structurels vous guident pour assembler des objets et des classes
en de plus grandes structures tout en gardant celles-ci flexibles et efficaces.







Les patrons comportementaux
s’occupent des algorithmes et de
la répartition des responsabilités
entre les objets.

Les patrons comportementaux s’occupent des algorithmes et de la répartition
des responsabilités entre les objets.










PROBLEME
Imaginez que vous êtes en train de créer une application de gestion
logistique. La première version de votre application ne propose que le
transport par camion, la majeure partie de votre code est donc située dans
la classe Camion. Au bout d’un certain temps, votre application devient
populaire et de nombreuses entreprises de transport maritime vous
demandent tous les jours d’ajouter la gestion de la logistique maritime dans
l’application.

PROBLEME

SOLUTION
Le patron de conception fabrique vous propose de remplacer les appels
directs au constructeur de l’objet (à l’aide de l’opérateur new ) en appelant
une méthode fabrique spéciale.
Pas d’inquiétude, les objets sont toujours créés avec l’opérateur new, mais
l’appel se fait à l’intérieur de la méthode fabrique.
Les objets qu’elle retourne sont souvent appelés produits.

À première vue, cette modification peut sembler inutile : nous avons juste
déplacé l’appel du constructeur dans une autre partie du programme.
Mais maintenant, vous pouvez redéfinir la méthode fabrique dans la sous-classe
et changer la classe des produits créés par la méthode.
Il y a tout de même une petite limitation : les sous-classes peuvent retourner des
produits différents seulement si les produits ont une classe de base ou une
interface commune. De plus, cette interface doit être le type retourné par la
méthode fabrique de la classe de base.

Par exemple, les classes Camion et Bateau doivent toutes les deux
implémenter l’interface Transport, qui déclare une méthode délivrer .
Chaque classe implémente cette méthode à sa façon :
Les camions délivrent par la route et les bateaux délivrent par la mer.
La méthode fabrique de la classe LogistiqueRoute retourne des camions, alors
que celle de la classe LogistiqueMer retourne des bateaux.

Le code qui appelle la méthode
fabrique (souvent appelé le code
client) ne fait pas la distinction entre
les différents produits concrets
retournés par les sous-classes, il les
considère tous comme des
Transports abstraits.
Le client sait que tous les objets
transportés sont censés avoir une
méthode livrer, mais son
fonctionnement lui importe peu.

AVANTAGES
• Vous désolidarisez le Créateur des produits concrets.
• Principe de responsabilité unique :
Vous pouvez déplacer tout le code de création des produits au même endroit, permettant
ainsi une meilleure maintenabilité.
• Principe ouvert/fermé :
Vous pouvez ajouter de nouveaux types de produits dans le programme sans
endommager l’existant.
INCONVENIENTS
• Le code peut devenir plus complexe puisque vous devez introduire de
nombreuses sous-classes pour la mise en place du patron. La condition optimale
d’intégration du patron dans du code existant se présente lorsque vous avez déjà
une hiérarchie existante de classes de création.

PROBLEME
Imaginez que vous travaillez sur une librairie qui permet aux programmes
d’envoyer des notifications à leurs utilisateurs lorsque des événements
importants se produisent. La version initiale de la librairie était basée sur la
classe Notificateur qui n’avait que quelques attributs, un constructeur et une
unique méthode envoyer. La méthode pouvait prendre un message en
paramètre et l’envoyait à une liste d’emails à l’aide du constructeur du
notificateur. Une application externe qui jouait le rôle du client devait créer et
configurer l’objet notificateur une première fois, puis l’utiliser lorsqu’un
événement important se produisait.

PROBLEME

PROBLEME
Au bout d’un certain temps, vous vous rendez compte que les utilisateurs de la
librairie veulent plus que les notifications qu’ils reçoivent sur leur boîte mail. Ils
sont nombreux à vouloir recevoir des SMS lorsque leurs applications
rencontrent des problèmes critiques. Certains voudraient être prévenus sur
Facebook et les employés de certaines entreprises adoreraient recevoir des
notifications Slack.

PROBLEME
Cela n’a pas l’air bien difficile !
Vous avez étendu la classe Notificateur et ajouté des méthodes de notification
supplémentaires dans de nouvelles sous classes. Le client devait instancier la
classe de notification désirée et utiliser cette instance pour toutes les autres
notifications, mais quelqu’un a remis en question ce fonctionnement en vous
affirmant qu’il aimerait bien utiliser plusieurs types de notifications
simultanément. Si votre maison prend feu, vous avez très certainement envie
d’en être informé par tous les moyens possibles.
Vous avez tenté de résoudre ce problème en créant des sous - classes
spéciales qui combinent plusieurs méthodes de notification dans une seule
classe. Mais il s’avère que cette approche va non seulement gonfler le code de
la librairie, mais aussi celui du client.

SOLUTION
Le décorateur est également appelé « emballeur » ou « empaqueteur ».
Ces surnoms révèlent l’idée générale derrière le concept.
Un emballeur est un objet qui peut être lié par un objet cible.
L’emballeur possède le même ensemble de méthodes que la cible et lui
délègue toutes les demandes qu’il reçoit.
Il peut exécuter un traitement et modifier le résultat avant ou après avoir
envoyé sa demande à la cible.

SOLUTION
À quel moment un emballeur devient-il réellement un décorateur ?
Comme je l’ai déjà dit, un emballeur implémente la même interface que
l’objet emballé. Du point de vue du client, ces objets sont identiques.
L’attribut de la référence de l’emballeur doit pouvoir accueillir n’importe quel
objet qui implémente cette interface. Vous pouvez ainsi utiliser plusieurs
emballeurs sur un seul objet et lui attribuer les comportements de plusieurs
emballeurs en même temps.

Le code client doit emballer
un objet basique Notificateur
pour le transformer en un
ensemble de décorateurs
adapté aux préférences du
client. Les objets qui en
résultent sont empilés

Porter des vêtements est un bon
exemple d’utilisation. Si vous avez froid,
vous vous enroulez dans un pull. Si
vous avez encore froid, vous pouvez
porter un blouson par-dessus. S’il pleut,
vous enfilez un imperméable.
Tous ces vêtements « étendent » votre
comportement de base mais ne font pas
partie de vous, et vous pouvez
facilement enlever un vêtement lorsque
vous n’en avez plus besoin

1. Le Composant déclare l’interface commune pour les décorateurs
et les objets décorés.
2. Le Composant Concret est une classe contenant des objets qui
vont être emballés. Il définit le comportement par défaut qui peut être
modifié par les décorateurs.
3. Le Décorateur de Base possède un attribut pour référencer un
objet emballé. L’attribut doit être déclaré avec le type de l’interface du
composant afin de contenir à la fois les composants concrets et les
décorateurs. Le décorateur de base délègue toutes les opérations à
l’objet emballé.
4. Les Décorateurs Concrets définissent des comportements
supplémentaires qui peuvent être ajoutés dynamiquement aux
composants. Les décorateurs concrets redéfinissent les méthodes du
décorateur de base et exécutent leur traitement avant ou après
l’appel à la méthode du parent.
5. Le Client peut emballer les composants dans plusieurs couches de
décorateurs, tant qu’il manipule les objets à l’aide de l’interface du
composant

AVANTAGES
• Vous pouvez étendre le comportement d’un objet sans avoir recours à la création
d’une nouvelle sous-classe.
• Vous pouvez ajouter ou retirer dynamiquement des responsabilités à un objet au
moment de l’exécution.
• Vous pouvez combiner plusieurs comportements en emballant un objet dans
plusieurs décorateurs.
• Principe de responsabilité unique : Vous pouvez découper une classe monolithique
qui implémente plusieurs comportements différents en plusieurs petits morceaux
INCONVENIENTS
• Retirer un emballeur spécifique de la pile n’est pas chose aisée.
• Il n’est pas non plus aisé de mettre en place un décorateur dont le comportement
ne varie pas en fonction de sa position dans la pile.
• Le code de configuration initial des couches peut avoir l’air assez moche.

PROBLEME
Les collections ne servent que de conteneur pour un groupe d’objets, mais elles
demeurent l’un des types de données les plus utilisés en programmation.

PROBLEME
La majorité des collections stockent leurs éléments dans de simples listes, mais
certaines d’entre elles sont basées sur les piles, les arbres, les graphes ou
d’autres structures complexes de données. Quelle que soit sa structure, une
collection doit fournir un moyen d’accéder à ses éléments pour permettre au code
de les utiliser. Elle doit donner la possibilité de parcourir tous ses éléments sans
passer plusieurs fois par les mêmes. Vous pouvez juste lancer une boucle sur
tous les éléments. Mais comment faites-vous pour parcourir séquentiellement les
éléments d’une structure complexe de données comme un arbre ?

PROBLEME

SOLUTION
Le but du patron de
conception itérateur est
d’extraire le comportement
qui permet de parcourir une
collection et de le mettre
dans un objet que l’on
nomme itérateur.

SOLUTION
En plus d’implémenter l’algorithme de parcours, un objet itérateur encapsule tous
les détails comme la position actuelle et le nombre d’éléments restants avant
d’atteindre la fin. Grâce à cela, plusieurs itérateurs peuvent parcourir une même
collection simultanément et indépendamment les uns des autres. En général, les
itérateurs fournissent une méthode principale pour récupérer les éléments d’une
collection. Le client peut appeler la méthode en continu jusqu’à ce qu’elle ne
retourne plus rien, ce qui signifie que l’itérateur a parcouru tous les éléments.

SOLUTION

AVANTAGES
• Principe de responsabilité unique. Vous allez nettoyer le code client et les
collections en déplaçant les algorithmes de parcours — souvent très lourds —
dans des classes séparées.
• Principe ouvert/fermé. Vous pouvez implémenter de nouveaux types de collections
et d’itérateurs et les utiliser avec le code existant sans rien endommager.
• Vous pouvez parcourir une même collection avec plusieurs itérateurs
simultanément, car chacun possède son propre état d’itération.
• Pour cette même raison, vous pouvez arrêter une itération et la reprendre quand
vous le souhaitez.
INCONVENIENTS
• L’utilisation de ce patron est exagérée si votre application ne se sert que de
collections simples.
• Les itérateurs sont parfois moins efficaces que certaines collections spécialisées.

PROBLEME
Un beau jour, vous avez décidé de créer une application de navigation pour les
voyageurs occasionnels. Vous l’avez développé avec une superbe carte comme
fonctionnalité principale, qui aide les utilisateurs à s’orienter rapidement dans
n’importe quelle ville. La fonctionnalité la plus demandée était la planification
d’itinéraire. Un utilisateur devrait pouvoir entrer une adresse et le chemin le plus
rapide pour arriver à destination s’afficherait sur la carte.

PROBLEME
La première version de l’application ne pouvait tracer des itinéraires que sur les
routes. Les automobilistes étaient comblés. Mais apparemment, certaines
personnes préfèrent utiliser d’autres moyens de locomotion pendant leurs
vacances. Vous avez ajouté la possibilité de créer des trajets à pied dans la
version suivante. Juste après cela, vous avez ajouté la possibilité d’utiliser les
transports en commun dans les itinéraires. Mais tout ceci n’était que le début.
Vous avez continué en adaptant l’application pour les cyclistes, et plus tard,
ajouté la possibilité de construire les itinéraires en passant par les attractions
touristiques de la ville.

PROBLEME
L’application a beau avoir très bien marché d’un point de vue financier, vous vous
êtes arraché les cheveux sur le côté technique. Chaque fois que vous ajoutiez un
nouvel algorithme pour tracer les itinéraires, la classe principale Navigateur
doublait de taille. À un moment donné, la bête n’était plus possible à maintenir.
Que ce soit pour corriger un petit problème ou pour ajuster les scores des rues,
la moindre touche apportée aux algorithmes impactait la totalité de la classe,
augmentant les chances de créer des bugs dans du code qui fonctionnait très
bien.

SOLUTION
Le patron de conception stratégie vous propose de prendre une classe dotée
d’un comportement spécifique mais qui l’exécute de différentes façons, et de
décomposer ses algorithmes en classes séparées appelées stratégies.
La classe originale (le contexte) doit avoir un attribut qui garde une référence
vers une des stratégies. Plutôt que de s’occuper de la tâche, le contexte la
délègue à l’objet stratégie associé.

SOLUTION
Dans notre application de
navigation, chaque algorithme
d’itinéraire peut être extrait de
sa propre classe avec une
seule méthode buildRoute().
La méthode accepte une
origine et une destination, puis
retourne une liste de points de
passage.

AVANTAGES
• Vous pouvez permuter l’algorithme utilisé à l’intérieur d’un objet à l’exécution
• Vous pouvez séparer les détails de l’implémentation d’un algorithme et le code qui l’utilise.
• Vous pouvez remplacer l’héritage par la composition.
• Principe ouvert/fermé : Vous pouvez ajouter de nouvelles stratégies sans avoir à modifier le
contexte
INCONVENIENTS
• Si vous n’avez que quelques algorithmes qui ne varient pas beaucoup, nul besoin de rendre
votre programme plus compliqué avec les nouvelles classes et interfaces qui accompagnent la
mise en place du patron.
• Les clients doivent pouvoir comparer les différentes stratégies et choisir la bonne.
• De nombreux langages de programmation modernes gèrent les types fonctionnels et vous
permettent d’implémenter différentes versions d’un algorithme à l’intérieur d’un ensemble de
fonctions anonymes. Vous pouvez ensuite utiliser ces fonctions exactement comme vous le
feriez pour des objets stratégie, sans encombrer votre code avec des classes et interfaces
supplémentaires.

Qu’est ce que le refactoring de code
PARTIE 6 Clean Code

Pratique
d’ingénierie Test
Packaging

Le ré usinage de code est l'opération consistant à retravailler le code source d'un programme
informatique – sans toutefois y ajouter des fonctionnalités ni en corriger les bogues.
Code re factoring :
Réécrire le code pour en changer la structure interne tout en gardant les fonctionnalités externes
• Permet de réduire la charge de travail dans le long terme
• Facilite la maintenance du code
• Réutilise ton code
• Permet d’améliorer tes compétences en développement

Le re factoring a pour objectif principal de lutter contre la dette technique.
Il transforme un désordre en code propre et en conception simple.
Les caractéristiques d’un code propre :
• Un code propre est évident pour les autres programmeurs.
On ne parlera pas d'algorithmes super sophistiqués. Une mauvaise dénomination des variables, des classes
et des méthodes gonflées, des nombres magiques... tout cela rend le code bâclé.
• Le code propre ne contient pas de duplication.
Chaque fois que vous devez apporter une modification à un code dupliqué, vous devez vous rappeler de faire
la même modification à chaque instance. Cela augmente la charge cognitive et ralentit les progrès.
• Le code propre contient un nombre minimal de classes et d'autres pièces mobiles.
Moins de code, c'est moins de choses à garder en tête. Moins de code, c'est moins de maintenance. Moins de
code, c'est moins de bogues. Le code est la responsabilité, soyez bref et simple.
• Le code propre passe tous les tests.
Vous savez que votre code est sale lorsque seulement 95% de vos tests réussissent. Vous savez que vous
êtes foutu lorsque vous testez la couverture est de 0%.
• Le code propre est plus facile et moins coûteux à entretenir!

Avantages Inconvénients
• Une meilleure compréhension facilite la maintenance et les • Un manque de précision lors du refactoring peut implémenter
possibilités d’extension du logiciel. de nouveaux bugs et de nouvelles erreurs dans le code.
• La restructuration du code source peut se faire sans modifier le • Il n’existe pas de définition précise de ce qu’est un
fonctionnement. « code propre ».
• Bien souvent, le client ne voit pas la différence lorsque le

• Une meilleure lisibilité accroît la compréhension du code pour les
code est amélioré, car le fonctionnement reste identique : le
autres programmeurs.
gain n’est donc pas évident.
• Dans de grandes équipes travaillant sur le réusinage du

• Retirer les redondances et les doublons améliore l’efficacité du
code, la coordination peut exiger un temps étonnamment
code.
long.
• Des méthodes indépendantes évitent que les modifications

•
locales aient un impact sur une autre partie du code.
• Un code propre, avec des méthodes et des classes courtes et
•
indépendantes, se caractérise par une plus grande facilité de test.

Règle de trois
1.Lorsque vous faites quelque chose pour la première fois, faites-le simplement.
2.Lorsque vous faites quelque chose de similaire pour la deuxième fois, répéter, mais faites la même chose
3.Lorsque vous faites quelque chose pour la troisième fois, commencez à refactoriser.

Lors de l'ajout d'une fonctionnalité
• La refactorisation vous aide à comprendre le code des autres. Si vous devez gérer le code sale de
quelqu'un d'autre, essayez d'abord de le refactoriser. Le code propre est beaucoup plus facile à
comprendre. Vous l'améliorerez non seulement pour vous-même mais aussi pour ceux qui l'utiliseront
après vous.
• La refactorisation facilite l'ajout de nouvelles fonctionnalités. Il est beaucoup plus facile d'apporter des
modifications au code propre.

Lors de la correction d'un bug
Les bogues du code se comportent exactement comme ceux de la vie réelle :
Ils vivent dans les endroits les plus sombres et les plus sales du code.
Nettoyez votre code et les erreurs se découvriront pratiquement d'elles-mêmes.
Les gestionnaires apprécient le re factoring proactif car il élimine le besoin de tâches de re factoring
spéciales plus tard. Les patrons heureux font les programmeurs heureux!

Lors d'une révision de code
La révision du code peut être la dernière chance de ranger le code avant qu'il ne devienne disponible
au public. Il est préférable d'effectuer de telles critiques en binôme avec un auteur.
De cette façon, vous pouvez résoudre rapidement des problèmes simples et évaluer le temps
nécessaire pour résoudre les problèmes les plus difficiles

Les sources d’erreurs que l’on peut corriger lors d’un ré usinage du code peuvent être :
• Les méthodes brouillonnes ou trop longues
• Les doublons (redondances)
• Les listes de paramètres trop longues
• Les classes avec un trop grand nombre de fonctions
• Les classes avec trop peu de fonctions
• Les codes trop généraux avec des cas spécifiques
• Les Middle Men

Les sources d’erreurs que l’on peut corriger lors d’un ré usinage du code sont, entre autres :
• Les méthodes brouillonnes ou trop longues : les lignes et blocs de commande sont tellement longs
que les personnes extérieures ne peuvent pas comprendre la logique interne du logiciel.

• Les doublons (redondances) : un code superflu contient souvent des redondances qui, à l’étape de la
maintenance, doivent être modifiées séparément à chaque entrée. Elles génèrent donc du temps de
travail et des coûts supplémentaires.

• Les listes de paramètres trop longues : au lieu de répondre directement à une méthode, les objets
voient leurs attributs transmis à une liste de paramètres.

• Les classes avec un trop grand nombre de fonctions : les classes comprenant de trop nombreuses
fonctions définies comme méthodes, également connues sous le nom d’objet dieu, qui rendent presque
impossible toute modification du logiciel.

• Les classes avec trop peu de fonctions : les classes comprenant trop peu de fonctions définies
comme méthodes, qui sont superflues.

• Les codes trop généraux avec des cas spécifiques : les fonctions avec des cas particuliers trop
spécifiques, qui ne se produisent que rarement ou jamais et compliquent l’ajout de compléments
nécessaires.

• Les Middle Men : une classe distincte fait office d’intermédiaire entre les méthodes et différentes
classes, alors que les méthodes pourraient appeler directement une classe.

Le Clean Code n’est pas un ensemble de règles strictes mais désigne plutôt une série de principes pour
produire un code compréhensible de façon intuitive et facile à modifier.
Compréhensible signifie un code immédiatement intelligible par n’importe quel développeur qualifié.
Les caractéristiques suivantes augmentent la lisibilité du Clean Code :
• Le processus d’exécution de l’ensemble de l’application est logique et structuré de façon simple.
• Le rapport entre les différentes parties du code est transparent.
• La tâche ou le rôle de chaque classe, fonction, méthode et variable est immédiatement
compréhensible.

Il existe de très nombreuses techniques concrètes pour produire du clean code
Les travaux foisonnants de Martin Fowler et Kent Beck en proposent un aperçu complet :
« Refactoring : Improving the Design of Existing Code »
Du coup nous avons :
- Compilation de méthodes
- Déplacement d’entités entre objets
- Organisation des données
- Simplification des expressions conditionnelles
- Simplification des appels de méthodes
- Gestion des généralisations

- Compilation de méthodes
Proposition 1 / 9 : Technique de la méthode d’extraction
• Problème : vous avez un • Solution : déplacez ce code vers une nouvelle
fragment de code qui peut être méthode (ou fonction) distincte et remplacez
regroupé. l'ancien code par un appel à la méthode.
def printOwing(self):
self.printBanner()
# print details print("name:",
self.name) print("amount:",
self.getOutstanding())

• En informatique, un test désigne une procédure de
vérification partielle d'un système. Son objectif principal
est d'identifier un nombre maximum de comportements
problématiques du logiciel. Il permet ainsi, dès lors que
les problèmes identifiés seront corrigés, d'en augmenter
la qualité.
• D'une manière plus générale, le test désigne toutes les
activités qui consistent à rechercher des informations
quant à la qualité du système afin de permettre la prise
de décisions.
• Un test ressemble à une expérience scientifique, il
examine une hypothèse exprimée en fonction de trois
éléments : les données en entrée, l'objet à tester et les
observations attendues. Cet examen est effectué sous
conditions contrôlées pour pouvoir tirer des conclusions
dans l'idéal, être reproduit.

• La problématique des tests est souvent considérée comme secondaire et négligée par les
développeurs. C'est une erreur : lorsqu'on livre une application et qu'elle est placée en production
(offerte à ses utilisateurs), il est essentiel d'avoir un maximum de garanties sur son bon fonctionnement
afin d'éviter au maximum de coûteuses mauvaises surprises.
• Le test d'une application peut être manuel. Dans ce cas, une personne effectue sur l'application une
suite d'opérations prévue à l'avance (navigation, connexion, envoi d'informations...) pour vérifier qu'elle
possède bien le comportement attendu. C'est un processus coûteux en temps et sujet aux erreurs
(oublis, négligences, etc.).
• En complément de ces tests manuels, on a tout intérêt à intégrer à un projet logiciel des tests
automatisés qui pourront être lancés aussi souvent que nécessaire. Ceci est d'autant plus vrai pour les
méthodologies agiles basées sur un développement itératif et des livraisons fréquentes, ou bien
lorsque l'on met en place une intégration continue.
TEST
UNITAIRE SYSTÈME
(VALIDATION)
INTEGRATION

Test unitaire :
Vérifie que chaque module fonctionne indépendamment des autres.
Le test unitaire offre les avantages suivants :
• Il est facile à écrire. Dédié à une partie très réduite du code, le test unitaire ne nécessite le plus
souvent qu'un contexte minimal, voire pas de contexte du tout.
• Il offre une granularité́ de test très fine et permet de valider exhaustivement le comportement de la
partie du code testée (cas dégrades, saisie d'informations erronées...).
• Son exécution est rapide, ce qui permet de le lancer très fréquemment (idéalement à chaque
modification du code testé).
• Il rassemble les cas d'utilisation possibles d'une portion d'un projet et représente donc une véritable
documentation sur la manière de manipuler le code testé.

Test d’intégration :
Vérifie que tous les modules testés individuellement fonctionnent bien ensemble
Dans un projet informatique, l'intégration est de fait d'assembler plusieurs composants (ou modules)
élémentaires en un composant de plus haut niveau. Un test d'intégration valide les résultats des
interactions entre plusieurs composants et permet de vérifier que leur assemblage s'est produit sans
défaut. Il peut être manuel ou automatisé. Un nombre croissant de projets logiciels mettent en place un
processus d'intégration continue. Cela consiste à vérifier que chaque modification ne produit pas de
régression dans l'application développée. L'intégration continue est nécessairement liée à une batterie de
tests qui se déclenchent automatiquement lorsque des modifications sont intégrées au code du projet.

Tests systèmes :
Vérifie que le système fonctionne correctement dans les conditions réelles d’utilisation
Ces tests sont réalisés lors de la recette (validation) par un client d'un projet livré par l'un de ses
fournisseurs. Souvent écrits par le client lui-même, ils portent sur l'ensemble du logiciel et permettent de
vérifier son comportement global en situation. De par leur spectre large et leur complexité, les tests de
validation sont le plus souvent manuels. Les procédures à suivre sont regroupées dans un document
associé au projet, fréquemment nommé plan de validation

assert et AssertionError :
En Python un assert est une aide au débugage qui vérifie des conditions.
Si la condition n'est pas vérifiée alors une AssertionError est soulevée avec un message d'erreur.
Exemple :
Ecrire une fonction somme permettant d’additionner trois entiers.
Effectuer un test unitaire de la fonction somme
Pour le moment aucune erreur ne sera

retournée parce que la somme de 1,2 et 3
donne bien évidemment 6.
Maintenant fournissons 5 comme résultat.

Message indicateur en cas
d’erreur détectée lors du test

Essayons d’organiser la technique de test, pour cela au lieu de tester directement la fonction somme()
nous allons définir un scénario de test basé sur l’écriture d’une classe de test avec la librairie unittest
Créez un nouveau dossier de projet et, à l'intérieur, créez un nouveau dossier appelé notre_somme.
À l'intérieur du répertoire notre_somme, créez un fichier vide appelé __init__.py.
La création du fichier __init__.py signifie que le dossier notre_somme peut être importé en tant que
module à partir du répertoire parent.
projet/
│
└── notre_somme/
└── __init__.py

Ré - Implémentons notre fonction somme précédente
Cette fois ci on donne la possibilité à l’utilisateur de fournir une série de valeur en argument
Description de la fonction :
Cette implémentation crée une variable appelée total, une variable val vas itérer sur toutes les valeurs
de arg et les ajoute à total. Il renvoie ensuite le résultat une fois que l'itérable a été épuisé.

ECRITURE DE LA CLASSE DE TEST
- Ecrivons la classe de Test sur le fichier sunu_test.ipynb que nous allons greffer dans le dossier projet
projet/
│
├── notre_somme/
│ └── __init__.py
|
└── sunu_test.ipynb

Lorsque le test est concluant

Lorsque le test n’est pas concluant

Méthode Équivalent à
.assertEqual(a, b) a == b
.assertTrue(x) bool(x) is True
.assertFalse(x) bool(x) is False
.assertIs(a, b) a is b
.assertIsNone(x) x is None
.assertIn(a, b) a in b
.assertIsInstance(a, b) isinstance(a, b)

La dernière étape de l'écriture d'un test consiste à valider la sortie par rapport à une réponse connue.
C'est ce qu'on appelle une assertion.
Il existe quelques bonnes pratiques générales pour rédiger des assertions:
• Assurez-vous que les tests sont répétables et exécutez votre test plusieurs fois pour vous assurer qu'il
donne le même résultat à chaque fois
• Essayez d'affirmer des résultats qui se rapportent à vos données d'entrée, par exemple en vérifiant que
le résultat est la somme réelle des valeurs dans l'exemple
unittest est livré avec de nombreuses méthodes pour affirmer les valeurs, les types et l'existence de
variables. Voici quelques-unes des méthodes les plus couramment utilisées:

doctest est un module inclus dans la bibliothèque standard du langage de programmation
Python qui permet la génération facile de tests basés sur la sortie du shell d'interpréteur.
Grâce à doctest, le programmeur peut inclure des tests unitaires directement dans la
documentation des fonctions et méthodes !

Testons une fonction permettant de
calculer la factorielle d’un entier n

• La fonction testmod du module doctest est allée
chercher dans les docstring des fonctions du module
actuellement chargé, c’est-à-dire exples_doctest, tous
les exemples (reconnaissables à la présence des triples
chevrons " " "), et a vérifié que la fonction documentée
satisfait bien ces exemples.
• Dans le cas présent, une seule fonction dont la
documentation contient deux exemples (attempted=2) a
été testée, et il n’y a eu aucun échec (failed=0).

Modifiez le premier exemple, en mettant 9 à la place de 6.
********************************************************************** Signification du rapport d’erreur :

File "__main__", line 7, in __main__.fact
Failed example:
fact(3) • Tout d’abord que les tests ont échoué et qu’il y a
Expected: eu 1 échec (cf dernière ligne) et que cet échec
9
est dû à la fonction fact (cf avant dernière ligne).
Got:
6 • Ensuite que le test incriminé est celui
********************************************************************** concernant fact(3) pour lequel le test a obtenu
1 items had failures:
1 of 2 in __main__.fact
(Got) 6 en exécutant la fonction fact, alors qu’il
***Test Failed*** 1 failures. attendait (Expected) 9 selon l’exemple donné
TestResults(failed=1, attempted=2) par la documentation.

Pour retourner un rapport de succès utiliser la propriété verbose = True de testmod
Trying:
fact(5)
Expecting:
120
ok
1 items had no tests:
__main__
1 items passed all tests:
1 tests in __main__.fact
1 tests in 2 items.
1 passed and 0 failed.
Test passed.

§ Problemes ?
§ Supposons que vous ayez développé une très grande application qui comprend
de nombreux modules. Au fur et à mesure que le nombre de modules augmente, il
devient difficile de les suivre tous s'ils sont déposés au même endroit. C'est
particulièrement le cas s'ils ont des noms ou des fonctionnalités similaires. Vous
pourriez souhaiter un moyen de les regrouper et de les organiser.

Les packages permettent une structuration hiérarchique
de l'espace de noms des modules en utilisant la notation
par points. De la même manière que les modules aident
à éviter les collisions entre les noms de variables
globales, les packages aident à éviter les collisions
entre les noms de modules.

§ La création d'un package est assez simple, car elle utilise la structure de fichiers
hiérarchique inhérente au système d'exploitation. Considérez la disposition
suivante :
Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF Source: Lien 01/02/2021 453
Créer un package pkg avec deux modules mod1.py et mod2.py
Compte tenu de cette structure, si le répertoire pkg

réside dans un emplacement où il peut être trouvé (dans
l'un des répertoires contenus dans sys.path), vous
pouvez vous référer aux deux modules avec une notation
par points (pkg.mod1, pkg.mod2) et importez-les avec
la syntaxe

§ Que se passe-t-il avec les commandes suivantes:
§ import pkg.mod1, pkg.mod2 • import pkg

pkg
§ from pkg.mod1 import foo pkg.mod1
foo()
§ from pkg.mod2 import Bar as Qux

x = Qux()
x
§ from pkg import mod1

mod1.foo()

§ Si un fichier nommé __init__.py est présent dans un répertoire de package, il est
invoqué lors de l'importation du package ou d'un module du package.
§ Cela peut être utilisé pour l'exécution du code d'initialisation du package, comme
l'initialisation des données au niveau du package.
§ __init__.py peut également être utilisé pour effectuer l'importation automatique de

modules à partir d'un package.
§ Une grande partie de la documentation Python indique qu'un fichier __init__.py
doit être présent dans le répertoire du package lors de la création d'un package.
§ C'était autrefois vrai. Auparavant, la présence même de __init__.py signifiait à
Python qu'un package était en cours de définition. Le fichier pouvait contenir du
code d'initialisation ou même être vide, mais il devait être présent.

On peut utiliser une importation relative, où .. fait
référence au package au niveau supérieur.

Un paquet est généralement composé de :
§ Fichiers exécutables ou sources ;
§ Fichier de contrôle contenant le nom du logiciel, sa version, ses dépendances logicielles, etc. ;
§ Fichiers de configuration ;
§ Fichiers de documentation ;
§ Scripts de pré/post installation ;
§ Scripts de pré/post désinstallation ;
§ Une signature par clef asymétrique pour valider l'authenticité du paquet.
Un paquetage peut se trouver sous forme de source ou de binaires précompilés.

L’idée du scénario consistera à empaqueter une bibliothèque de fonction permettant de calculer
le périmètre des figures géométriques suivantes :
• triangle
• carré
• rectangle
• cercle

Etape 1 : Créons le module périmètre puis greffons le dans le répertoire :
packaging_essai/
└── src/
└── perimetre/
└── __init__.py

Etape 2 : Créons des fichiers de package
packaging_essai/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── setup.py
├── src/
│ └── perimetre/
│ └── __init__.py
└── tests/

- pyproject.toml
C’est le fichier qui indique aux outils de construction quel système vous utilisez et ce qui est requis
pour la construction. La valeur par défaut si ce fichier est manquant est de supposer un système de
construction setuptools classique, mais il vaut mieux être explicite.
[build-system]
requires = [
"setuptools>=42",
"wheel"
]
build-backend = "setuptools.build_meta"

- setup.cfg
C’est le fichier de configuration du setuptools.
Il indique à votre package (comme le nom et la version) ainsi que les fichiers de code à inclure.
Finalement, une grande partie de cette configuration pourra être déplacée vers pyproject.toml.
[metadata]
# replace with your username:
name = example-pkg-YOUR-USERNAME-HERE
version = 0.0.1
author = Example Author
author_email = [email protected]
description = A small example package
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
classifiers =
package_dir =

- README.md
Ce fichier doit contenir des informations pertinentes et précises sur votre projet :
• Description succincte de ce que fait le projet
• La licence ( https://choosealicence.com )
• Ceux qui ont contribué au projet
• Comment installer les codes du projets ? ( avec des exemples de code)
• Comment utiliser les codes du projet ? ( avec des exemples)
• Les bugs
• Les questions fréquemment posées
• Une table de matière éventuellement

- setup.py
Le fichier le plus important est celui setup.py qui existe à la racine du répertoire de votre projet. Pour
un exemple, consultez setup.py dans l' exemple de projet PyPA .
setup.py remplit deux fonctions principales:
• C'est le fichier dans lequel sont configurés divers aspects de votre projet. La principale
caractéristique de setup.py est qu'il contient une setup() fonction globale . Les arguments de mot-
clé de cette fonction indiquent comment les détails spécifiques de votre projet sont définis. Les
arguments les plus pertinents sont expliqués dans la section ci-dessous .
• C'est l'interface de ligne de commande pour exécuter diverses commandes liées aux tâches
d'empaquetage. Pour obtenir une liste des commandes disponibles, exécutez .python setup.py --
help-commands

- LICENCE
Il est important que chaque package téléchargé dans l'index des packages Python inclue une
licence. Cela indique aux utilisateurs qui installent votre package les conditions dans lesquelles ils
peuvent utiliser votre package. Pour obtenir de l'aide sur le choix d'une licence, consultez
https://choosealicense.com/ . Une fois que vous avez choisi une licence, ouvrez LICENSE et entrez
le texte de la licence.

§ https://packaging.python.org/tutorials/packaging-projects/
§ https://packaging.python.org/glossary/#term-Import-Package
§ https://docs.python.org/3/tutorial/modules.html#packages

Graphe et Arbre
PARTIE 6 Algorithmes gloutons

Programmatio
n Avancée Lamda expression
GesGon des données

Un graphe est un couple G = (V,E)
Avec :
• V (vertices) représente les sommets
• E (edges) représente les arêtes entre chaque sommet

Nous pouvons avoir différents types de graphes

Exemple : Le cas des réseaux sociaux
Soient cinq personnes (amis) qui sont reliées par des arêtes.
Lorsque le lien est important on le pondère à 2

Vocabulaire
Degré (d’un sommet) : nombre d’arête auxquelles appartiennent le sommet
Adjacence : Reliés par une arête
Chemin : Suite de sommet reliant deux sommets
Longueur : somme des poids d’un chemin
Cycle : Chemin entre un sommet et lui-même (sans repasser par la même arête)
Différence connexe / fortement connexe :
- Connexe : Graphe non orienté ; tout les sommets sont reliés par un chemin
- Fortement connexe : Graphe orienté ; tout les sommets sont reliés par un chemin
Composante connexe : Sous-graphe connexe d’un graphe général

Matrice d’adjacence
En théorie des graphes, en informatique, une matrice d'adjacence pour un graphe fini à n
sommets est une matrice de dimension n × n dont l'élément non diagonal aᵢⱼ est le nombre d'arêtes
liant le sommet i au sommet j. L'élément diagonal aᵢᵢ est le nombre de boucles au sommet i.

Liste d’adjacence
La liste d'adjacence d'un graphe non orienté, est la liste des voisins de chaque sommet.
Celle d'un graphe orienté est typiquement, pour chaque sommet, la liste de nœuds à la tête de
chaque arête ayant le sommet comme queue.
Liste d’adjacence du graphe :

[ [ B,C,D,E ] , [ A,C ] , [ A,B,D,F ] , [ A,C ] , [ A,F ] , [ C,E ]]

Liste d’adjacence
Les voisins de A

Liste d’adjacence
Les voisins de B

Liste d’adjacence
Les voisins de C

Liste d’adjacence
Les voisins de D

Liste d’adjacence
Les voisins de E

Liste d’adjacence
Les voisins de F

Implémentons un graphe :
• faire_graphe(sommets) pour construire un graphe (sans les arêtes) à partir de la
liste sommets de ses sommets.
• ajouter_arete(G, x, y) pour ajouter une arête entre les sommets x et y du graphe G.
• sommets(G) pour accéder à la liste des sommets du graphe G.
• voisins(G, x) pour accéder à la liste des voisins du sommet x du graphe G.
Une première implémentation se fait par une classe Graphe1 basée sur la représentation par une
matrice d'adjacence
Une seconde implémentation se fait par une classe Graphe2 basée sur les listes de successeurs
On termine en présentant comment passer d'une représentation à l'autre.

G = [
[1, 6, 7], # voisins de 0
[0, 2, 4, 5, 6], # voisins de 1
[1], # voisins de 2
[5, 6, 8], # voisins de 3
[1], # voisins de 4
[1, 3, 6], # voisins de 5
[0, 1, 3, 5, 7], # voisins de 6
[0, 6, 8], # voisins de 7
[3, 7] # voisins de 8
]

Principe :
On part d’un sommet et on prend un chemin.
Lorsqu’on arrive dans une impasse (fils déjà traités
ou en traitements), on revient au sommet précédent
et on examine les autres fils.

On dit qu’on a effectué un parcours en profondeur d’abord :
On avance autant que possible, et on revient sur ses traces pour
les sommets qu’on a laissés de côté préalablement.
Expliquons un peu ce qui se passe ici.
La liste dejavu permet de marquer les sommets déjà visités.
Il s’agit d’une liste de booléens, initialisée avec False.
Quand on visite un sommet k, on met à jour à True l’élément
dejavu[k] et on visite effectivement le sommet : c’est le rôle des
lignes 15 et 16. En ligne 12, on récupère le numéro k d’un
sommet à visiter (qu’on retire de la liste depuis) dont on
abandonne l’examen (en ligne 14) s’il a déjà été vu.

Il ne diffère du premier que par la ligne 7 où on a écrit
depuis.pop(0) au lieu de depuis.pop(), c’est-à-dire qu’à
chaque étape on sélectionne le sommet dont le numéro est
au début de la liste depuis, autrement dit le plus
anciennement introduit dans la liste, au contraire de la
démarche précédente. Cette fois, l’appel bfs(G) affiche :
0 1 6 7 2 4 5 3 8.
Il s’agit d’un parcours en largeur d’abord on constate bien
qu’après avoir visité le sommet 0, on attendra d’en avoir
visité tous ses voisins, 1, 6 et 7, avant d’aller plus loin.

Un arbre est un graphe connexe, acyclique et non orienté souvent doté d’un sommet particulier
appelé racine. Chaque sommet est appelé un nœud
Vocabulaire des Arbres :
Racine : Nœud sans antécédent
Feuille : Nœud sans successeur
Forêt : Chaque nœud a au plus un antécédent
Arborescence : Arbre avec une unique racine
Profondeur d’un nœud : Distance à la racine
Hauteur d’un arbre : Plus grande hauteur entre une feuille et la racine

Feuilles = F1, … , F13
Profondeur de F8 = 3
Hauteur de l’arbre = 5
Profondeur entre les Nœuds A et B = 2
Arbres particuliers
• Arbre binaire
• Arbre binaire de recherche
• Arbre équilibré
• Arbre complet
• Arbre presque complet

Arbre binaire
En informatique, un arbre binaire est une structure de données qui peut se représenter sous la forme
d'une hiérarchie dont chaque élément est appelé nœud, le nœud initial étant appelé racine.
Dans un arbre binaire, chaque élément possède au plus deux éléments (fils) au niveau inférieur,
habituellement appelés gauche et droit.
Du point de vue de ces éléments fils, l'élément dont ils sont issus au niveau supérieur est appelé père.

Arbre binaire de recherche
En informatique, un arbre binaire de recherche ou ABR (en anglais, binary search tree ou BST) est une
structure de données représentant un ensemble ou un tableau associatif dont les clés appartiennent à un
ensemble totalement ordonné. Un arbre binaire de recherche permet des opérations rapides pour
rechercher une clé, insérer ou supprimer une clé.

Arbre équilibré
En informatique, un arbre équilibré, aussi appelé arbre à critère d'équilibre, est un arbre qui maintient une
profondeur équilibrée entre ses branches.
Cela a l'avantage que le nombre de pas pour accéder à la donnée d'une clé est en moyenne minimisé et
ce nombre est égal (+/- 1) quelle que soit la clé

Arbre complet
Un arbre est complet si toutes les feuilles sont à la profondeur h depuis la racine.

Arbre presque complet
Soit un arbre de F feuilles.
Soit 1 ≤ 𝑝 ≤ 𝐹:
• Les p premières feuilles ont une profondeur h depuis la racine
• Les autres ont une profondeur h-1 depuis la racine

Qu’est ce que l'optimisation ?
C’est une branche des mathématiques cherchant à modéliser, à analyser et à résoudre analytiquement
ou numériquement les problèmes qui consistent à minimiser ou maximiser une fonction sur un ensemble.
L’optimisation joue un rôle important en recherche opérationnelle (domaine à la frontière entre
l'informatique, les mathématiques et l'économie), dans les mathématiques appliquées (fondamentales
pour l'industrie et l'ingénierie), en analyse et en analyse numérique, en statistique pour l’estimation du
maximum de vraisemblance d’une distribution, pour la recherche de stratégies dans le cadre de la théorie
des jeux, ou encore en théorie du contrôle et de la commande.

• Optimiser un problème, c’est déterminer les conditions dans lesquelles ce problème
présente une caractéristique spécifique. Par exemple, déterminer le minimum ou le
maximum d’une fonction est un problème d’optimisation. On peut également citer la
répartition optimale de tâches suivant des critères précis, le problème du rendu de monnaie,
le problème du sac à dos, la recherche d’un plus court chemin dans un graphe, le problème
du voyageur de commerce. De nombreuses techniques informatiques sont susceptibles
d’apporter une solution exacte ou approchée à ces problèmes.
• Avec les techniques de programmation dynamique certaines algorithmes peuvent apporter
une solution, ces derniers intitulés gloutons constituent une alternative dont le résultat n’est
pas toujours optimal. Plus précisément, ces algorithmes déterminent une solution optimale
en effectuant successivement des choix locaux, jamais remis en cause. Au cours de la
construction de la solution, l’algorithme résout une partie du problème puis se focalise
ensuite sur le sous-problème restant à résoudre.

• Enoncé du problème
Mamadou achète des articles à la boutique et après avoir réglé la somme le boutiquier doit lui
rendre la somme de 485 FCFA, sachant que dans l’espace UEMOA nous avons le jeu de
pièces suivant : 500, 250, 200, 100, 50, 25, 10, 5
Comment le boutiquier doit il rendre la monnaie avec peu de pièces ?
Propositions :
• P1 : {100,100,100,100,50,25,10}
• P2 : {200,200,50,10,10,10,5}
• P3 : {250,100,25,10}
• P4 : {250,25,25,25,25,25,10}
• ...
Un infinité de proposition peut être effectuée maintenant reste à savoir la plus optimale.
L’usage d’un algorithme glouton vas permettre à Mamadou d’optimiser ses pièces.

• Algorithme de glouton pour le cas 1
Modélisation de l’algorithme :
Considérons un ensemble de N pièces de monnaie de valeurs :
v1<v2<…<vN
Avec v1 = 5 FCFA
Sachant que ce systéme est canonique * , notons sN comme l’ensemble des pieces :
sN = {v1,v2,…,vN-1}
Soit R une somme à render avec le minimum de pieces sN
L’algorithme glouton sélectionne la plus grande valeur vN et la compare a sN
• Si R < vN, la pièce de valeur vN ne peut pas être utilisée.
On reprend le processus avec le système de pièces sN-1
• Si R >= vN, la pièce de valeur vN peut être utilisée une fois.
Ce qui fait une première pièce à comptabiliser, de valeur vN, la somme restant à rendre étant alors :
R - Vn
L’algorithme continue avec le même système de pièces sN et cette nouvelle somme à rendre R - Vn.
*Voir l’algorithme de Kazen et Kazs
(http://www.cs.cornell.edu/~kozen/Papers/change.pdf)
• Algorithme de glouton pour le cas 1
Implémentation de l’algorithme :

• Enoncé du problème
Des conférenciers sont invités à présenter leurs exposés dans une salle.
Mais leurs disponibilités ne leur permettent d’intervenir qu’à des horaires bien définis.
L’idée c’est de bâtir un planning d’occupation de la salle avec le maximum de conférenciers.
Formalisme :
n : Le nombre de conférenciers
𝐶! : Un conférencier
[𝑑𝑒𝑏𝑢𝑡! ; 𝑓𝑖𝑛! [ : Heure de début et de fin de l’intervention
Effectuons un choix de 4 conférenciers avec des périodes d’intervention différentes

• Scenario 1
Quatre conférenciers peuvent intervenir avec des créneaux disjoints :
C1 ∶ [3, 4[ − C2 ∶ [0, 1[ − C3 ∶ [2, 3[ − C4 ∶ [1, 2[

• Scenario 2
Quatre conférenciers peuvent intervenir avec des créneaux horaires non - disjoints :
C1 ∶ [2, 4[ − C2 ∶ [0, 1[ − C3 ∶ [1, 3[ − C4 ∶ [0, 2[

• Scenario 3
Choisissons trois conférenciers puis appliquons les scénarios 1 et 2:
C1 ∶ [0, 3[ − C2 ∶ [1, 2[ − C3 ∶ [2, 3[

• Algorithme glouton pour le problème d’ordonnancement
Une solution semble émerger des observations précédentes.
Ainsi l’ébauche de l’algorithme suivante peut être proposée
• Classer les intervalles par heures de fin croissantes.
• Choisir le conférencier associé au premier intervalle.
• Choisir parmi les intervalles suivants celui du conférencier dont l’intervalle est compatible avec celui
du premier conférencier.
• Recommencer ainsi avec les intervalles classés suivants jusqu’à ce qu’il n’y en ait plus à traiter.

• Algorithme glouton pour le problème d’ordonnancement
Classons les conférenciers par heures de fin croissantes en notant ≼ la relation d’ordre associée.
C8 ≼ C4 ≼ C6 ≼ C13 ≼ C10 ≼ C15 ≼ C2 ≼ C11 ≼ C5 ≼ C9 ≼ C1 ≼ C7 ≼ C14 ≼ C3 ≼ C12
Puis construisons petit à petit le planning.
• Le premier conférencier est C8 → [C8].
• Le conférencier suivant dont l’intervalle est compatible avec celui de C8 est C4 → [C8, C4].
• Le conférencier suivant compatible avec C4 est C2 → [C8, C4, C2].
• Le conférencier suivant compatible avec C2 est C5 → [C8, C4, C2, C5].
• Le conférencier suivant compatible avec C5 est C3 → [C8, C4, C2, C5, C3].
Ce qui mène au planning final suivant.
[C8, C4, C2, C5, C3]

Comme son nom l’indique, l’approche fonctionnelle de la programmation se concentre sur la
notion de fonctions. Dans un programme fonctionnel, tous les éléments peuvent être compris
comme des fonctions et le code peut être exécuté par des appels successifs de fonctions.
À l’inverse, aucune valeur n’est assignée de façon indépendante, on peut se représenter une
fonction comme étant la variante spéciale d'un sous-programme donné.
Elle est réutilisable et, contrairement à une procédure, renvoie directement un résultat.
Bien sûr, dans de nombreux langages de programmation évolués, il existe des fonctions qui
sont définies puis appliquées. Il ne s'agit donc pas de la particularité principale de la
programmation fonctionnelle. Ce qui rend l'approche fonctionnelle si importante pour
l'informatique et qui fait toute sa polyvalence, c'est le fait que les fonctions de ce paradigme
de programmation peuvent prendre différentes « formes ». Par exemple, elles peuvent
être associées entre elles comme des données. Elles peuvent également être utilisées en
tant que paramètres et résultats de fonctions. Ce traitement spécial des fonctions permet aux
programmeurs de mettre en place et de traiter des tâches de calcul de grande envergure (en
particulier celles qui relèvent d’une nature symbolique).

Avantages Inconvénients
• Les programmes n’ont pas d’état • Les données (p. ex. variables) ne sont pas modifiables
• Il n’est pas possible de récupérer de façon efficace de grandes

• Idéal pour la parallélisation
quantités de données
• Non recommandé pour connexion à des bases de données et

• Code facilement testable
serveurs
• Code facilement vérifiable : même les fonctions sans état • Ne convient pas en cas de nombreuses récursions d'une même
peuvent être vérifiées pile
• Se combine bien avec une programmation impérative et

• La programmation récursive peut entraîner de graves erreurs
orientée objet
• Code plus précis et concis • Ne convient pas à toutes les tâches

Qu’est ce qu’une expression lamda ?
Une expression lambda peut être comprise comme une représentation concise d’une fonction
anonyme avec les propriétés suivantes:
• Anonyme : nous disons anonyme parce qu’il n’a pas de nom explicite comme une méthode
aurait normalement, donc moins de choses à écrire.
• Fonction : nous disons fonction parce qu’un lambda n’est pas associé à une classe
particulière comme l’est une méthode. Mais comme une méthode, un lambda a une liste de
paramètres, un corps, un type de retour, et une liste possible d’exceptions qui peuvent être
lancées.
• Transmissible : une expression lambda peut être passée en argument à une méthode ou
stockée dans une variable.
• Surtout pour les fonctions de haut niveau map(), filter(), reduce()
• Concise : vous n’avez pas besoin d’écrire beaucoup de code boiler plate comme vous le
faites pour les classes anonymes.

Différence entre un fonction standard et une expression de fonction lambda
La fonction d'identité, une fonction qui renvoie son argument, est exprimée avec une définition de fonction
Python standard en utilisant le mot - clé def comme suit :
identity() prend un argument x et le renvoie lors de l'invocation.
En revanche, si vous utilisez une construction lambda Python vous avez une syntaxe plus simple.

Expression de fonction lambda
Argument
Mot clé lambda
Variable liée x+1 : Une instruction

Expression lambda
Étant donné qu'une fonction lambda est une expression, elle peut être nommée.
Par conséquent, vous pouvez écrire le code précédent comme suit :

Expression lambda multi – argument
Les fonctions multi-arguments (fonctions qui prennent plus d'un argument) sont exprimées en
lambdas Python en listant les arguments et en les séparant par une virgule ( ,) mais sans les
entourer de parenthèses :

Expression lambda et exécution automatique
Un autre modèle utilisé dans d'autres langages comme JavaScript consistant à exécuter
immédiatement une fonction dés sa déclaration peut être redéfinie avec une expression
lambda Python.
Ceci est connu comme une expression de fonction immédiatement invoquée ( IIFE).

Expression lambda et les fonctions d’ordre supérieur
Les fonctions Lambda sont fréquemment utilisées avec des fonctions d'ordre supérieur, qui
prennent une ou plusieurs fonctions comme arguments ou renvoient une ou plusieurs
fonctions.

Expression lambda et argument
Comme un objet fonction normal défini avec def, les expressions lambda Python prennent en
charge toutes les différentes façons de passer des arguments. Ceci comprend:
• Arguments de position
• Arguments nommés (parfois appelés arguments de mots clés)
• Liste variable d'arguments (souvent appelés var args )
• Liste de variables d'arguments de mots-clés
• Arguments de mots clés uniquement

Expression lambda et argument

§ Un decorateur permet d’ajouter une fonctionnalité à une fonction
§ Par exemple:

§ Un decorateur peut être utilisé avec les lambda expressions mais sans le symbole
@some_decorator
§ Par exemple:

Nous avons une closure en Python lorsqu'une fonction imbriquée fait référence à une valeur dans
sa portée englobante. Les critères qui doivent être remplis pour créer une closure en Python sont
résumés dans les points suivants.
• Nous devons avoir une fonction imbriquée (fonction à l'intérieur d'une fonction).
• La fonction imbriquée doit faire référence à une valeur définie dans la fonction englobante.
• La fonction englobante doit renvoyer la fonction imbriquée.

Exemple de closure :
La valeur de la portée englobante est

mémorisée même lorsque la variable sort
de la portée ou que la fonction elle-même
soit supprimée de l'espace de noms actuel.

§ On peut utiliser les expressions lambda avec les closure

§ Difficile de suivre le style PEP8 pour certains cas
§ Code difficile à lire
§ Il est recommandé de ne pas écrire les méthodes des classes sous forme de
fonctions lambda
§ Les lambdas imposent une vue fonctionnelle de la programmation
§ Syntaxe lourd parfois

§ A utiliser avec les fonctions map(), filter() et reduce()
§ Les fonctions clés pour renforcer leurs possibilités: sort(), sorted(), min(), max(),
§ En mode interaction avec l’interpréteur
§ Avec timeit

§ Probléme courant en programmation: comment gérer correctement les
ressources externes, telles que les fichiers, les verrous et les connexions
réseau?
§ Gerer des ressources en programmation est souvent un problème délicat.
§ nécessite à la fois une phase de configuration et une phase de libération des
ressources.
§ fermeture d'un fichier, la libération d'un verrou ou la fermeture d'une connexion réseau.
§ En cas d’oubli, votre application maintient la ressource en vie.
§ Entraine memory leak ou compromission de la bande passante du réseau.

§ Par exemple, un programme continue de créer de nouvelles connexions à une base de données sans
les libérer ni les réutiliser. Dans ce cas, le backend de la base de données peut cesser d'accepter de
nouvelles connexions.
§ L'écriture de texte dans des fichiers est généralement une opération mise en mémoire tampon. Cela
signifie que l’appel de .write () sur un fichier n’entraînera pas immédiatement l’écriture de texte
dans le fichier physique mais dans une mémoire tampon temporaire. Parfois, lorsque la mémoire
tampon n'est pas pleine et que les développeurs oublient d'appeler .close (), une partie des données
peut être perdue à jamais.
§ Une autre possibilité est que votre application rencontre des erreurs ou des exceptions qui amènent
le flux de contrôle à contourner le code responsable de la libération de la ressource disponible.

§ Un contexte est une portion de code cohérente avec des garanties en entrées et
sorties
§ Exemple: lecture de fichier
§ On doit garantir que le fichier est ouvert et accessible en entrée ( à l’interieur du
contexte)
§ Fermée à la sortie( à l’exterieure du contexte)
§ Python met à notre disposition deux approches générales pour gérer les
ressources:
§ try ……..finally
§ with

§ Approche classique de gestion des exceptions
§ On peut utiliser une instruction try… finally pour gérer correctement l'ouverture
et la fermeture des fichiers:

§ Crée un contexte d’execution qui permet d’executer un groupe d’instruction sous le contrôle
d’un context manager
§ Un contexte est un scope particulier, avec des opérations exécutées en entrée(configuration)
et en sortie(liberation des ressources).
§ Syntaxe:
§ « expression » doit être un objet qui implémente le protocole de gestion des ressources qui
comprend deux méthodes spéciales:
§ .__ enter __ () est appelée par l'instruction with pour entrer dans le contexte d'exécution.
§ .__ exit __ () est appelée lorsque l'exécution quitte le bloc de code with.

§ Appelez « expression » pour obtenir un gestionnaire de contexte.
§ Stockez les méthodes .__ enter __ () et .__ exit __ () du gestionnaire de contexte pour une
utilisation ultérieure.
§ Appelez .__ enter __ () du gestionnaire de contexte et liez sa valeur de retour à target_var si elle
est fournie.
§ Exécutez le bloc de code With.
§ Appelez .__ exit __ () sur le gestionnaire de contexte lorsque le bloc de code With se termine.
§ Remarque: certains gestionnaires de contexte renvoient None de .__ enter__ () car ils n'ont
aucun objet à retourner à l'appelant. Dans ces cas, la spécification d'un target_var n'a aucun
sens.

§ Le bloc With est donc un bloc d’instructions très simple, simplifiant et adaptant
un try/except/finally.
§ __enter__ ne prend aucun paramètre, contrairement à __exit__ qui en prend
3 : exc_type, exc_value, et traceback.
§ Ces paramètres interviennent quand une exception survient dans le bloc with, et correspondent au type
de l’exception levée, à sa valeur, et à son traceback.
§ Dans le cas où aucune exception n’est survenue pendant le traitement de la ressource, ces 3 paramètres
valent None.
§ __exit__ retourne un booléen, intervenant dans la propagation des exceptions.
§ En effet, si True est retourné, l’exception survenue dans le contexte sera attrapée.

Exercice: decrivez le process de with dans cet exemple ?
• Open retourne un objet io.TextIOBase qui herite de la classe IOBase qui est gestionnaire
de contexte
• Cet objet sera affecté à file avec __enter()__ par l’instruction with
• On execute avec file le corps du bloc associé à with
• On appelle __exit()__ qui va se charger de la fermeture du fichier même si une exception
survient dans le bloc du with

§ Le fichier peut être fermé entre deux appels successifs de file comme dans cet exemple

§ En général, les gestionnaires de contexte et l'instruction with ne se limitent pas à la
gestion des ressources. En d'autres termes, avec les gestionnaires de contexte, vous
pouvez effectuer n'importe quelle paire d'opérations qui doivent être effectuées avant
et après une autre opération ou procédure, telles que:
§ Ouvrir et fermer
§ Verrouiller et libérer
§ Modifier et réinitialiser
§ Créer et supprimer
§ Entrer et sortir
§ Démarrer et arrêter
§ Configuration et libérer
§ Vous pouvez fournir du code pour gérer en toute sécurité l'une de ces paires
d'opérations dans un gestionnaire de contexte. Ensuite, vous pouvez réutiliser ce
gestionnaire de contexte avec des instructions dans tout votre code.

§ Nous pouvons créer une classe gestionnaire de contexte en implémentant le
protocole de gestionnaire de contexte
Question: Qu’est-ce qui se passe en cas d’exception dans l’execution du bloc de code du with ?

§ Nous pouvons créer une classe gestionnaire de contexte en implémentant le
protocole de gestionnaire de contexte

§ Un même gestionnaire de contexte pourrait être utilisé à plusieurs reprises si
l’expression est chaque fois une même variable.

§ Mais les fichiers tels que retournés par open ne sont par exemple pas réutilisables :
une fois sortis du bloc with, le fichier est fermé, il est donc impossible d’ouvrir un
nouveau contexte.

§ Lock() de Threading qui permet de verrouiller une ressource est réutilisable mais
pas réentrant

§ RLock() de Threading qui permet de verrouiller une ressource est réentrant

§ Ecrivez une classe gestionnaire de contexte qui permet d’afficher le resultat ci-
dessous:

§ Créer une classe gestionnaire de contexte qui permet d’ouvrir un fichier en
lecture et ecriture. Utiliser filepath.

§ La contextlib est un module de la bibliothèque standard comportant divers outils
ou gestionnaires de contexte bien utiles.
§ Par exemple,
§ une classe, ContextDecorator, permet de transformer un gestionnaire de contexte en
décorateur, et donc de pouvoir l’utiliser comme l’un ou comme l’autre.
§ Cela peut s’avérer utile pour créer un module qui mesurerait le temps d’exécution d’un
ensemble d’instructions : on peut vouloir s’en servir via with, ou via un décorateur autour
de notre fonction à mesurer.
§ Cet outil s’utilise très facilement, il suffit que notre gestionnaire de contexte hérite
de ContextDecorator.

§ Mettre en place un gestionnaire de contexte équivalent à redirect_stdout pour
rediriger la sortie standard vers un autre fichier. Il sera aussi utilisable en tant que
décorateur pour rediriger la sortie standard de fonctions.
§ La redirection de sortie est une opération assez simple en Python. La sortie
standard est identifiée par l’attribut/fichier stdout du module sys. Pour rediriger la
sortie standard, il suffit alors de faire pointer sys.stdout vers un autre fichier.
§ Rendez le réentrant s’il ne l’est pas en emplinat les éléments de sortie

§ Définition du terme gestionnaire de
contexte : https://docs.python.org/3/glossary.html#term-context-manager
§ Gestionnaires de
contexte : https://docs.python.org/3/library/stdtypes.html#context-manager-
types
§ Blocs with : https://docs.python.org/3/reference/datamodel.html#with-statement-
context-managers
§ Module contextlib : https://docs.python.org/3/library/contextlib.html
§ PEP liée au bloc with : https://www.python.org/dev/peps/pep-0343/

§

§ Comprendre ce qu’est un itérable,
§ Implémenter un iterable

§ Un itérable est un objet dont on peut parcourir les valeurs, à l’aide d’un for par
exemple.
§ Les types str, tuple, list, dict et set sont des itérables bien connus.
§ Un grand nombre d’outils Python que nous verrons par la suite travaillent avec des
itérables, il est donc intéressant d’en tirer profit.

§ iter retourne un itérateur qui est un
objet qui va se déplacer le long de
l’itérable.
§ On appelle next en lui précisant
l’itérateur.
§ next fait avancer l’itérateur et
retourne la nouvelle valeur
découverte à chaque pas.
§ StopIteration est une exception,
levée par l’itérateur quand il arrive
à sa fin, qui signifie que nous en
sommes arrivés au bout, et donc
que la boucle doit cesser.

§ Ecrire une classe gestionnaire de contexte qui permet de parcourir un iterable

§ Les itérables et le mot-clef for sont intimement liés. C’est à partir de ce dernier
que nous itérons sur les objets.
§ for appelle la fonction iter sur l’iterable qui retourne un iterateur
§ Puis, pas à pas, le for appelle next en lui précisant l’itérateur.

§ next fait avancer l’itérateur et retourne la nouvelle valeur découverte à chaque pas.
§ A la fin du parcours for attrape l’exception StopIterator pour nous.

§ En interne:
§ iter fait habituellement appel à la méthode __iter__ de l’itérable,
§ next à la méthode __next__ de l’itérateur.
§ Ces deux méthodes ne prennent aucun paramètre.
§ Ainsi :
§ Un itérable est un objet possédant une méthode __iter__ retournant un itérateur ;
§ Un itérateur est un objet possédant une méthode __next__ retournant la valeur suivante à
chaque appel, et levant une exception de type StopIteration en fin de course.
§ La documentation Python indique aussi qu’un itérateur doit avoir une
méthode __iter__ où il se retourne lui-même, les itérateurs étant ainsi des itérables
à part entière.

§ Un iterable peut fournir une séquence infinie d'éléments que nous pouvons parcourir
très bien avec un iterateur.
§ Émuler la même chose avec une liste Python serait impossible - il n’y a aucun moyen de créer
une liste avec un nombre infini d’éléments en premier lieu.
§ En des termes plus abstraits, les itérateurs fournissent une interface commune qui vous
permet de traiter chaque élément d’un conteneur tout en étant complètement isolé de
la structure interne du conteneur.
§ Qu'il s'agisse d'une liste d'éléments, d'un dictionnaire, d'une séquence infinie ou d'un
autre type de séquence, tout cela n'est qu'un détail d'implémentation.
§ Chacun de ces objets peut être parcouru de la même manière par la puissance des itérateurs.

§ Creez ces classes d’iterateur et d’iterables et manipulez les avec for, next, iter,
map, sum, join et zip

§ En se basant sur les code ci-dessous ecrire une classe iterable et un iterateur qui
permettent d’executer ce code de maniére illimitée
§ Réécrire le code pour limiter les répétitions. Par exemple:

§ Nous avions besoin de la classe de l’iterateur pour héberger la méthode __next__
et récupérer les nouvelles valeurs de l'itérateur.
§ Mais peu importe où __next__ est défini. Dans le protocole d'itérateur, tout ce qui
compte, c'est que __iter__ retourne n'importe quel objet avec une méthode
__next__ dessus.
§ Réécrivez le code des exercices précédents en une seule classe

§ Ce module met à disposition de nombreuses méthodes pour les itérables dont :
§ chain(p, q, ...) — Met bout à bout plusieurs itérables ;
§ islice(p, start, stop, step) — Fait un travail semblable aux slices, mais en travaillant avec
des itérables (nul besoin de pouvoir indexer notre objet) ;
§ combinations(p, r) — Retourne toutes les combinaisons de r éléments possibles dans p ;
§ zip_longest(p, q, ...) — Similaire à zip, mais s’aligne sur l’itérable le plus grand plutôt
que le plus petit (en permettant de spécifier une valeur de remplissage).

§ Une fonctionnalité courante de Python, liée aux itérables, est celle de l’unpacking.
Il s’agit de l’opération qui permet de décomposer un itérable en plusieurs
variables.
§ On peut faire du unpacking avec tout iterable

§ Que donne cet expression: a, ((b, c, d), e), (f, g) = [0, (range(1, 4), 5), '67’] ?

SPLAT À GAUCHE
§ On peut aller encore plus loin avec l’opérateur splat. Cet opérateur est représenté
par le caractère *.
§ À ne pas confondre avec la multiplication, opérateur binaire entre deux objets, il
s’agit ici d’un opérateur unaire
§ Utilisé à gauche lors d’une assignation, il permet de récupérer plusieurs éléments
lors d’une décomposition.
§ Quel est le resultat de cet expression: head, *middle, last = range(10)

SPLAT À DROITE
§ Depuis Python 3.5 on peut utiliser les splat à droite.
§ Il aura simplement l’effet inverse, et décomposera un itérable comme si ses

valeurs avaient été entrées une à une.
§ Que donne l’expresion suivante: first, *middle, last = *[0, 1, 2], 3, 4, *[5, 6], 7

§ Itérateurs Python - Un résumé rapide
§ Les itérateurs fournissent une interface de séquence aux objets Python dont la
mémoire est efficace et considérée comme pythonique. Contemplez la beauté de
la boucle for-in!
§ Pour prendre en charge l'itération, un objet doit implémenter le protocole
d'itération en fournissant les méthodes __iter__ et __next__.
§ Les itérateurs basés sur les classes ne sont qu'un moyen d'écrire des objets
itérables en Python. Considérez également les générateurs et les expressions de
générateur.

§ Définition du terme itérable : https://docs.python.org/3/glossary.html#term-iterable
§ Du terme itérateur : https://docs.python.org/3/glossary.html#term-iterator
§ Type itérateur : https://docs.python.org/3/library/stdtypes.html#iterator-types

§ Module itertools : https://docs.python.org/3/library/itertools.html
§ Unpacking généralisé : https://www.python.org/dev/peps/pep-0448

§ Nouvelles fonctionnalités de Python 3.5 : https://zestedesavoir.com/articles/175/sortie-
de-python-3-5/
§ Article Sam&Max sur l’opérateur splat : http://sametmax.com/operateur-splat-ou-
etoile-en-python/

§ Avez-vous déjà eu à travailler avec un ensemble de données si volumineux qu’il
surchargeait la mémoire de votre machine?
§ Ou peut-être avez-vous une fonction complexe qui doit maintenir un état interne à
chaque fois qu’elle est appelée, mais la fonction est trop petite pour justifier la
création de sa propre classe.
§ Dans ces cas et plus, les générateurs et l'instruction yield Python sont là pour vous
aider.

§ Qu’est-ce qu’un générateur et comment l’utiliser ?
§ Comment créer des fonctions et des expressions de générateur ?
§ Fonctionnement de l'instruction yield
§ Comment utiliser plusieurs instructions yield Python dans une fonction de

générateur ?
§ Comment utiliser les méthodes de générateur avancées ?
§ Comment créer des pipelines de données avec plusieurs générateurs ?

§ Introduites avec PEP 255, les fonctions de générateur sont un type spécial de
fonction qui renvoie un itérateur « paresseux ».
§ Un générateur est un itérable, mais aussi un itérateur qui n’a pas besoin d’implementer le
protocole d’un iterateur (__iter()__, __next()__)
§ Objets sur lesquels vous pouvez boucler comme une liste. Cependant, contrairement aux
listes, les itérateurs « paresseux » ne stockent pas leur contenu en mémoire.
§ Un generateur est un one time operation ie on ne peut itérer sur les données qu’une
seule fois. Pour le itérer à nouveau il faudra appeler le générateur à nouveau

§ Les générateurs ressemblent et agissent comme des fonctions régulières, mais
avec une caractéristique déterminante:
§ Les générateurs utilisent le mot-clé yield au lieu de return.
§ Leurs définitions ressemblent à une définition de fonction, à l'exception de l'instruction
yield Python et du code qui la suit.
§ yield indique qu’une valeur est renvoyée à l'appelant, mais contrairement à return, on ne
quitte pas la fonction par la suite.

§ Au lieu de cela, l'état de la fonction est mémorisé.
§ lorsque next () est appelé sur un objet générateur (soit explicitement, soit implicitement
dans une boucle for), la variable précédemment produite num est incrémentée, puis
renvoyée à nouveau.

§ Comme les compréhensions de liste, les expressions generateur vous permettent
de créer rapidement un objet générateur en quelques lignes de code.
§ On peut les créer sans construire et conserver l'objet entier en mémoire avant
l'itération.
§ En d'autres termes, vous n'aurez aucune problème de mémoire lorsque vous utilisez des
expressions de générateur.
§ Formule: (expression for i in s if condition)
§ Equivalent: for i in s:
if condition:
yield expression

§ Comme les compréhensions de liste, les expressions generateur vous permettent
de créer rapidement un objet générateur en quelques lignes de code.
§ On peut les créer sans construire et conserver l'objet entier en mémoire avant
l'itération.
§ En d'autres termes, vous n'aurez aucune probléme de mémoire lorsque vous utilisez des
expressions de générateur.

§ Etudier les performance de l’expression générateur et de liste en utilisant
sys.getsizeof()
§ Evaluer les temps d’execution et les appels de fonction de la sommation de la liste
et du générateur en utilisant cProfile.run()
§ Emettre une recommandation sur l’utilisation des generateurs par rapport aux
listes

§ Dans l'ensemble, yield est une instuction assez simple. Son travail principal est de contrôler le flux
d'une fonction générateur d'une manière similaire aux instructions de retour avec certaines
spécificités:
§ Lorsque vous appelez une fonction générateur ou utilisez une expression générateur, vous retournez un
itérateur spécial appelé générateur.
§ Vous pouvez affecter ce générateur à une variable pour l'utiliser.
§ Lorsque vous appelez des méthodes spéciales sur le générateur, telles que next(), le code de la fonction est
exécuté jusqu'à yield.
§ Lorsque l'instruction yield est atteinte, le programme suspend l'exécution de la fonction et renvoie
la valeur produite à l'appelant. (En revanche, return arrête complètement l'exécution de la fonction.)
§ Lorsqu'une fonction est suspendue, l'état de cette fonction est sauvegardé. Cela inclut toutes les
liaisons de variables locales au générateur, le pointeur d'instruction, la pile interne et toute gestion
des exceptions.
§ Cela vous permet de reprendre l’exécution de la fonction chaque fois que vous appelez le
générateur. De cette façon, toutes les évaluations de fonctions sont reprises juste après le yield.

§ Quel est le resultat du code ci-dessous:

§ throw
§ Lancer une exception à partir du generateur

§ close
§ Arreter le générateur de maniére élégante

§ send
§ Communiquer avec le generateur

§ Voir notebook sur les generateurs

§ Dans ce chapitre on a traité les points suivants:
§ Comment utiliser et écrire des fonctions de générateur et des expressions de
générateur
§ Ce que yield permet de faire avec les générateurs
§ Comment utiliser plusieurs instructions yield dans une fonction de générateur
§ Comment utiliser .send () pour envoyer des données à un générateur

§ Comment utiliser .throw () pour lever des exceptions de générateur
§ Comment utiliser .close () pour arrêter l'itération d'un générateur
§ Comment créer un pipeline de générateur pour traiter efficacement de gros

fichiers CSV

§ Quelques pages habituelles tirées de la documentation :
§ Définition du terme générateur : https://docs.python.org/3/glossary.html#term-
generator
§ Expressions yield : https://docs.python.org/3/reference/expressions.html#yieldex
pr
§ https://zestedesavoir.com/articles/152/la-puissance-cachee-des-coroutines
§ https://realpython.com/introduction-to-python-generators/

§ En Python, les fonctions sont des objets de première classe.
§ Les fonctions peuvent être transmises et utilisées comme arguments, comme n'importe
quel autre objet (string, int, float, list, etc.).
§ Considérez les trois fonctions suivantes:

§ Il est possible de définir des fonctions à l’intérieur d’autres fonctions. Ces
fonctions sont appelées fonctions internes.
§ Qu’est-ce qui se passe à l’appel de la fonction parent ?
§ Peut-on appeler second_child ailleurs?

§ L'ordre dans lequel les fonctions internes sont définies n'a pas d'importance.
§ Comme avec toutes les autres fonctions, l'impression n'a lieu que lorsque les
fonctions internes sont exécutées.
§ De plus, les fonctions internes ne sont pas définies tant que la fonction parent n'est
pas appelée.
§ Elles n'existent qu'à l'intérieur de la fonction parent () en tant que variables locales.

§ Python permet également d'utiliser
des fonctions comme valeurs de
retour.
§ Notez que vous renvoyez first_child
sans les parenthèses. Cela signifie
que vous retournez une référence à
la fonction first_child.
§ En revanche, first_child () avec

parenthèses fait référence au résultat
de l'évaluation de la fonction.
§ Que retourne parent(1) ?

§ Expliquez ce qui va se passer avec ce bout de code:

§ Le nom de décorateur provient du patron de conception décorateur (pattern
decorator).
§ Un décorateur permet de se soustraire à un objet pour en modifier le
comportement.
§ Le principe de la décoration en Python est d’appliquer un décorateur à une

fonction, afin de retourner un nouvel objet (généralement une fonction).
§ On peut donc voir le décorateur comme une fonction prenant une fonction en
paramètre, et retournant une nouvelle fonction1

§ La pie syntax @decorator

§ Mettre le code du decorateur dans un module .py
§ L ’importer et le reutiliser avec la pie syntax

Générateurs

Qu’est-ce c’est ?
• Un contexte est une portion de code cohérente, avec des garanties en
entrée et en sortie.

Python Parcours Complet Integral

Transféré par

Droits d'auteur :

Formats disponibles

Python Parcours Complet Integral

Transféré par

Informations du document

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 Parcours Complet Integral

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Python :

01/02/2021 Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 2

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 3

§ Art de décomposer un problème en une suite

§ Suite finie de règles à appliquer dans un ordre déterminé

Vient du mathématicien arabe

Muhammmad ibn Musa alKharezmi

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 5

v L’organigramme : Représentation graphique avec des symboles (carrés, losanges, etc.)

§ Offre une vue d’ensemble de l’algorithme ;

§ Représentation quasiment abandonnée aujourd’hui.

v Le pseudo-code : Représentation textuelle avec une série de conventions

§ Plus pratique pour écrire un algorithme ;

§ Représentation largement utilisée ;

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 8

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 9

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 12

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 13

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 15

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 16

• Directement exécutable par la machine

• Non portable : Chaque famille de processeur possède son langage

• Ne manipule que des registres de taille fixée (64 bits en général)

• Ne permet d’effectuer que des opérations élémentaires

(accès mémoire, additions, soustractions, etc.)

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 17

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 18

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 19

programme sous le contrôle de l’unité de Commande

3. Mémoire Centrale : Permet de stocker et de restituer des informations

• Correspond à un ensemble fini de cellules

• Une case mémoire (cellule) contient une donnée ou une instruction

• Chaque cellule est numérotée : adresse

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 23

Nous avons les périphériques de communication et de mémorisation

• 4. Entrées : Clavier, Souris, Scanner, Web Cam, Micro

• 5. Sorties : Ecran, Haut Parleur, Imprimante,

Disque Dur, Disquette (ancêtre de la clé USB et de la carte mémoire), CDROM...

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 24

• Déclaration d’emplacement mémoire • MP : Mémoire Centrale

• Calcul et Comparaison • UAL : Unité Arithmético - Logique

• Lecture • PE : Périphérique d’Entrée

• Ecriture • PS : Périphérique de Sortie

• Tests • UCC : Unité de Commande et de Controle

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 25

dans un langage spécifique, qu’on appelle langage de programmation ;

§ On obtient ainsi ce qu’on appelle un programme informatique qui contient

l’ensemble des actions consécutives que l’ordinateur doit exécuter ;

§ Ces actions sont appelées instructions ;

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 26

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 29

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 30

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 31

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 32

01/02/2021 Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 35

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 36

10h00 10h05 10h10 10h15 10h20 10h25 10h30

Formalisme de déclaration d’une variable en algorithme :

VARIABLE nom_de_la_variable : type_de_la_variable

Python, UIDT / SES / MSDA / M. BOUSSO - M. DIOUF 01/02/2021 38