CHAPITRE 4 : LES SOUS-PROGRAMMES

La programmation modulaire permet de subdiviser un problème en ensemble de sous problèmes

(modules) de difficultés moindres. Un module (sous programme) effectue une tâche bien déterminée et
sera appelé, en cas de besoin, par le programme principal ou par un autre module. Un module peut être
une fonction ou une procédure.
I. Les Fonctions
1) Activité1
Soit l’algorithme du programme qui saisit un réel X>0 , détermine la racine carré de X et la
somme des chiffres de l’arrondissement de X
Algorithme Calcul_Racine_Somme
Debut
Répéter
Ecrire("Donner X") Appel d’un sous programme prédéfinie
Lire (X)
Jusqu’à X>0 Paramètre effectif
Ecrire("La racine carré de ", X ,"=",RacineCarré(X) )
Ecrire("La somme des chiffres de round", X,"=", Somme(Arrondi(X))
Fin
[Link]
Objet T/N
X Réel
Somme Fonction

NB :
RacineCarré : Une fonction prédéfinie (En python il faut importer la définition de sqrt de la bibliothèque math)
Arrondi : Une fonction prédéfinie : En python c’est round
Somme : Une fonction qu’il faut la définir par le programmeur
Algorithme de la fonction Somme
Fonction Somme(Y :entier) :entier
Début
Chconvch(Y)
S0
Pour i de 0 à long(Ch)-1 Faire
SS+valeur(Ch[i])
Fin Pour
Retourner S
Fin
[Link]
Objet T/N
I, S entier
Ch chaine

Question :
Implémenter cet Algorithme en Python
Python
def somme(Y) :
Ch=str(Y)
S=0
for i in range(len(Ch)) :
S=S+int(Ch[i])
return S

2) Activité2
Soit l’algorithme du programme qui détermine la factorielle d’un entier N ≥0
1
 Algorithme CalculFactoriel
Debut
Répéter
Ecrire("Donner N")
Lire (N)
Jusqu’à N≥0
FFact(N) Appel d’une fonction Fact avec paramètre effectif N
Ecrire( N, " !=",F )
Fin
T.D.O.G
Objet T/N
N Entier
Fact Fonction

NB :
Fact: est une fonction qui détermine la factorielle d’un entier N . Exemple : Fact(3)=6 ; 3 !=1*2*3=6
Algorithme de la fonction Fact
Fonction Fact(N :entier) :Entier T.D.O.L
Début Objet T/N
F1 F, i Entier
Pour i de 1 à N Faire
FF*i
Fin Pour
Retourner N
Fin

Questions :
1) Implémenter cet algorithme en Python
Python
def fact(N) :
F=1
for i in range(1,N+1) :
F=F*i
return N

2) Déduire le programme Python qui saisit 2 entiers n et p (0<n≤8 et 0<p≤n), détermine et affiche la
combinaison de p objets parmi n.
p n!
∁ =
n p ! ( n− p ) !
Python
def fact(N) : p=int(input("Taper p :"))
F=1 while not 0<p<=n :
for i in range(1,N+1) : p=int(input("Taper p :"))
F=F*i r=fact(n)//(fact(p)*fact(n-p))
return N print("C(",n,",",p,")=",r)
##PP ##
n=int(input("Taper n :"))
while not 0<n<8 :
n=int(input("Taper n :"))

3) Définition
Une fonction est un sous-programme qui retourne une seule valeur de type simple (entier, réel, chaîne ou
booléen).
4) Déclaration (Définition)
En Algorithmique
Fonction Nom_fonction (pf1 : type1, pf2 : type2, … , pfn : typen) :
Type_résultat DEBUT
2
 Traitement
Retourner Résultat
FIN
T.D.O.L
Objet T/N

NB : Au niveau de l’algorithme on dresse un tableau de déclaration des objets locaux (T.D.O.L)

En Python
def Nom_fonction (pf1, pf2, …, pfn ) :
Traitement
return resultat

Exemple : Algorithme de la fonction Fact

5) Appel d'une fonction
L'appel d'une fonction doit figurer obligatoirement dans une expression (affectation, instruction
d'affichage, condition, boucle pour, …), en utilisant le nom de la fonction suivi de la liste des paramètres
effectifs.
Au niveau de l’algorithme En Python
Objet  Nom_fonction (pe1, pe2, …, pen) Objet = Nom_fonction (pe1, pe2, …, pen)
Ou bien Ou bien
Ecrire( Nom_fonction (pe1, pe2, …, pen)) print( Nom_fonction (pe1, pe2, …, pen))
Ou bien Ou bien
… …

II. Déclaration et accès aux objets

1) Déclaration et accès aux objets :
 Les objets locaux : Tous les objets (variables et sous-programmes) déclarés dans un sous-
