La fonction dans un programme informatique
En informatique, une fonction a un sens proche des fonctions en mathématiques, mais plus souple.
Fonction dans un programme informatique
Une fonction dans un programme informatique peut être considérée comme une boîte noire qui, à chaque entrée, fournit une sortie qui dépend de l'entrée.
En Python, on note deux nombres flottants x pour la taille en mètres et y pour le poids. Une fonction qui retournera l'indice de masse corporelle (IMC) calculera la grandeur y / x**2. x et y sont les entrées, y / x**2 est la sortie.
La syntaxe des fonctions en Python
Pour utiliser les fonctions en informatique, il faut d'abord les définir en programmant les instructions qu'elles exécutent au moment de l'appel.
Pour définir une fonction, il faut fournir à Python :
- le nom de la fonction ;
- les paramètres dont elle a besoin pour fonctionner, c'est-à-dire son entrée ;
- ce qu'elle renvoie, c'est la sortie.
En Python, on utilise la structure suivante :
\verb+ def <nom de la fonction>(<liste des entrees>) :+
\verb+ <instructions>+
\verb+ return <la sortie>+
Il faut placer le groupe d'instruction avec une série d'espace ou une tabulation pour chaque instruction de la fonction. Il faut penser au deux-points à la fin de la ligne qui contient de mot-clé def. Le mot-clé return permet à Python de savoir quand sortir de la fonction, et avec quelle valeur.
La fonction suivante calcule l'aire d'un rectangle, dont la longueur et la largeur sont indiquées en entrée :
\verb+ def aire_rectangle(longueur,largeur):+
\verb+ resultat = longueur * largeur+
\verb+ return resultat+
Il est possible de ne pas avoir besoin de paramètres, on met alors des parenthèses vides.
La fonction suivante retourne un nombre entier au hasard entre 1 et 10 quand elle est appelée :
\verb+ def nombreAleatoire() :+
\verb+ return math.randint(1, 10)+
Pour écrire une fonction qui permet de simuler un lancer de pièce, on fait appel à la fonction \verb+randint(1{,}2)+ qui renvoie 1 ou 2 de façon aléatoire. On décide alors d'attribuer à 1 une pièce qui tombe sur la face « pile » et à « 2 » une pièce qui tombe sur la face « face ».
\verb+ import random+
\verb+def lancerPiece() :+
\verb+ resultat = random.randint(1{,}2)+
\verb++
\verb+ if resultat == 1 :+
\verb+ return "pile"+
\verb+ else :+
\verb+ return "face"+
Cette fonction ne prend donc pas de paramètres, et donne en sortie soit la chaîne de caractère « pile », soit la chaîne de caractère « face ».
Pour écrire une fonction qui effectue la simulation de 100 lancers de pièce, on écrit une boucle qui va compter le nombre de piles obtenus pour 100 lancers.
\verb+def echantillon100Lancers() :+
\verb+ nombreDePiles=0 # On initialise la variable nombreDePiles a 0 avant la boucle+
\verb++
\verb+ for i in range(100) : # On effectue 100 lancers de pieces+
\verb+ simulationLancer = lancerPiece()+
\verb++
\verb+ if simulationLancer == "Pile" :+
\verb| nombreDePiles += 1|
\verb++
\verb+ return nombreDePiles+
On peut écrire une fonction qui calcule le nombre moyen de piles obtenus. On sait que l'on a effectué 100 lancers.
\verb+def frequenceDePile(nombreDePiles) :+
\verb+ return nombreDePiles/100.0 # Attention, si on met 100 sans decimale, +
\verb+ # la division sera considere comme entiere.+
L'utilisation des fonctions en informatique
Après avoir défini une fonction en Python, le développeur peut la réutiliser très simplement n'importe où dans son code.
Tant qu'une fonction n'est pas appelée dans un code, ses instructions ne sont pas exécutées. On doit donc faire appel à une fonction en utilisant son nom et en mettant entre parenthèses les paramètres demandés.
Le programme Python suivant affiche l'aire du rectangle de longueur et de largeur données par les variables \verb+x+ et \verb+y+ :
\verb+ def aire_rectangle(longueur, largeur):+
\verb+ return longueur * largeur+
\verb++
\verb+ x = 10+
\verb+ y = 5+
\verb++
\verb+ print("L'aire vaut", aire_rectangle(x, y))+
On peut aussi appeler une fonction en donnant directement les nombres qu'elle va utiliser sans passer par des variables :
\verb+ def aire_rectangle(longueur, largeur):+
\verb+ return longueur * largeur+
\verb++
\verb++
\verb+ print("L'aire vaut", aire_rectangle(10, 5))+
Les deux programmes vont retourner 50.
On cherche à vérifier s'il y a, en moyenne, autant de chance de tomber sur « pile » que sur « face » pour une pièce simulée dans un programme Python. Pour cela, on va simuler un grand nombre de lancers de pièce, sur plusieurs séries, puis calculer la moyenne du nombre de « pile » obtenus.
On peut utiliser les fonctions \verb+ lancerPiece() +, \verb+ echantillon100Lancers() + et \verb+ frequenceDePile() + définies dans la partie précédente.
\verb+for i in range(10) :+
\verb+ nombreDePiles = echantillon100Lancers() +
\verb++
\verb+ print(frequenceDePile(nombreDePiles))+
Voici un résultat obtenu :
0,51
0,49
0,53
0,5
0,62
0,41
0,47
0,52
0,41
0,36
L'ordre des paramètres est très important.
\verb+ def soustraction(a, b):+
\verb+ return a -b+
\verb++
\verb+ # Si on fait le test suivant :+
\verb+ print( soustraction(10, 5) == soustraction(5, 10))+
Python retournera \verb+False+.
Le nom des variables d'entrée ne concerne que l'intérieur de la fonction.
Dans le programme :
\verb+ def carre(x):+
\verb+ return x*x+
\verb++
\verb+ cote = 5+
\verb+ x=3+
\verb+ print(carre(cote))+
Le programme retourne \verb+25+ et n'est pas affecté par la ligne \verb+x=3+. Le nom \verb+x+ dans la fonction \verb+carre+ ne désigne pas la même variable que le nom \verb+x+ dans le programme principal.