3SC - Partie - Les Sous Programmes S1

Prof
: Mme RIAHI Wafa Classe : 3 SC

Matière : Informatique Lycée : M’ghira / Fouchena
Année : 2020 / 2021
Module :
Les sous programmes
Objectif :
 Décomposer un problème en sous-problèmes élémentaires
 Présenter les solutions sous forme de procédures et de fonctions
 Présenter les solutions sous forme d'algorithmes
 Implémentation des algorithmes sous Python programmes.
Plan :
I Analyse modulaire.........................................................................................................................1
II Les procédures...............................................................................................................................3
II.1 Définition..................................................................................................................................3
II.2 Déclaration................................................................................................................................3
II.3 Appel.........................................................................................................................................3
III Les fonctions.................................................................................................................................3
III.1 Définition..................................................................................................................................3
III.2 Déclaration................................................................................................................................3
III.3 Appel.........................................................................................................................................3
IV Application :..................................................................................................................................3
Série n°1.................................................................................................................................................6
Série n°1 : correction..............................................................................................................................7
Prof : Mme RIAHI Wafa Classe : 3 SC
Matière : Programmation
Module :
Lycée : M’ghira / Fouchena
Les sous programmes Année : 2020 / 2021
I Analyse modulaire
Exercice :
Analysez puis déduisez l’algorithme d’un programme qui permet de remplir un tableau T de N entiers
positif, avec N [5..20], calcul et affiche la somme des éléments paire du tableau.
 La résolution d’un problème complexe comporte trois étapes :

1. Décomposition du problème en sous-problèmes (analyse modulaire) : on indique pour
chacun son but (que fait le sous-programme ?), les paramètres par valeur (quelles sont les
données nécessaires ?) et les paramètres par variable (quels résultats va-t-on obtenir ?) ;
Exemple :
Les flèches bleues indiquent les
variables transmises (ou bien fourni) par
le programme principal aux modules
alors que les flèches rouges indiquent les
résultats renvoyer par les modules au
programme principal.
Commentaire :
 Pour le module Saisie : le programme principal lui fourni les variables N et T initialement
’’Vide’’ (flèche bleue), est c’est lui qui va assurer l’opération de saisi de N et le remplissage de T, une
fois ce module à accomplit sa tâche il retourne au programme principal la variable N et le tableau T
(flèche rouge)
 Pour le module Calculer_somme : il reçoit la valeur de la variable N ainsi que les valeurs des
éléments du tableau (flèche bleue), afin de parcourir le tableau, calculer la somme des éléments pairs
et renvoyer la valeur de la somme S ( flèche rouge)
 Pour le module Afficher : il reçoit la valeur de la somme S ((flèche bleue) déjà calculé par le
module précédent) et l’affiche et ne renvoie aucun résultat.
Astuce :
 Une astuce à appliquer lors de l’analyse modulaire est de considérer que tous les modules sont
des procédures et si un module accepte (ou bien reçoit) des paramètres sans les modifier et retourne
un seul résultat alors cette procédure sera une fonction.
Reprenons notre exemple :
 On peut remplacer la procédure CALCULER_SOMME par une fonction puisque elle ne va
pas changer les valeurs de N et T (paramètres passés par valeur) et la valeur de retour (S) est de type
simple.
 Analyse du programme principal :
Nom : SOMME_ PAIRE
3 Résultat = PROC AFFICHER(S)
2 S ß FN CALCULER_SOMME(N, T)
1 [ N, T] = PROC SAISIE(N, T)
FIN SOMME_PAIR
T.D.O globaux :
objet Type \ nature rôle
AFFICHER Procédure Afficher la valeur de la somme
S Entier Valeur de la somme
CALCULER_SOMME Fonction Calculer la somme des éléments pairs
T Tableau Tableau contenant n entiers positifs
SAISIE Procédure Saisir la valeur de n et remplir le tableau T
N entier Nombre d’éléments du tableau T
1
Module :
2. écriture de l’algorithme général : en faisant référence aux sous-problèmes définis précédemment ;

 Algorithme de programme principal :
0) début SOMME_ PAIRE
1) PROC SAISIE(N, T)
2) S ß FN CALCULER_SOMME(N, T)
3) PROC AFFICHER(S)
4) FIN SOMME_PAIR
3. écriture des sous-algorithmes : en définissant pour chacun les paramètres et les informations locales.
 La structure d’un sous-programme ressemble à celle d’un programme : en-tête, déclarations, bloc
d’instructions.
 Algorithme de la procédure SAISIE
