Niveau : Scientifique et Sciences Informatique

L’analyse modulaire
1. Définition

L’analyse modulaire consiste à diviser un problème en sous problèmes de difficultés moindres, ces derniers
peuvent être eux même divisés jusqu’à ce qu’on arrive à un niveau abordable de difficulté.

2. Intérêts

L’analyse modulaire présente plusieurs intérêts :

 Diviser la tâche difficile en plusieurs tâches de difficulté moindre.
 Offrir la possibilité de réutiliser un programme sans pour autant être obliger à réécrire le code.
 Pouvoir localiser l’erreur et la corriger.
 Avoir un programme plus lisible.
Pour que l’analyse modulaire soit efficace et nous aide à structurer un programme, il faut que :
La division en module soit significative c'est-à-dire qu’un module correspond à une tâche bien déterminée.

3. Notions de sous programmes

C’est un programme déclaré dans un autre programme et appelé dans celui-ci une fois ou plusieurs fois
On distingue deux types de sous programmes : les fonctions et les procédures

Déclaration, accès aux objets et mode de transmission

I. Déclaration et accès aux objets

1. Les objets locaux
Tous les objets tels que constantes, types, variables et d’autres fonctions déclarés dans un sous-programme sont
dits locaux à celui-ci.
2. Les objets globaux
Les objets utilisés dans un sous-programme et non déclarés dans celui-ci sont des objets globaux déclarés dans
la zone déclaration du programme appelant.
3. Niveaux des sous-programmes
Les niveaux des sous-programmes sont modélisés par un arbre qui représente le niveau hiérarchique des sous-
programmes.
4. Accès aux objets PP
Variables locales et globales
Les variables déclarés dans le programme principal sont
considérés comme locales pour lui et globales pour tous les SP1 SP2 SP3
modules qu’il appelle.
Les variables déclarés dans un module sont considérés locales
au module et globales pour tout autre module appelé.
Tous les objets locaux d’un sous-programme sont
inaccessibles : SP3 SP3
 Par le programme principal -1 -2
 Par les sous-programmes déclarés au même niveau que lui
 Par les sous programmes qui l’englobent
Dans un sous-programme de niveau i les identificateurs connus sont :
 Les identificateurs locaux
Préparé par : Mme Tlili Sonia 1
 Niveau : Scientifique et Sciences Informatique
 Les identificateurs déclarés dans les sous-programmes englobant de niveau j<i
Remarque :
 Un identificateur peut en cacher un autre c’est dans le cas où un identificateur du programme
englobant est un homonyme d’un identifiant du programme englobé. Dans ce cas l’objet local va
cacher l’objet global.
 Il faut éviter au maximum d’utiliser les objets globaux dans les sous programmes appelés sauf pour
les nouveaux types et les constantes. De préférence les sous programmes devront communiquer à
travers des paramètres.
II. Les paramètres et leurs modes de transmission
1. Les paramètres formels
Les paramètres écrits avec le sous-programme lors de sa déclaration sont les paramètres formels.
2. Les paramètres effectifs
Les paramètres écrits avec le sous-programme lors de son appel sont les paramètres effectifs.
3. Mode de passage des paramètres
Lors de la définition des paramètres formels d’un sous-programme, on doit préciser :
 le nom du paramètre
 son type
 mode de passage
On a deux modes de passage de paramètres : le mode par valeur et celui par variables.
a. Mode de passage par valeur
C’est le mode utilisé lorsque le paramètre effectif passé au sous-programme ne change pas de valeur après
l’exécution du sous-programme. Comme une fonction ne retourne qu’un seul résultat alors le mode de
passage de tous ces paramètres est obligatoirement par valeur.
b. Mode de passage par variable
c’est le contraire du mode de passage par valeur. Il permet au sous-programme d’utiliser la variable effective
dans le traitement puis de lui assigner une nouvelle valeur. Ce mode de passage est utilisé pour les procédures.
Pour pouvoir récupérer des résultats d’une procédure on doit mettre ‘@’devant les noms des paramètres
respectifs (en algorithme). Exemple : @ x, y : entier
4. Activation d’une fonction et retour du résultat de la fonction
a. Activation
L’activation d’une fonction est l’exécution d’une instruction d’appel de cette fonction. Cette exécution se fait
comme suit :
 Création de l’espace mémoires pour les objets locaux
 Exécution des instructions de la fonction
 Sortie de la fonction et retour à l’instruction suivante à l’activation dans le programme appelant
b. Retour du résultat de la fonction
Une fonction possède le type de son résultat donc il doit y avoir dans le corps de son programme une
instruction retourner variable_résultat.

Préparé par : Mme Tlili Sonia 2

 Niveau : Scientifique et Sciences Informatique

Les fonctions
I. Définition

Une fonction est un sous-programme qui doit renvoyer un et un seul résultat de type simple(entier, réel, booléen,
caractère ou chaîne de caractères). Ce type sera celui de la fonction.

II. Syntaxe
Lors de la définition de la fonction :
En algorithme En Python
FONCTION nom_fonction(pf1,:type1, … ,pfn :type n) : type_res
DEBUT def nom_fonction (pf1, … ,pfn ) : type_res
Instruction 1 Instruction 1
Instruction N Instruction N
RETOURNER Résultat return Résultat
FIN

Lors de l’appel de la fonction:

En algorithme En Python
Objetnom_fonction (pe1, … ,pen) Objet = nom_fonction (pe1,… ,pen)

