6 - Les Fonctions

Une fonction est une portion de code qui effectue une tâche ou un calcul relativement indépendant du reste du programme. Une fonction comporte des paramètres d’entrée sur lesquels elle travaille avant de retourner une valeur de sortie qui peut être stockée dans une variable. Si la fonction ne retourne rien (None), on parlera plutôt de procédure. Une fonction est un sous-programme réutilisable partout dans le code. Il est donc inutile de réécrire des instructions identiques. Il suffit de les inclure dans une fonction et d’appeler cette dernière à chaque fois que cela est nécessaire.

 

Les fonctions prédéfinies

Nous avons déjà utilisé quelques fonctions sans le savoir :

  • print() : affiche n’importe quel nombre de valeurs passées en arguments.
  • input() : met le programme en attente jusqu’à ce que l’utilisateur entre une chaîne de caractères puis presse la touche “Entrée”. Alors, le programme redémarre et affiche la chaîne de caractères.
  • int() : transforme une chaîne de caractères en nombre entier (si celle-ci s’y prête) ou un nombre décimal en nombre entier (en ignorant ce qui est après la virgule).
  • float() : transforme une chaîne de caractères en nombre décimal (si celle-ci s’y prête) ou un nombre entier en nombre décimal (exemple : 9.0)
  • str() : transforme un nombre entier ou un nombre décimal en chaîne de caractères.

Créer une fonction

Pour créer une fonction, on utilise le mot-clé def. Voici comment une fonction est construite.

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-


 def fonction(parametre_1, parametre_2,...): # deux-points obligatoires

     "Docstring" # documentation qui résume le rôle de la fonction

     "Bloc_d_instruction # celui-ci est indenté

     return resultat  # valeur retournée

 

Pour appeler la fonction et stocker dans une variable la valeur qu’elle retourne, il suffit d’écrire.

 variable = nom_de_la_fonction(parametre_1, parametre_2,...)

 

Prenons l’exemple d’une fonction qui divise par deux la valeur passée en argument.

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def divide_by_two(n):

     "fonction qui divise par deux le nombre n passé en argument" 

     return n/2

 

 #-----Programme principal---------------

 

 var = 8   # Variable à laquelle j'affecte le nombre entier 8

 divided_var = divide_by_two(var) # Appel de la fonction

 print(divided_var)

4.0

Explication

  • Je déclare la variable divided_var qui va stocker le résultat retourné par la fonction.
  • Cette fonction a un paramètre passé en argument. Il s'agit de la variable var qui stocke le nombre entier 8.
  • 8 est envoyé à la fonction et est stocké par la variable n
  • La fonction "retourne" n divisé par deux, c'est-à-dire 4.0.
  • print() affiche le contenu de la variable divided_var.

ATTENTION! La fonction doit toujours précéder l’appel de fonction.

 

Passer plusieurs arguments à une fonction

Il est possible de passer plusieurs arguments à une fonction.

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def divide(numb1, numb2):

     "fonction qui divise par numb2 le nombre numb1" 

     return numb1/numb2

 

 #-----Programme principal---------------

 

 var1, var2 = 16, 8  # déclaration de deux variables

 divided_var = divide(var1, var2) # Appel de la fonction

 print(divided_var)

 

2.0

Nombre d’arguments indéterminés

Il est possible de passer à une fonction un nombre indéterminé d’arguments. Pour ce faire, il suffit de rajouter un astérisque devant le paramètre qui recevra les arguments. En fait, ce paramètre est une liste vide qui va stocker les nombres qu'on lui donne.

Quant à la fonction, elle est chargé grâce à une boucle for de rajouter 2.5 à chaque élément de la liste. 

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def add_twoPointFive(*args):

     "fonction qui rajoute 2.5 à chaque élément de la liste args"

     for arg in args:

         print(arg + 2.5)

 

 #-----Programme principal---------------

 

 add_twoPointFive(1, 3, 5, 7, 9, 11, 13)

 

 

j'exécute ce code dans un terminal.

 3.5

 5.5

 7.5

 9.5

 11.5

 13.5

 15.5

 

 

 

 

 

 

La fonction add_twoPointFive() ne renvoie aucun résultat dans une variable. C'est la fonction print() qui se charge d'afficher le résultat des opérations sur le terminal. Pour s'en convaincre, il suffit de modifier la dernière ligne. Nous allons stocker le résultat de la fonction add_twoPointFive() dans une variable et afficher cette dernière.

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def add_twoPointFive(*args):

     "fonction qui rajoute 2.5 à chaque élément de la liste args"

     for arg in args:

         print(arg + 2.5)

 

 #-----Programme principal---------------

 

 var = add_twoPointFive(1, 3, 5, 7, 9, 11, 13)

 print(var)

 

 3.5

 5.5

 7.5

 9.5

 11.5

 13.5

 15.5

 None

 

 

 

 

 

 

