Les fonctions

Voici un exemple qui illustre la nécessité et l'intérêt de ce concept.

Supposons que vous deviez écrire un script qui calcule le volume d'un parallélépipède pour différentes valeurs de ses côtés. On pourrait écrire par exemple quelque chose comme :

# cas n°1
longueur = 5
largeur = 10
hauteur = 8
volume = longueur * largeur * hauteur
print(volume)

# cas n°2
longueur = 15
largeur = 12
hauteur = 10
volume = longueur * largeur * hauteur
print(volume)

# cas n°3
longueur = 10
largeur = 10
hauteur = 20
volume = longueur * largeur * hauteur
print(volume)
		

On constate tout de suite que l'on a écrit à peu près 3 fois la même chose, en ne modifiant à chaque fois que la valeur des variables...

Il serait donc judicieux de coder une seule fois les instructions communes aux différentes parties du script ci-dessus, tout en permettant à ces instructions de "s'adapter" à des valeurs de variables différentes : c'est le rôle d'une fonction, qui va "regrouper" en un même endroit du code la ou les instruction(s) qui réalisent le traitement :

		
		fonction permettant de calculer le volume :
			volume = longueur x largeur x hauteur
			renvoyer le résultat
			
		# cas n°1
		utiliser la fonction avec les valeurs 5, 10 et 8
		imprimer le résultat
		
		# cas n°2
		utiliser la fonction avec les valeurs 15, 12 et 10
		imprimer le résultat
		
		# cas n°3
		utiliser la fonction avec les valeurs 10, 10 et 20
		imprimer le résultat
		

Le script est ainsi beaucoup plus concis et lisible, sa maintenance et son débogage en seront très facilités !!

Une fonction est donc une sorte de "programme dans le programme".

Fonctions en Python et vocabulaire

Comme dans tout langage, une fonction en Python suit des règles d'écriture et d'utilisation précises.

Définition d'une fonction

Syntaxe

La définition d'une fonction correspond à l'écriture des instructions qui effectueront la tache pour laquelle elle est conçue.

def nom_de_la_fonction(paramètres):
	.....................
	Instruction(s)
	.....................
	return résultat
		

Pour l'exemple d'introduction, on pourrait ainsi définir une fonction calcul_volume() de la façon suivante :

def calcul_volume(longueur, largeur, hauteur): # la fonction a besoin de 3 paramètres pour faire le calcul du volume
	volume = longueur * largeur * hauteur
	return volume 
		

Quelques exemples de définition de fonctions

• une fonction qui calcule le volume d'une sphère, qui a comme paramètre le rayon ( r ) de la sphère, et qui renvoie un résultat de type float :

  
  def volume_sphere(r):
  	pi = 3.1415
  	volume = (4/3)*pi*r**3
  	return volume
  				

• Une fonction qui renvoie un message de bienvenue à un utilisateur, et qui a comme paramètre le nom de cet utilisateur :

  
  def message_de_bienvenue( nom ):
  	return 'Bonjour' + nom  + 'et bienvenue dans ce programme.'
  				

• Une fonction qui a deux nombres comme paramètres, et qui renvoie 2 résultats, le quotient et le reste de leur division :

  
  def division( n1, n2 ):
  	quotient = n1 // n2
  	reste = n1 % n2
  	return quotient, reste
  				

Appel d'une fonction

Principe

Pour "utiliser" ensuite une fonction une fois celle-ci définie, il faut l'appeler afin qu'elle s’exécute : si on définit une fonction sans l'appeler, rien ne se passera !

L'appel d'une fonction correspond au moment où on l’exécute; cet appel prend la forme d'une instruction généralement placée dans le corps principal du programme. ( mais pas obligatoirement : une fonction peut appeler une autre fonction ! )

L'appel d'une fonction se fait simplement en indiquant son nom, avec entre parenthèses, la liste du ( ou des ) arguments(s) à lui passer, dans le même ordre que celui des paramètres dans sa définition.( si la fonction n'a aucun paramètre, on ne lui passe aucun argument ! ).
Les arguments peuvent être des valeurs, des noms de variables, des expressions, etc...

nom_de_la_fonction(arg1, arg2,...)	
			

Mais attention, le fait qu'une fonction renvoie un résultat ne veut pas dire que le programme principal peut directement l'utiliser; lors de l'appel d'une fonction, il faut donc en plus "faire quelque chose" du résultat renvoyé par la fonction, comme l'afficher ou l'affecter à une variable ( sinon ce résultat est "perdu" ! ) :

print(nom_de_la_fonction(arg1, arg2,...))  # affichage de la valeur renvoyée par la fonction
	
result = nom_de_la_fonction(arg1, arg2,...)	# la variable result contiendra la valeur renvoyée par la fonction
			

Quelques exemples d'appel de fonction

# Définition des fonctions

def message_de_bienvenue( nom ):
	return 'Bonjour' + nom  + 'et bienvenue dans ce programme.'
	
def volume_sphere(r):
	pi = 3.1415
	volume = (4/3)*pi*r**3
	return volume

def division( n1, n2 ):
	quotient = n1 // n2
	reste = n1 % n2
	return quotient, reste
	
def calcul_volume(longueur, largeur, hauteur): # la fonction a besoin de 3 paramètres pour faire le calcul du volume
	volume = longueur * largeur * hauteur
	return volume 
	
# Programme principal

nom = input('Quel est votre nom ?')
print(message_de_bienvenue( nom ))

volume = volume_sphere(5) # calcul du volume d'une sphère de rayon r = 5
print( volume )

volume = calcul_volume(10, 5, 2)
print( volume ) 

quotient, reste = division(125, 23) # il faut passer 2 arguments, et récupérer 2 résultats !!
print('Quotient =', quotient)
print('Reste =', reste )
		

On peut remarquer qu'il n'y a pas d'ordre particulier pour la définition des fonctions, du moment que cette définition se fait avant l'appel de la fonction.

QCM d'entraînement

Exercices

Fonction cube ( un seul paramètre )

Fonction somme ( plusieurs paramètres )

Fonctions calculs multiples ( renvoi de plusieurs résultats )

Fonction conversion de température

Fonction à l'envers