DÉPARTEMENT MATH ET

INFORMATIQUE

Algorithmique II

Pr. SADIQ Mounir

2023-2024
Fonctions
et
procédures
 3

Procédure avec plusieurs paramètres

• Situation :
Imaginez que vous êtes enseignant dans une école primaire et que
vous souhaitez aider vos élèves à comprendre les tables de
multiplication. Vous avez décidé de créer un programme
informatique qui affiche la table de multiplication d'un nombre
donné et indique si chaque produit est divisible par un autre
nombre. Cela permettra aux élèves de voir non seulement les
résultats des multiplications, mais aussi de comprendre le
concept de divisibilité.

• Problème :
Vous voulez que le programme affiche la table de multiplication du
nombre 3 et indique si chaque produit est divisible par 2. Vous
souhaitez que le programme affiche un message spécifique
lorsque le produit est divisible par 2 et un autre message lorsque
ce n'est pas le cas.
 4

Fonctions simples sans paramètres

Algorithme tab_multiplication LARP PYTHON
ENTRER n,m
Procédure F(n,m: entier)
POUR i=1 JUSQU'À 10 FAIRE ECRIRE "tableau de",n,"est:" def F(n,m):
p=n*i POUR i=1 JUSQU'À 10 FAIRE print("tableau de",n,"est:")
si p%m=0 alors p=n*i for i in range(11):
p=n*i
Ecrire n,"*",i,"=",p si p%m=0 alors
if p%m==0:
Ecrire "le reste de la division Ecrire n,"*",i,"=",p
print(n,"*",i,"=",p)
de",p,"par",m, "est nul" Ecrire "le reste de la division print("le reste de la
sinon de",p,"par",m, "est nul"
division de",p,"par",m, "est
Ecrire n,"*",i,"=",p sinon nul")
Ecrire "le reste de la division Ecrire n,"*",i,"=",p else:
de" ,p,"par",m, "n'est pas Ecrire "le reste de la division print(n,"*",i,"=",p)
nul" de" ,p,"par",m, "n'est pas print("le reste de la
FINSI nul" division de" ,p,"par",m, "n'est
FINPOUR FINSI pas nul")
Finprocedure FINPOUR
RETOURNER
Début
F(3,2) Début
Fin F(3,2)
F(3,2)
Fin
 5

Procédure avec plusieurs paramètres

def tableau_de_multplication(n,m):
""" donne le tableau de multiplication"""
print("tableau de",n,"est:")
for i in range(11):
p=n*i
if p%m==0:
print(n,"*",i,"=",p)
print("le reste de la division de",p,"par",m, "est nul")
else:
print(n,"*",i,"=",p)
print("le reste de la division de" ,p,"par",m, "n'est pas
nul")

#Programme appelant#
tableau_de_multplication(3,2)
 6

Fonctions
Une fonction est introduite par un en-tête, appelé
aussi signature ou prototype, qui spécifie :
– le nom de la fonction,
– les paramètres donnés et leur type,
– le type du résultat.
 7

Fonctions

• La syntaxe retenue pour l’en-tête est la suivante :

fonction nomFonction (paramètre1: type1, paramètre: type 2,…): type
du résultat

• La liste des paramètres précise, pour chaque paramètre,

son nom, son type.

• type du résultat : indique la valeur retournée, nous la

noterons: retourne expression
 8

fonction nomFonction (paramètre1: type1,

paramètre: type 2,…): type_du_résultat
Variable
Variable 1: type1
Variable 2 : type2
…..
Debut

Traitement voulu
retourne( (valeur_de_retour)

Fin
 9

Programme appelant

algorithme cercle
Variables:
r, s, ci: réel Quand on appel une fonction,
on reçoit automatiquement la
Début : valeur qu’elle retourne
Ecrire (‘saisir rayon’) Appel de la fonction
Lire (r )
s Surface (r) Paramètre effectif
ci Circonférence ( r )
Fin

Nom_fonction Paramètre formel Type de la valeur retournée

Fonction Circonférence (a:réel): réel

Constante:
PI=3,14
Variables:
c: réel
Début
c(PI*2*a)
Retourne (c)
Fin
 10

Fonctions
Remarque 1:

• Une fonction est un bloc d’instructions qui retourne

obligatoirement une et une seule valeur
(résultat) à l’algorithme appelant. Une fonction
n’affiche jamais la réponse à l’écran car elle la
renvoie simplement à l’algorithme appelant.

• Lors d’appel d’une fonction, on veille sur le respect

des types définis dans l’en tête de la fonction
 11

Fonctions en python

def nomDeLaFonction(liste de paramètres):

...
bloc d'instructions
...
[resultat=…..] # […] c’est optionnel
[return resultat]
 12

Fonctions simples sans paramètres

Algorithme CUBE_3 LARP PYTHON
Variables:
y: entier
ENTRER
fonction cube_3():entier def cube_3():
retourner 3*3*3 RETOURNER 3*3*3 return 3*3*3
Finfonction

y=cube_3()
Début DÉBUT print(y)
ycube_3() y=cube_3
Ecrire (" le cube de 3 est :"),y Ecrire" le cube de 3 est :",y
Fin FIN
 13

Fonctions avec un seul paramètre

Algorithme CUBE LARP PYTHON
Variables:
y: entier
ENTRER x
Fonction cube(x:entier):entier def cube(x):
retourner x*x*x RETOURNER x*x*x return x*x*x
Finfonction

y=cube(3)
print(y)
Début DÉBUT
ycube(3) y=cube(3)
Ecrire (" le cube de 3 est :"),y Ecrire" le cube de 3 est :",y
Fin FINFIN
 14

Fonctions rappelant une autre

Algorithme volumes_sphere LARP PYTHON

Variables: ENTRER x
y: entier def cube(x):
RETOURNER x*x*x return x**3
Fonction cube(x:entier):entier
retourner x*x*x def volumes_sphere(r):
ENTRER r
Finfonction return 4*3.14*cube(r)/3
RETOURNER Y=volumes_sphere(3))
Fonction volumes_sphere 4*3.14*cube(r)/3
print("le volume de la
(r:entier):réel
sphere de rayon=3 est:"
y=volumes_sphere(3) , y)
retourner 4*3.14*cube(r)/3 Ecrire "le volume de la
Finfonction sphere de rayon=3
est:",y

Début
yvolumes_sphere (3)
Ecrire (" le cube de 3 est :"),y
Fin
 15

Fonctions return un Tableau

Algorithme LARP PYTHON
tableau_de_multplication_3
Variables: def
y[11]: Tableau ENTRER n tableau_de_multplication(n):
Ecrire " tableau de",n,"est:" print("tableau de",n,"est:")
Fonction tableau_de_multplication(n): R=[]
R=[0]
Tableau for i in range(11):
POUR i=1 JUSQU'À 10 FAIRE p=n*i
Variables:
p=n*i R=R+[p]
R[11]: tableau return R
R=R+[p]
p: entier
FINPOUR
R=[0]
RETOURNER R y=tableau_de_multplication(3
POUR i=1 JUSQU'À 10 FAIRE
)
p=n*i print(y)
R=R+[p]
y=tableau_de_multplication(3)
FINPOUR
Ecrire y
RETOURNER R
Finfonction

Début
y=tableau_de_multplication(3)
Ecrire y
Fin
 16

Fonctions Exercice
Soit le programme suivant à compléter :
Algorithme …………………………………… LARP PYTHON
Variables:
c: entier
def F(a,b):
x=0
Fonction F(a,b:entier): entier ENTRER a,b
Variables: x=0 if a>b:
x: entier SI a>b ALORS x=a
x=0 x=a else:
SI a>b ALORS SINON x=b
x=a x=b return x
SINON FINSI
x=b
FINSI RETOURNER x
RETOURNER x
Finfonction c=F(7,F(3,5))
print("...............=",c)
Début c=F(7,F(3,5))
c=F(7,F(3,5)) ecrire " ................................ :", c
ecrire " ................................ :", c
Fin
 17

Procédure vis-à-vis fonction

 Une fonction est un sous-algorithme qui, à partir
de donnée(s), calcul et rend à l’algorithme Un et
Un seul résultat alors qu’en général, une
procédure est un sous-programme qui ne retourne
aucun résultat
paramètre :

• paramètre : lors de l'appel d’un sous algorithme, il

faut passer la valeur du paramètre effectif au paramètre
formel, pendant l'exécution de la procédure appelée, si
le paramètre formel est modifié, il ne faut pas
répercuter cette modification sur le paramètre
effectif.
 19

Variables

• On peut manipuler 2 types de variables dans un

sous programme (procédure ou fonction) :
–des variables locales ,
–des variables globales.
• •Elles se distinguent par leur portée (leur
"champ de définition " et leur "durée de vie").
 20

Variables
 21

La portée des variables locales et

globales

• Une variable définie au niveau du programme

principal est appelée variable globale.
 Sa portée est totale : tout sous-programme
du programme principal peut utiliser cette
variable
• Une variable définie au sein d’un sous
programme est appelée variable locale.
 La portée d’une variable locale est
uniquement le sous-programme qui la
déclare.
 22

La durée de vie des variables locales et

globales

• Une variable locale n'est connue qu'à l'intérieur

du sous programme ou elle a été définie.
 Elle est crée à l'appel du sous programme et
détruite à la fin de son exécution
• Une variable globale est connue par l'ensemble
des sous programmes et le programme principal.
 Elle est définie durant toute l’application et
peut être utilisée et modifiée par les différents
sous programme du programme principale.
 23

Algorithme Variable_globale_locale
Variables:
a, x: entier

fonction F (b:entier): entier

Variables:
y: entier Portée de la
Début variable
locale b
x b+10 Portée de la
yb*x variable
locale c
Portée de la
variable
retourner (y) def F(b): globale x

Fin global x
Début x=b+10
x3 y=b*x
a5
aF(a) x=3
a=5
Ecrire (‘x=‘, x)
a=F(a)
Fin print("x=",x)