sous prog

Étude de cas :
*****
Proposé par : Bassem Amor.
Année scolaire : 2021-2022.
Les sous programmes
Classe : 4ème Sciences et Math.
Matière : informatique.
On se propose d’écrire un programme permettant de :
 Lire un entier n (5≤n≤20).
 Remplir un tableau T par n entiers ∈[10,100] .
 Lire un entier e.
 Afficher la position de e dans T si e existe dans T et -1
sinon.
 Afficher T.
Exemple :
T :
-1
8
20
0
6
0
1
2
3
4
e=20 → Le programme affiche 2.
e=-3 → le programme affiche -1

"appel"
"résultat"
"résultat"
"appel"
"résultat"
"utilisateur"
"utilisateur"
Décomposition modulaire
1- Définition :
Une approche qui consiste à décomposer un problème initialement complexe en sous
problèmes abordables, puis associer à chaque sous problème un sous-programme qui le résout.
2- Notions de bases.
a- Programme appelant/appelé :
sp1 : un sous-programme appelé.
Le programme principal est un programme appelant : appel les sous programmes.
sp3 : un sous-programme appelé par rapport au programme principal et appelant par rapport au sous-
programme sp3_1
b- Les sous programmes en algorithmique sont :
Les fonctions : ensemble d’instructions, appliquée sur des arguments passés en paramètre (appelé
paramètres formels), qui renvoie un seul résultat (entier,réel,booléen,caractère,chaine de caractères)
au programme appelant.
Les procédures : ensemble d’instructions, appliquées sur des arguments passés en paramètre (appelé
paramètres formels), qui renvoie zéros ou plusieurs résultats au programme appelant.
Prog.appelant
Procédure
Prog.appelant
Procédure
Procédure renvoie un résultat au prog. appelant
Procédure renvoie zéros résultat au prog. appelant

Déclaration au niveau algorithme :
Fonction nom_fonction(pf1 :type1,pf2 :type2,…..,pfn:typen):type_résultat
Début
Traitement
Retourner(résultat)
Fin
Appel :
objet← nom_fonction(pe1,pe2,…..,pen)
Déclaration au niveau algorithme :
Procédure nom_ procédure (pf1 :type1,pf2 :type2,…..,pfn:typen)
Début
Traitement
Fin
Appel :
nom_ procédure(pe1,pe2,…..,pen)
le mode de passage :
Si le mode de passage est par référence (par adresse), on ajoutera
le symbole @ avant le nom du paramètre.
3- Avantage de l’analyse modulaire :
 Simplifier la résolution du problème.
 Réutilisation des sous programmes.
 Faciliter la maintenance et la détection de bugs.
 Le développement du code des modules peut être attribué à des personnes différentes, qui
effectuent leurs tests unitaires indépendamment.
4- Syntaxe
Fonction :
Procédure :
(module avec return)
(module sans return)
(module avec return)
Niveau python
Niveau python

Bonnes pratiques analyse modulaire
Si le programme appelé retourne
au programme appelant :
Choix en
algorithme
Choix en python
exemples
En algorithme
En python
un seul résultat de type
entier,réel,chaine,booléen
fonction
Module avec return
Fonction lecture(p,q :entier) :entier
début
Répeter
Écrire("n=")
Lire(n)
Jusqu’à(p<n<q)
Retourner(n)
fin
def lecture(p,q) :
ok= False
While ok== False:
n=int(input("n="))
ok=p<n<q
return (n)
Un tableau à une dimension/à deux
dimensions
procédure
Module sans return
Procedure remplir(@T :Tab;n :entier)
Début
Pour i de 0 à n-1 faire
Écrire("T[",i,"]=")
Lire(T[i])
Fin pour
Fin
def remplir(T,n) :
for i in range(n):
T[i]=int(input("T["+str(i)+ "]="))
Zéro résultat (le programme appelé
affiche le résultat)
procédure
Module sans return
Procedure affiche(T :Tab;n :entier)
Début
Pour i de 0 à n-1 faire
Écrire(T[i])
Fin pour
fin
def affiche(T,n) :
for i in range(n):
print(T[i])
Plusieurs résultats de type
(chaine,entier,réel,booléen,tableau)
procédure
Module avec return
Procedure permute(@x,@y :entier)
Début
i←x
x←y
y←i
fin
def permute(x,y) :
x,y=y,x
return (x,y)
Remarque : l’équivalent en python de tout sous-programme (procédure ou fonction) qui retourne un ou plusieurs résultats au programme appelant, peut
être un module avec return qui contient les paramètres résultat.
Appel:
a←lecture(3,6)
b←lecture(1,7)
Appel:
a=lecture(3,6)
b=lecture(1,7)
Appel:
remplir(T,n)
remplir(V,7)
Appel:
remplir(T,n)
remplir(V,7)
Appel:
affiche(T,n)
affiche(V,7)
Appel:
affiche(T,n)
affiche(V,7)
Appel:
permute(a,b)
Appel:
(a,b)=permute(a,b)

5- Le mot-clé "global" en python :
Une solution pour l’activité (Analyse modulaire) :
calcul
lecture(p,q)
Remplir(t,n)
Afficher(t,n)
lecture(p,q)
Recherche(t,n,e)
fonction
fonction
Procédure
Procédure
Programme principal
En utilisant global, nous n’allons pas
créer de nouvelle version de la variable
localement à l'intérieur du module, mais
d'utiliser plutôt la variable qui porte ce
nom "en dehors", dans ce qui s'appelle
l'environnement "global".