C'est quoi ce None? Ça veut dire rien en anglais et c'est ce que la variable var contient... C'est logique, il n'y a pas de return! En fait, il y a bien un return mais il doit se cacher dans la fonction print().

Commet faire alors pour retourner le résultat à la variable var? Essayons de remplacer print() par return...

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def add_twoPointFive(*args):

     "fonction qui rajoute 2.5 à chaque élément de la liste args"

     for arg in args:

         return arg + 2.5

 

 #-----Programme principal---------------

 

 var = add_twoPointFive(1, 3, 5, 7, 9, 11, 13)

 print(var)

 

3.5

Seule le premier élément est traité par la fonction et renvoyé à la variable var. Pourquoi? Au départ, var est définie comme la variable qui va stocker le résultat retourné par la fonction qui lui est affectée. Et de fait, elle stocke le premier résultat qui lui est renvoyé. La fonction avec ses paramètres a été "écrasé" par 3.5. add_twoPointFive() n'existe plus et ne peut donc pas traiter les autres éléments de la boucle.

Alors comment faire pour qu'au bout du compte, tous les éléments de la liste args soit traités et renvoyés à var? Eh bien, il faut créer une liste à l'intérieur de la fonction et la retourner à var après avoir traité le dernier élément. Je sais, nous n'avons pas encore abordé les listes mais tant pis, je vous montre quand-même.

 

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def add_twoPointFive(*args):

     "fonction qui rajoute 2.5 à chaque élément de la liste args"

     new_list = list()

     for arg in args:

         new_list.append(arg + 2.5)

     return new_list

 

 #-----Programme principal---------------

 

 var = add_twoPointFive(1, 3, 5, 7, 9, 11, 13)

 print(var)

 

[3.5, 5.5, 7.5, 9.5, 11.5, 13.5, 15.5]

Explication

  • Je créé une liste vide que j'appelle new_list.Pour la déclarer, j'aurais très bien pu écrire new_list = []. Ça fonctionne aussi, mais nous verrons cela plus en détail dans un prochain chapitre.
  • Grâce à un outil puissant qu'on appelle la méthode append(), je rajoute à la nouvelle liste chaque élément de la liste args auquel j'ai rajouté 2.5.
  • La liste args est traitée. La boucle s'arrête. Nous nous retrouvons avec une new_list remplie de tous les éléments.
  • En dehors de la boucle, j'utilise return pour renvoyer la liste complète à var.
  • La new_list écrase la fonction add_twoPointFive() mais ce n'est pas bien grave car on en a plus besoin! On a tous les éléments.

 

À quoi sert la docstring?

La docstring est une chaîne de caractères indentée juste après la déclaration d’une fonction. Elle fournit une documentation accessible grâce à la fonction help(). Dans un terminal interactif python3, essayez par exemple ceci: help(list). Vous obtiendrez tout un tas d'informations qui deviendront plus claires au fil des chapitres.

 

Paramètres par défaut

Une fonction peut avoir des paramètres avec des  arguments par défaut. Ces paramètres ne doivent pas précéder les paramètres sans arguments par défaut, sous peine de lever une exception.

Voici deux exemples. Dans l’appel de fonction du premier exemple, je ne passe qu’un seul argument qui correspond au premier paramètre de la fonction. Le deuxième paramètre utilise l’argument par défaut (2).

 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def divide(numb, half=2):

     "fonction qui divise par 2 par défaut"

     return numb/half

 #-----Programme principal---------------

 var = 10

 divided_var = divide(var) # Je passe une seule valeur en argument

 print(divided_var)

5.0

Dans ce deuxième exemple, je vais passer deux variables à la fonction en modifiant l’argument du deuxième paramètre. Je dois préciser quel paramètre est modifié (half = var2). 

 #!/usr/bin/env python3

 # -*- coding: utf8 -*-

 

 #-----Fonction---------------------------


 def divide(numb, half=2):

     "fonction qui divise par 2 par défaut"

     return numb/half

 

 #-----Programme principal---------------

 

 var1, var2 = 27, 3

 divided_var = divide(var, half=var2)

 print(divided_var)

9.0

Si je crée une fonction en déclarant un paramètre par défaut avant les autres paramètres, par exemple divide(half=2, numb), Python retourne une exception et le programme ne s’exécute pas:

non-default argument follows default argument

event Date de dernière mise à jour : 04/03/2020

  • Aucune note. Soyez le premier à attribuer une note !

Ajouter un commentaire

Anti-spam
 
expand_less