programme sont dits locaux à celui-ci.
 Les objets globaux : Tous les objets déclarés au niveau du programme principal sont dits
globaux.
 Accès aux objets : un objet global est accessible par tout le monde. Un objet local est connu
uniquement à l’intérieur de son module.
2) Types de paramètres :
On distingue deux types de paramètres:
 Les paramètres formels : qui figurent dans la définition du sous-programme.
 Les paramètres effectifs : qui figurent dans l'appel du sous-programme.
Remarque:
 Les paramètres formels et les paramètres effectifs doivent s'accorder de point de vue nombre et
ordre et leurs types doivent être identiques/compatibles, selon le mode de passage des paramètres.
 Il est possible de définir un sous-programme sans paramètres.

III- Application
1) Ecrire l’algorithme d’un module intitulé MinTab qui détermine le minimum d’un tableau T de N
entiers
Fonction MinTab(T :Tab, N :entier) :entier
Début

T.D.O.L
3
 Objet T/N

Fin
2) Ecrire un programme Python qui saisit 2<N≤30 entiers dans un tableau détermine et affiche le
minimum dans T. Ce programme fait appel au module MinTab.
III. Les Procédures
1) Activité
Soit l’algorithme suivant :
Algorithme Permutation T.D.O
Début Objet T/N
Ecrire("Donner X")
Lire (X)
Ecrire("Donner Y")
Lire (Y)
ZX
XY
YZ
Ecrire("La nouvelle valeur de X est :",X)
Ecrire("La nouvelle valeur de Y est :",Y)
Fin
Questions :
1)Implémenter cet algorithme en Python
2)Transformer l’action définit par les instructions en gras en un en un module et apporter les modifications
nécessaires dans le programme.
3)Transformer l’action de saisie de X et Y en un module et apporter les modifications nécessaires dans le
programme.
4)Transformer l’action d’affichage en un module et apporter les modifications nécessaires dans le programme.
From math import*
X=int(input(‘Danner

2) Définition
Une procédure est un sous-programme qui peut avoir zéro, un ou plusieurs résultats.
3) Déclaration
En Algorithmique
Procédure Nom_procédure (pf1 : type1, pf2 : type2, …, pfn : typen)
DEBUT
Traitement
FIN
4
 En Python
def Nom_procédure (pf1, pf2, … , pfn ) :
Traitement
[return resultat]
NB : Eliminer tous les paramètres dont le mode de passage est par référence (adresse) et les
retourner en résultat

4) Appel d'une procédure

En Algorithmique
Nom_procédure (pe1, pe2, …, pen)

En Python
Dans le cas où la procédure retourne un ou Dans le cas où la procédure ne retourne
plusieurs résultats : aucun résultat
Variable(s) = Nom_procédure (pe1, pe2, …, pen) Nom_procédure (pe1, pe2, …, pen)

Exemple :
Avec retour Sans retour
En Algorithmique En Algorithmique
Procédure Saisir (@N : Entier) Procédure Afficher (T : Tab, N : Entier)
DEBUT DEBUT
Ecrire ("Donner un entier : ") Traitement
Lire (N) FIN
FIN
En Python En Python
def Saisir ( ) : def Afficher(T, N) :
N = int (input ("Donner un entier : ")) Traitement
return N
L’APPEL EN PYTHON L’APPEL EN PYTHON
N= Saisir ( ) Afficher(T, N)
5) Application
Ecrire l’algorithme d’un module qui permet de saisir un entier N (2<N≤3) et de remplir un tableau T par
N entiers.

IV. Mode de passage de paramètres

Il existe deux modes de passage des paramètres: le mode par valeur et le mode par variable. Pour le cas de
la fonction, nous définissions seulement le mode par valeur.
1) Mode de passage par valeur :
Au moment de l'appel, la valeur du paramètre effectif sera copiée dans le paramètre formel du module.
Toute modification du paramètre formel est sans conséquence sur le paramètre effectif.
2) Mode de passage par variable :

5
 Dans l'entête de la procédure, on doit précéder les paramètres formels transmis par référence ( adresse)
par le symbole @.
Toute modification du paramètre formel entraîne automatiquement la modification de la valeur du
paramètre effectif.
V. Exercice d’application :
1) Ecrire l’algorithme d’un programme principal qui saisit n (0<n≤10) entiers strictement positif
dans un tableau T, détermine et affiche toutes les nombres dans T formés par des chiffes triés
dans l’ordre croissant
2) Ecrire l’algorithme de chaque module appelé dans le programme principal.
Exemple :

Si n=5 et T contient les chaines suivantes :

2018 25 362 1259 246

Dans ce cas Le programme Affiche : 25, 1259, 246

Solution
1)
Algorithme du Programme Principal
Algorithme App
Debut

Fin
T.D.N.T [Link]
Types Objet T/N

2)