Actions et objets élémentaires d`un algorithme

DAIGL – Développement – Fonctions et procédures
Fonctions et procédures
1- Fonctions standards (fonctions dites "natives")
Exemple : Calculer la racine carrée d'un nombre dans un algorithme ou dans un script Python.
Deux solutions :
●Ecrire une suite d'instructions permettant de calculer la racine carrée.
●Faire appel à un "sous-programme" auquel on soumet le nombre dont on veut connaître la
racine carrée. Ce type de programme se nomme une fonction. C'est le principe de la "boîte
noire" : La donnée produite en sortie est fonction des données en entrée. On sait ce que fait la
"boîte noire" mais on ne sait pas comment elle le fait.
On peut prendre comme exemple la manipulation des chaînes de caractères qui fait appel à des
fonctions standards (fonctions déjà écrites) :
Algorithmique :
●SSCHAINE()
●LONGUEUR()
●RANG()
●…
Langage Python :
●len()
●find()
●…
La notion de fonction permet la "réutilisation" du code. En effet, il n'est pas nécessaire de réécrire le
code du programme permettant de calculer la longueur d'une chaîne dans l'algorithme à chaque fois
que l'on en a besoin. Il suffit de faire appel à la fonction en lui passant en paramètre la chaîne dont on
désire calculer la longueur. De plus, utiliser des fonctions permet de "découper" le programme, ce qui
en facilite la lecture et la maintenance.
Utilisation d'une fonction standard
L’utilisation d’une fonction déjà existante au sein d’un algorithme ou d'un script Python nécessite de
connaître :
●son nom,
●le ou les paramètres (nombre, ordre et types),
●et le type du résultat retourné.
Exemple : Utiliser la fonction existante dont le rôle est de calculer le nombre de caractères d’une
chaîne de caractères :
●le nom : LONGUEUR.
●le paramètre à passer à cette fonction : la chaîne de caractères dont on veut connaître la
longueur.
●le type du résultat : retourne une valeur de type ENTIER qui représente la longueur de la
chaîne de caractères.
LONGUEUR ( "python" ) retourne la valeur 6
Le prototype d'une fonction permet d'indiquer son nom, le type de la valeur retournée ainsi que les
paramètres associés (types et ordre). Le prototype défini pour l'algorithme est aussi valable pour le
script Python.
page 1
Fonction
entrée 1
entrée 1
entrée n
sortie

DAIGL – Développement – Fonctions et procédures
Exemple : Fonction LONGUEUR ( Chaîne ) : Entier
De plus, il est possible d'indiquer dans le prototype d'une fonction, les noms des paramètres de façon à
en faciliter la compréhension.
Exemple : Fonction LONGUEUR ( source : Chaîne ) : Entier
La fonction effectue son traitement, puis retourne le résultat du traitement que l'on peut donc affecter à
une variable. Cette fonction peut aussi être utilisée plusieurs fois dans l'algorithme.
Exemple :
Algo Exemple_appel_LONGUEUR
Variables :
nom_1 , nom_2 : CHAINE
nb_caracteres : ENTIER
Début
nom_1 <- "Martin"
nb_caracteres <- LONGUEUR ( nom_1 ) # Evaluation d'une variable
Afficher ( nb_caracteres )
Afficher ( "Saisir un nom : " )
Saisir ( nom_2 )
nb_caracteres <- LONGUEUR ( nom_2 ) # Evaluation d'une variable
Afficher ( nb_caracteres )
nb_caracteres <- LONGUEUR ( "Wallace" ) # valeur littérale
Afficher ( nb_caracteres )
Fin
2- Fonctions "utilisateur"
Le nombre de fonctions standards est (très) limité. On a donc besoin tôt ou tard de développer au sein
d'un algorithme ses propres fonctions. Ce sont les fonctions utilisateurs.
Les fonctions permettent :
●… de remplacer, dans un algorithme, une séquence d'instructions apparaissant plusieurs fois.
Exemple : Recherche de l'élément le plus petit d'un tableau de trois entiers par une unique
séquence d'instructions qui pourra être appelée autant de fois que nécessaire dans l'algorithme
(Réutilisation)
Algo Exemple_Minimum
Variables :
tab_1[3] : Entier
tab_2[3] : Entier
plus_petit_1 : Entier
plus_petit_2 : Entier
Début
tab_1 = ( 4 , 23 , 5 )
tab_2 = ( 78 , 5 , 95 )
plus_petit_1 <- Minimum ( tab_1 )
Afficher ( plus_petit_1 )
plus_petit_2 <- Minimum ( tab_2 )
Afficher ( plus_petit_2 )
Fin
●… de clarifier l'algorithme en "déplaçant" les séquences d'instructions permettant de réaliser
des traitements de l'algorithme principal vers des fonctions utilisateurs (décomposition du
programme en plusieurs "blocs d'instructions"). L'application peut être vue alors comme un
"assemblage" de fonctions (et/ou de procédures).
page 2

DAIGL – Développement – Fonctions et procédures
2.1. Déclaration d'une fonction "utilisateur" :
[Algo] Syntaxe :
Fonction nom_fct ( noms_pmt : types_pmt ) : type_retour
Variable(s):
variable(s)_locale(s)
Début
instruction(s)
...
retourner valeur
Fin
Une fonction est caractérisée par son nom, le nom et le type des paramètres d'entrée que le programme
appelant fournit à cette fonction lorsqu'il y fait appel, ainsi que par le type du résultat que celle-ci
retourne.
[Python] Syntaxe :
def nom_fct ( noms_pmt ) :
instruction(s)
...
return valeur
2.2. Utilisation d'une fonction "utilisateur" :
L'utilisation d'une fonction "utilisateur" se fait de la même manière que l'utilisation d'une fonction
standard. Il suffit, lors de l'appel de la fonction, de communiquer la valeur des paramètres sur les quels
travaillera la fonction.
Pour exemple, la fonction incrémenter() a pour rôle de retourner l'entier passé en paramètre
incrémenté d'une unité.
Prototype : Fonction incrémenter(Entier) : Entier
[Algo]
Corps de la fonction :
Fonction incrémenter ( indice : Entier ) : Entier
Début
indice <- indice + 1
retourner indice
Fin
Programme principal :
Algo Boucle
Variable(s):
cpt : Entier
Début
cpt <- 0
TantQue cpt < 10 Faire
afficher ( cpt )
cpt <- incrémenter( cpt )
Ftq
Fin
[Python]
# Fonctions
def incrementer( indice ) :
indice = indice + 1
return indice
# Programme principal
page 3

DAIGL – Développement – Fonctions et procédures
if __name__ == "__main__" :
cpt = 0
while cpt < 10 :
print cpt
cpt = incrementer( cpt )
Remarque : Pour bien distinguer le code des fonctions utilisateur du programme principal et faciliter
la lecture des fichiers sources, il est recommandé de placer le code du programme principal dans le
bloc d'instructions validant la condition : if __name__ == "__main__" :.
3- Procédures "utilisateur"
De même qu'une fonction, une procédure représente une séquence d'instructions, afin :
●de découper harmonieusement un algorithme pour en faciliter la lisibilité,
●éviter de répéter plusieurs fois la même séquence d'instructions.
Cependant, contrairement à une fonction, une procédure ne retourne jamais de résultat. Elle admet
des paramètres en entrée et peut, dans certains cas, modifier la valeur de ces paramètres au cours de
son exécution.
Déclaration d'une procédure utilisateur :
[Algo] Syntaxe :
Procédure Nom_procédure ( types_passage nom_par : type_par )
Variable(s):
variable(s)_locale(s)
Début
instruction(s)
Fin
Une procédure est caractérisée par un nom ainsi que par une liste de paramètres d'entrée définis par
leur nom et leur type. Le passage des paramètres indique, pour chaque paramètre, la façon dont va être
utilisé le paramètre dans la procédure:
●e : Paramètre en entrée exclusive : on ne souhaite pas modifier la valeur de la variable
transmise (consultation).
●s : Paramètre en sortie exclusive : signifie qu'on attend de la procédure qu'elle initialise la
variable transmise ou qu'elle en modifie sa valeur (modification).
●e/s : Paramètre en entrée-sortie : on attend de la procédure qu'elle utilise la variable passée
comme paramètre puis qu'elle en modifie la valeur (consultation et modification).
Utilisation des procédures
L'utilisation des procédures s'effectue de la même façon que l'utilisation des fonctions, sauf que la
procédure ne renvoie pas de résultat. La fonction/procédure appelante communique à la procédure
appelée les paramètres qui seront utilisés dans le traitement effectué par celle-ci.
[Python]
Il n'existe pas de différence entre procédures et fonctions en Python. Un sous-programme Python qui
retourne une valeur est une fonction. Au contraire, un sous-programme qui ne retourne pas de valeur
est une procédure.
Types de passages de paramètres en sortie ou en entrée-sortie : En Python, le type de passage
(entrée, entrée-sortie, ou sortie) est choisi par l'interpréteur selon le type de la donnée concernée.
type de données type de passage
entrée entrée-sortie
int, str, float, tuple, bool X
list X
page 4

DAIGL – Développement – Fonctions et procédures
4- Variables locales et variables globales
[Généralités]
Une variable définie au sein d'une procédure ou d'une fonction est dite locale car sa valeur n'est
définie qu'au sein de la procédure ou de la fonction. On ne peut donc pas utiliser cette variable en
dehors de la procédure ou de la fonction dans laquelle elle est définie.
Une variable définie au sein de l'algorithme du programme principal est elle aussi locale car elle n'est
connue que dans l'algorithme principal (elle n'est pas connue des procédures et fonctions).
Il est parfois nécessaire de déclarer dans certaines situations des variables qui seront connues de tous
les algorithmes (programme principal + fonctions + procédures) du programme. De telles variables
sont appelées variables globales. Les variables globales se déclarent en début d'algorithme en ajoutant
au mot clé Variable le mot clé Globale.
Toutefois, dans une procédure ou une fonction, si une variable locale porte le même nom qu'une
variable globale, c'est la variable locale qui est utilisée (la variable locale est prioritaire par rapport à
la variable globale).
variable locale variable globale
Durée de vie
égale au temps d'exécution de la
fonction ou de la procédure dans
laquelle est elle déclarée.
égale au temps d'exécution du
programme.
Visibilité
n'est vue (et n'est accessible) que
dans le fonction ou la procédure
dans laquelle elle est déclarée.
accessible dans tout le
programme que ce soit dans le
programme principal, dans une
fonction ou encore dans une
procédure.
[Algo] La déclaration d'une ou plusieurs variables globales se fait après la déclaration des constantes et
avant la déclaration des variables locales du programme principale :
Algo titre_algorithme # Algorithme principal
Constante(s) :
# déclaration des constantes
Variable(s) globale(s) :
# déclaration des variables globales
Variable(s) :
# déclaration des variables locales de l'algorithme principal
Début
# instructions
Fin
[Python] Au sein d'un script Python, la portée des variables est déterminée selon les trois cas
suivants :
Cas 1 - Accès en lecture
Par défaut, une variable utilisée dans un programme Python est visible dans toutes les fonctions
déclarées dans le même bloc. Dans le cas où dans une fonction, cette variable n'est accédée qu'en
lecture (affichage, opérande dans un calcul...), il s'agit de la même zone mémoire, et donc de la même
variable. Mais celle ci est accessible uniquement en lecture.
Exemple :
Code source : cas1.py Trace d'exécution
def typeDeFruit() :
print "Dans la fonction :",fruit
if __name__ == "__main__" :
fruit = "fraise"
print "Avant l'appel :",fruit
typeDeFruit()
print u"Après l'appel :",fruit
$ python cas1.py
Avant l'appel : fraise
Dans la fonction : fraise
Après l'appel : fraise
page 5