Les sous programmes
Classe : 4ème Sciences et Math.
*****
Proposé par : Bassem Amor.
Matière : informatique.
Année scolaire : 2021-2022.
Étude de cas :
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
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 sousprogramme 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
"appel"
"résultat"
"appel"
"résultat"
Procédure
Prog.appelant
"utilisateur"
Procédure renvoie un résultat au prog. appelant
Procédure
"résultat"
"utilisateur"
Procédure renvoie zéros résultat au prog. appelant
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 :
Déclaration au niveau algorithme :
Fonction nom_fonction(pf1 :type1,pf2 :type2,…..,pfn:typen):type_résultat
Début
(module avec return)
Traitement
Retourner(résultat)
Niveau python
Fin
Appel :
objet← nom_fonction(pe1,pe2,…..,pen)
Procédure :
Déclaration au niveau algorithme :
Procédure nom_ procédure (pf1 :type1,pf2 :type2,…..,pfn:typen)
(module sans return)
Début
Traitement
Fin
Niveau python
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.
(module avec return)
Bonnes pratiques analyse modulaire
Si le programme appelé retourne
au programme appelant :
un seul résultat de type
entier,réel,chaine,booléen
Un tableau à une dimension/à deux
dimensions
Zéro résultat (le programme appelé
affiche le résultat)
Choix en
algorithme
fonction
procédure
procédure
Plusieurs résultats de type
(chaine,entier,réel,booléen,tableau) procédure
Choix en python
exemples
En algorithme
Module avec return
Module sans return
Module sans return
Module avec return
En python
Fonction lecture(p,q :entier) :entier
début
Répeter
Écrire("n=")
Lire(n)
Appel:
Jusqu’à(p<n<q)
a←lecture(3,6)
Retourner(n)
fin
b←lecture(1,7)
def lecture(p,q) :
ok= False
While ok== False:
n=int(input("n="))
ok=p<n<q
Appel:
return (n)
a=lecture(3,6)
Procedure remplir(@T :Tab;n :entier)
Début
Pour i de 0 à n-1 faire
Écrire("T[",i,"]=")
Appel:
Lire(T[i])
remplir(T,n)
Fin pour
Fin
remplir(V,7)
def remplir(T,n) :
for i in range(n):
T[i]=int(input("T["+str(i)+ "]="))
Procedure affiche(T :Tab;n :entier)
Début
Appel:
Pour i de 0 à n-1 faire
Écrire(T[i])
affiche(T,n)
Fin pour
affiche(V,7)
fin
Procedure permute(@x,@y :entier)
Début
i←x
Appel:
x←y
y←i
permute(a,b)
fin
def affiche(T,n) :
for i in range(n):
print(T[i])
b=lecture(1,7)
Appel:
remplir(T,n)
remplir(V,7)
Appel:
affiche(T,n)
affiche(V,7)
def permute(x,y) :
x,y=y,x
return (x,y)
Appel:
(a,b)=permute(a,b)
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.
5- Le mot-clé "global" en python :
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".
Une solution pour l’activité (Analyse modulaire) :
Programme principal
calcul
Procédure
fonction
lecture(p,q)
Remplir(t,n)
lecture(p,q)
fonction
Recherche(t,n,e)
Procédure
Afficher(t,n)
Algorithme du programme principal :
Algorithme calcul
Début
Tableau de déclaration de nouveaux types (T.D.N.T) :
Type
Tab=tableau de 20 entiers
Appel du sous
programme
n←lecture(5,20)
remplir(t,n)
Tableau de déclaration des objets globaux (T.D.O.G):
ecrire("e=")
objet
n
t
s
e
lecture
remplir
recherche
afficher
lire(e)
s←recherche(t,n,e)
ecrire(s)
afficher(t,n)
fin
type
Entier
Tab
Entier
Entier
Fonction
Procédure
Fonction
procédure
Remarque:
variable locale :
Algorithme de la fonction lecture
Fonction lecture (p,q :entier) :entier
Début
Définie à l'intérieur d'un sous programme.
Inaccessible depuis l'extérieur du sous
programme.
Détruite après l'exécution du sous
programme.
variable globale :
Répéter
Ecrire ("taper un entier entre", p,"et", q)
Lire(x)
Jusqu’à (p≤x≤q)
Retourner(x)
fin
Définie à l'extérieur du sous programme.
Contenu visible depuis l'intérieur du sous
programme.
Lorsqu'une variable locale et une variable
globale porte le même nom, à l'intérieur
d'une fonction, c'est la variable locale qui est
prioritaire.
Paramètres formels
Les paramètres au niveau de l’entête du sousprogramme.
Tableau de déclaration
des objets locaux (T.D.O.L):
objet
x
type
Entier
Par exemple : p et q.
Paramètres effectifs :
Les paramètres au niveau de l’appel du sousprogramme.
Algorithme de la procédure remplir
Procédure remplir (@ v :tab ; r : entier)
Tableau de déclaration
des objets locaux (T.D.O.L):
Début
objet
i
Pour i de 0 à r-1 faire
type
Entier
v[i]←lecture(10,100)
Fin pour
Mode de passage des paramètres :
fin
Par référence ou par adresse :
Algorithme de la fonction recherche
Lorsque les modifications faites par le sousprogramme sur le paramètre formel sont appliquées
sur le paramètre effectif.
Fonction recherche (v :tab ;r,x :entier) :entier
Début
NB : Il est précédé par @ au niveau de l’entête.
i←0
Par valeur :
trouve←faux
Tantque ((trouve=faux) et (i<r)) faire
Si (v[i]=x) alors
Lorsque les modifications faites par le sousprogramme sur le paramètre formel ne sont pas
appliquées sur le paramètre effectif.
trouve←vrai
sinon
Tableau de déclaration
i←i+1
finsi
fin tantque
si (trouve=faux) alors
des objets locaux (T.D.O.L):
objet
i
y
trouve
type
Entier
entier
booléen
y←-1
sinon
y←i
finsi
Retourner(y)
fin
Algorithme de la procedure afficher
Procédure afficher (v :tab ; r : entier)
des objets locaux (T.D.O.L):
Début
Pour i de 0 à r-1 faire
Ecrire(v[i])
Fin pour
fin
Tableau de déclaration
objet
i
type
Entier
Equivalent en python :
import numpy as np
#------------------
#------------------
def lecture(p,q):
def afficher(v,r):
ok=False
while(ok==False):
for i in range(r):
print(v[i])
x=int(input("entier entre "+str(p)+" et "+str(q)))
#------------------
ok=(p<=x<=q):
n=lecture(5,20)
return x
t=np.array([0]*n,dtype='int')
#------------------
remplir(t,n)
def remplir(v,r):
e=int(input('e= '))
for i in range(r):
v[i]=lecture(10,100)
#-----------------def recherche(v,r,x):
i=0
trouve=False
while((trouve==False) and (i<r)):
if(v[i]==x):
trouve=True
else:
i=i+1
if(trouve==False):
y=-1
else:
y=i
return y
s=recherche(t,n,e)
print(s)
afficher(t,n)