Remarque :

Les paramètres effectifs et les paramètres formels doivent correspondre au point de vue ordre, nombre et
type.

III. Activité
Écrire un programme qui calcule et affiche la somme des factoriels des chiffres d’un entier n donné avec 1<= n
<=50. Respecter le modèle d’affichage suivant :

Exemple :N=13  on affichera 1 ! + 3 ! = 7

ALGORITHME PP Programme en Python

DEBUT def Factoriel (e) :
REPETER FC=1
Ecrire (‘Donner [Link] for i in range(1,e+1):
un entier entre 1 et 50 :’) FC=FC*i
Nom T/N
Lire (n) return FC
N, F, D, U Entier
JUSQU'A n dans[1..50] #***************************************
Factoriel Fonction
SI n < 10 ALORS n=int(input('Donner un entier entre 1 et 50 :'))
FFactoriel( n ) while not(n in range(1,51)):
Ecrire (n, ‘ ! = ‘, F) n=int(input('Donner un entier entre 1 et 50 :'))
SINON if n < 10 :
Dn DIV 10 F=Factoriel( n )
Un MOD 10 print(n, ' ! = ', F)
Ecrire (D, ‘ ! + ‘, U, ‘ ! = ‘, Factoriel( D ) + else:
Factoriel ( U )) D=n // 10
FIN SI U=n % 10
FIN print(D, ' ! + ', U, ' ! = ', Factoriel ( D ) + Factoriel ( U ))
FONCTION Factoriel (e : entier) : entier
DEBUT
[Link]
FC1
Nom T/N
POUR i de 1 à e FAIRE
FC, i entier
FCFC*i
FIN POUR
Retourne FC
FIN

Préparé par : Mme Tlili Sonia 3

 Niveau : Scientifique et Sciences Informatique

Les procédures
I. Définition

Une procédure est un sous-programme qui retourne zéro ou plusieurs résultatsde tous types (entier, réel, booléen,
caractère, chaîne de caractères, tableau…).

II. Syntaxe

Lors de la définition de la procédure :

En algorithme En Python
PROCEDURE nom_procédure (pf1 :type1,… ,pfn :type n) def nom_procédure (pf1,… ,pfn ) :
DEBUT Instruction 1
Instruction 1 Instruction 2
Instruction 2 Instruction N
Instruction N
FIN

Lors de l’appel de la procédure:

En algorithme En Python
nom_procédure (pe1, … ,pen) nom_procédure (pe1, … ,pen)

Remarque :

- Les paramètres formels et les paramètres effectifs doivent s’accorder de point de vue ordre, nombre et
type.
- Le passage de paramètre par adresse (par référence) permet au programme appelant de transmettre
une valeur à la procédure appelée et vice versa. Le changement du paramètre formel permet aussi le
changement du paramètre effectif. On ajoutera le symbole « @ »avant le paramètre formel passé par
adresse.

III. Activité

Écrire un programme qui saisitn entiers dans un tableau T (avec 2<=n<=20) puis affiche les entiers pairs dans
un tableau TP, et les entiers impairs dans un autre tableau TI. Trouver les modules nécessaires.
algorithme : (programme principal) algorithme : (procédure pair_impair)
ALGORITHME PP PROCEDUREpair_impair (T :tab ; N :entier ;@ TP :tab ; @TI :tab ;
DEBUT @ np :entier ;@ ni :entier)
Répéter DEBUT
Ecrire (‘’entrer un entier entre 2 et 20 :’’) j0 k0
Lire (n) POUR i de0à N-1FAIRE
Jusqu’à (2<=n<=20) SI T[i] MOD 2 =0 ALORS
remplissage (T, n) TP[j]T[i]
pair_impair(T,N,TP,TI,LP,LI) j j+1
affiche (TP, LP) SINON
affiche (TI, LI) TI[k]T[i]
FIN k k+1
FIN SI
FIN POUR
npJ
niK
FIN

Préparé par : Mme Tlili Sonia 4

 Niveau : Scientifique et Sciences Informatique

Algorithme PROC affiche Algorithme PROC remplissage

PROCEDUREaffiche (T : tab ; N :entier) PROCEDUREremplissage (@ T : tab ; N : entier)

DEBUT DEBUT
POUR i de0àN-1FAIRE POURi de0à N-1FAIRE
Ecrire (T[i]) Ecrire (‘’entrer un entier’’)
FIN POUR Lire (T[i])
FIN FIN POUR
FIN

ProgrammePython :

from numpy import * else:

#**************remplissage************* TI[k]=T[i]
defremplissage(n): k=k+1
for i in range(n):
T[i]=int(input('T['+str(i)+']= ')) returnTP,TI,j,k
return T #********************PP***************
#************************************* n=int(input('donner un entier entre 2 et 20: '))
defaffiche(T,n): whilenot(2<=n<=20):
for i in range(n): n=int(input('donner un entier entre 2 et 20: '))
print(T[i],end='\t')
print() T=array([int()]*n)
#************************************* TP=array([int()]*n)
defpair_impair(T,n): TI=array([int()]*n)
j=0
k=0 T=remplissage(n)
for i in range(n): TP,TI, lp,li=pair_impair(T,n)
if T[i] % 2 ==0: affiche(TP, lp)
TP[j]=T[i] affiche(TI, li)
j=j+1

Préparé par : Mme Tlili Sonia 5