0) def PROC SAISIE (var x: entier; var V: tableau de 20 entiers)
1) répéter
Ecrire (``Donner un entier n dans [5..20] :``)
Lire (x)
Jusqu'à x dans [5..20]
2) Pour i de 1 à x faire
Répéter
Ecrire (``Donner V[``,i,``] : ``)
Lire (V[i])
Jusqu’à V[i]>=0
Fin pour
3) fin SAISIE
T.D.O locaux
objet Type _ nature rôle
i Entier Compteur
 Algorithme de la fonction Calculer_somme

0) def FN CALCULER_SOMME (x: entire ; V: tableau de 20 entiers ; var som : integer) : entier
1) Somß0 pour i de 1 à x faire
Si (V[i] mod 2 =0 ) alors
som ß som + V[i]
fin si
fin pour
2) FN CALCULER_SOMME  som
3) fin Calculer_somme
T.D.O locaux
objet Type _ nature rôle
i Entier Compteur
som Entier Variable dans laquelle on stocke la somme
 Algorithme de la procédure AFFICHER
0) def PROC AFFICHER (som : entier)
1) Ecrire (‘’ la somme des éléments pairs est : ‘’, som)
2) fin AFFICHER
2
Module :
II Les procédures
II.1 Définition
Les procédures sont des sous-programmes qui peuvent avoir zéro, un ou plusieurs résultats.
II.2 Déclaration
La définition d’une procédure est constituée de trois parties :
a) L’en tête : Cette partie comporte le descripteur Proc, le nom de la procédure suivie de l’ensemble des
paramètres formels qui sont mis entre parenthèses. Chaque paramètre sera précédé par son mode de passage
et suivi du type qui lui correspond.
b) La déclaration : Cette partie sera réservée à la déclaration des objets locaux (sils existent) propre à la
procédure.
c) Le corps : qui contient l’ensemble des instructions de développement de la procédure.
Syntaxe en algorithmique
0) Def Proc Nom_procédure (paramètres formels)
1) Instruction1
2) Instruction2
…
n) Fin Nom_procédure
- C'est le mot-clé var qui dit si le passage se fait par valeur (pas de var) ou par variable (présence du var).
Pas de var = donnée ; présence du var = donnée/résultat.
- Si plusieurs paramètres ont le même type, on peut écrire leur identificateur séparé par une virgule et suivi
du type commun ; un point virgule sépare la déclaration de chaque paramètre.
- Attention : redéclarer un paramètre comme variable locale provoque une erreur à la compilation.
II.3 Appel
L’appel d’une procédure se fait simplement en indiquant son nom suivi entre parenthèses de la liste des
paramètres effectifs séparés par une virgule : Nom_procédure (paramètres effectifs) ;
III Les fonctions
III.1 Définition
Les fonctions sont des sous-programmes qui fournissent un seul résultat de type simple (entier, réel,
caractère, chaine de caractères, booléen) à partir d’une liste de paramètres par valeur
III.2 Déclaration
a) L’en tête : Cette partie comporte le descripteur FN, le nom de la fonction suivi de l’ensemble des
paramètres formels qui sont mis entre parenthèses. Chaque paramètre sera suivi du type qui lui correspond.
Puis le type du résultat renvoyé par cette fonction précédé par le signe :.
b) La déclaration : Cette partie sera réservée à la déclaration des objets locaux propre à la fonction.
c) Le corps : qui contient l’ensemble des instructions de développement de la fonction.
Syntaxe en algorithmique
0) Def Fn Nom_fonct (p formels) : type_résultat
1) Instruction1
2) Instruction2
…
n-1) Fn Nom_fonct  résultat
n) Fin Nom_fonct
- Il existe de nombreuses fonctions prédéfinies qu’il n’est pas besoin de déclarer (exemple ORD (car),
ABS(x), SQR(x)…).
III.3 Appel
L’appel d’une fonction se fait toujours dans :
- une expression d’affectation : Nom_variable  FN Nom_fonction (paramètres effectifs)
- instruction d’écriture : Ecrire (FN Nom_fonction (paramètres effectifs))
- ou condition : Si FN Nom_fonction (paramètres effectifs) = …
IV Application :
Série n° 1 : Exercice n° 1 .. Exercice n° 5
3
Module :
Python
En python, la syntaxe pour définir une fonction est la suivante :
Fonctionnement :
 en Python, l'écriture d'une fonction commence toujours par le mot def.
 vous pouvez choisir le nom que vous voulez pour la fonction.
 les variables sont déclarées entre parenthèses, séparées par des virgules, juste
après le nom de la fonction.
 comme les instructions if, for ou while, l'instruction def est une instruction
composée : la ligne démarrant l'instruction def est terminée par deux points « : »,
lesquels introduisent un bloc d'instructions qui doit être indenté.
 La fonction s'utilise ensuite dans le reste du programme par un simple appel :
Nom_De_La_Fonction(Valeurs_des_Variables)
Remarques :
 Des fonctions, nous en utilisons depuis le premier module : l'instruction «
print("Bonjour") » n'est autre que l'appel de la fonction print, avec en argument
la valeur de variable « "Bonjour" ».
 En effet, Python comprend un très grand nombre de fonctions prédéfinies : des
fonctions déjà définies par les développeurs de Python.
 A celles-ci, nous allons maintenant en ajouter d'autres, que nous coderons nous-
mêmes en fonction de nos besoins.
Vraies fonctions et procédures.

Les fonctions écrites jusqu'à présent se contentent de réaliser des actions (afficher un
message, par exemple). C'est ce l'on appelle des procédures.
Une vraie fonction doit, en plus, lorsqu'elle se termine, renvoyer une valeur :
comme une fonction en mathématiques qui renvoie au final l'image d'un nombre :
lorsque l'on appelle f avec la valeur 3, elle renvoie le nombre f(3).
L'instruction return, qui vient toujours en dernière ligne de la fonction, définit ce que

doit n,renvoyer la fonction.
La valeur (ou l'objet) renvoyée pourra, par exemple, être stockée dans une variable et
ré-exploitée par le programme.
4
Module :
Syntaxe d'une fonction renvoyant un résultat:
Désormais nos programmes auront la structure suivante :

 1) Importation des librairies et fonctions prédéfinies nécessaires au programme,
 2) Définition de nos fonctions personnelles,
 3) Main, ou encore en français : corps principal du programme.
Exemple :
 Dans un programme, il y a 2 types de variables :

1) variable locale :
 définie à l'intérieur d'une fonction,
 inaccessible depuis l'extérieur de la fonction,
 détruite après l'exécution de la fonction.
2) variable globale :
 définie à l'extérieur des fonctions,
 contenu visible depuis l'intérieur des fonctions,
 non modifiable depuis l'intérieur d'une fonction.
 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.
 Une variable globale peut devenir modifiable à l'intérieur d'une fonction en
indiquant dans la fonction : global NomDeLaVariable
5
Prof : Mme RIAHI Wafa Module : Les sous programmes Classe : 3 SC
Matière : Programmation Lycée : M’ghira / Fouchena
Série n° 1 Année : 2020 / 2021
Série n°1
Exercice n° 1
Analysez puis déduisez l’algorithme d’un programme qui permet de remplir un tableau T de N entiers
positif, avec N [5..20], calcul et affiche la somme des éléments paire du tableau.
N.B Appliquer l’analyse modulaire pour résoudre ce problème.
Exercice n° 2
Ecrire une analyse un algorithme d’un programme intitulé DUREE qui permet de convertir une durée d
donnée en secondes (avec 400 <= d <=70 000) en heures, minutes et seconde, et d’afficher les résultats.
N.B : La solution doit comporter au moins deux modules.
Exercice n° 3
En utilisant l’éditeur Thonny :
Exercice n° 4
Exercice n° 5
6
Série n°1 : Correction Année : 2020 / 2021
Série n°1 : correction

Exercice n° 1
Exercice n° 2
1. analyse du programme principal :
NOM : DUREE
Résultat : PROC affiche (d,hr,min,sec)
[hr, min, sec] = PROC conversion(d,hr,min,sec)
[d] = PROC saisie(d)
Fin DUREE
7
Algorithme du programme principal : T.D.O.Globaux

0) Début DUREE
1) PROC saisie(d) Objets Type \ nature Rôle
2) PROC conversion(d,hr,minu,sec) d Entier long Une durée en secondes
3) PROC affiche(d,hr,minu,sec) hr entier Nbre des heures
4) fin DUREE minu entier Nbre des minutes
sec entier Nbre des secondes
Saisie conversion
affiche Procédure
Exercice n°3
Exercice n°4
8
Exercice n°5

3SC - Partie - Les Sous Programmes S1

Transféré par

Informations du document

Titre original

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

3SC - Partie - Les Sous Programmes S1

Transféré par

Droits d'auteur :

Formats disponibles

Prof

: Mme RIAHI Wafa Classe : 3 SC

 La résolution d’un problème complexe comporte trois étapes :

2. écriture de l’algorithme général : en faisant référence aux sous-problèmes définis précédemment ;

 Algorithme de la fonction Calculer_somme

En python, la syntaxe pour définir une fonction est la suivante :

Vraies fonctions et procédures.

L'instruction return, qui vient toujours en dernière ligne de la fonction, définit ce que

Syntaxe d'une fonction renvoyant un résultat:

Désormais nos programmes auront la structure suivante :

 Dans un programme, il y a 2 types de variables :

En utilisant l’éditeur Thonny :

Série n°1 : correction

Algorithme du programme principal : T.D.O.Globaux

Vous aimerez peut-être aussi