Exemple 2 : Effectuer des opérations sur les listes Concaténation de listes
1.10. Etude des fonctions
1.10.2. Les fonctions définies par l’utilisateur
1.10.2.1. Définir une fonction
Pour définir une fonction sous Python, on utilise le mot clé « def » pour déclarer le nom de la fonction. La syntaxe générale de définition d’une fonction est la suivante : :
def nomDeLaFonction(arg1, arg2, …, argN):
bloc d'instructions
def est le mot clé qui déclare le nom de la fonction. Ce mot est un mot réservé de python qui figure parmi les 33 mots réservés du langage python. Ce qui signifie qu’aucun nom d’objet ne doit prendre cette valeur. Il est utilisé uniquement pour définir une fonction.
A la suite du mot clé def, on indique le nom que doit prendre la fonction. Comme dans le cas des noms de variables, il est conseillé d’utiliser surtout des lettres minuscules, notamment au
72 début du nom. Et pour des noms composés, on peut utiliser des majuscules pour faire la transition entre les éléments qui composent le nom (ex : myFunction, fonctionTest, etc…).
Notons simplement que les noms d’objets commençant par une majuscule seront réservés au cas des classes.
Après avoir déclaré le nom de la fonction, on indique entre parenthèses les noms des arguments (paramètres) à partir desquels seront définies les instructions dans le corps du programme. Notons toutefois que la déclaration des noms des paramètres n’est pas obligatoire car il peut exister des programmes sans arguments ou du moins ceux-ci seront déclarés directement dans le corps du programme. Quoiqu’il en soit, la spécification des parenthèses reste obligatoire même si aucun paramètre n’est déclaré à l’intérieur. Attention également au symbole « : » qui marque la fin de la déclaration de la fonction et le début de la définition des instructions tout comme dans le cas de l’utilisation de la fonction « if » ou des boucles « for » ou « while ».
Après avoir déclaré la fonction à travers son nom et ses arguments, la seconde étape est la spécification des blocs d’instructions. Ceux-ci doivent être définis avec un certain décalage par rapport au mot clé def (indentation) tout comme dans le cas de la définition de la fonction « if » ou des boucles « for » ou « while ». Cette indentation des blocs d’instructions est obligatoire.
Dans cette section, nous allons étudier plusieurs variantes de la définition de fonctions notamment les fonctions définies sans arguments, les fonctions avec arguments se présentant sous forme de paramètres (constants), les fonctions avec arguments se présentant sous forme de variables, etc…
1.10.2.1.1. Définition d'une fonction simple sans argument
L’exemple ci-dessous illustre la définition d’une fonction simple sans argument. Le but de la fonction est d’afficher les 20 premières valeurs de la table de multiplication par 8.
Ainsi, on a :
def tableMultiplication8():
n = 1
while n <=20 : v=n*8
print(n, 'x', 8, '=', v, sep =' ') n = n +1
Quelques petites remarques peuvent être faites sur cette fonction. D’abord, la fonction est construite sur une boucle « while » définie à partir d’une variable n dont la valeur initiale est 1 et qui sera incrémentée jusqu’à ce que sa valeur atteigne 20. Ensuite, pour chaque valeur de n, on définit une variable v dont la valeur est le produit de 8 et n. Enfin, on affiche un ensemble de chaîne de caractères défini à l’intérieur de la fonction print().
73 Remarquons simplement que la variable n a été initialisée à l’extérieur de la boucle mais son incrémentation s’effectue de la boucle à la suite des blocs d’instructions spécifiés à l’intérieur de la boucle. On peut aussi remarquer deux niveaux d’indentation. Un premier niveau d’indentation est définie à partir de la déclaration def et un second niveau d’indentation est défini à la suite de la déclaration « while ». Cette règle reste valable dans tous les cas. Tout bloc d’instruction défini à la suite d’une déclaration def sera indenté. Et lorsque ce bloc d’instruction est formé d’une clause « if » ou d’une boucle « while » ou « for », les instructions appartenant à ces blocs serons indentées à leur tour et cela de façon séquentielle.
Pour exécuter la fonction tableMultiplication8() que nous venons de définir, il suffit de le référencer en indiquant son nom comme suit (n’importe où dans le programme principal).
tableMultiplication8() # appelle la fonction tableMultiplication8()
Signalons aussi qu’on pouvait aussi définir la fonction tableMultiplication8() à partir d’une boucle « for ». Dans ce cas, la fonction se présenterait comme suit :
def tableMultiplication8():
for n in range(1 ,21) : v=n*8
print(n, 'x', 8, '=', v, sep =' ')
tableMultiplication8() # appelle la fonction tableMultiplication8()
Ici, on utilise la fonction range(1, 21) qui renvoie une séquence de valeur allant de 1 à 20.
Chaque élément de cette séquence est récupérée et mutilplié par 8 avec la boucle « for ». Cet exemple montre donc que la boucle « while » et « for » sont alternatives dans de nombreuses situations.
1.10.2.1.2. Définition d'une fonction dont les arguments sont des paramètres
Un paramètre est une variable qui prend une valeur constante. Dans l'exemple précédent, nous avons élaboré une table de multiplication par 8. Nous pouvons généraliser cette fonction de sorte que qu’elle puisse renvoyée la table de multiplication de n’importe quel nombre spécifié comme argument. Ces nombres étant des paramètres, il s’agit alors de définir une fonction dont les arguments sont les paramètres. Voir l’exemple ci-dessous
def tableMultiplication(base):
n = 1
while n <=20 :
v=n*base
print(n, 'x', base, '=', v, sep =' ') n = n +1
74 tableMultiplication(2) # renvoie la table de multiplication par 2
tableMultiplication(8) # renvoie la table de multiplication par 8 tableMultiplication(11) # renvoie la table de multiplication par 11 1.10.2.1.3. Définition d'une fonction dont les arguments sont des variables
Une fonction dont les arguments sont des variables est une fonction dont les arguments sont des paramètres à la seule différence que dans le premier cas l’argument plusieurs valeurs successivement lors de l’appel du programme. Exemple : Considérons la fonction tableMutplication() qui a été définie précédemment comme suit :
def tableMultiplication(base):
n = 1
while n <=20 :
v=n*base
print(n, 'x', base, '=', v, sep =' ') n = n +1
Pour que l’argument base se comporte comme une variable, on va l’attribuer plusieurs valeurs à l’intérieur d’une nouvelle boucle « while » ou « for ».
Exemple : réalisons la table de multiplication des 20 premières valeurs de tous les nombres allant de 2 à 10.
On a : x = 2
while x <=10:
tableMultiplication(x)
print(" ") # insérer un espace entre deux tables x = x +1
Dans cet exemple, l’argument base devient simplement une variable qui prend les valeurs de (définie de 2 à 10).
1.10.2.1.4. Définition d'une fonction à plusieurs arguments
Dans les exemples précédents, les fonctions ont été définies à partir d’un argument unique (ou sans argument). Une fonction est généralement définie à partir de plusieurs arguments comme l’a montré que la syntaxe générale en début de section. Ces arguments peuvent être des paramètres ou des variables. Certaines peuvent être des arguments obligatoires et d’autres optionnels. Par ailleurs, lorsque la fonction est définie à partir de plusieurs arguments, ceux-ci doivent être séparés par des virgules.
Exemple : la fonction tableMultiplication () définie ci-dessus effectue la multiplication en considérant les 20 premiers éléments de la base (1 à 20). On peut généraliser cet intervalle en indiquant les valeurs de début et de fin en ajoutant deux argument supplémentaires comme suit :
75 def tableMultiplication(base, debut, fin):
n = debut
while n <=fin :
v=n*base
print(n, 'x', base, '=', v, sep =' ') n = n +1
Pour exécuter la fonction, on a :
tableMultiplication(10, 5, 20) # effectue la table de mutplication de 10 allant de 5 à 20
tableMultiplication(8, 6, 12) # effectue la table de mutplication de 8 allant de 6 à 12
NB : Dans cet exemple, base, debut et fin sont spécifiés comme paramètres. On peut aussi les traiter comme des variables en élaborant par exemple une boucle lors de l’exécution de la fonction. Exemple :
x = 2 y=5 z=20
while x <=10:
tableMultiplication(x ,y, z)
print(" ") # insérer un espace entre deux tables x = x +1
Cette boucle renvoie la table de multiplication de 2 à 10 (pour les éléments allant de 5 à 20).
1.10.2.1.5. Définition des valeurs par défaut pour les arguments d’une fonction
Lors de la définition d’une fonction, il est souvent conseillé de définir des valeurs par défaut pour certain arguments (notamment les arguments optionnels).
En effet, il est conseillé de rendre obligatoire certains arguments du programme et de renvoyer des messages d’erreur lorsque les valeurs ne remplissent pas un certain nombre de conditions bien définies (par exemple, l’argument ne doit pas être NULL, on ne doit pas utiliser une variable en caractère là une variable numérique est prévue, etc…). En revanche, on peut définir des valeurs par défaut pour des des arguments optionnels à condition que ces valeurs soient universelles c'est-à-dire valable quel que soit le contexte dans lequel le programme est exécuté..
En définissant les valeurs par défaut pour les arguments d’une fonction, il est possible d’appeler le programme avec une partie seulement des arguments attendus. Exemples :
def salutation(nom, titre ='Monsieur'):
76 print("Bonjour", titre, nom)
La fonction salutation ainsi définie a deux arguments : nom et titre. Une valeur par défaut a été définie pour l’argument. Ainsi lorsque la fonction salutation est appelée avec seulement l’argument nom (omettant l’argument), la fonction renvoie la valeur par défaut Monsieur.
Exemple :
salutation('Dupont') # renvoie Bonjour Monsieur Dupont
Mais lorsque la fonction est appelée avec les deux arguments, la valeur par défaut est ignorée.
Exemple :
En définissant les valeurs par défaut pour les arguments d’une fonction, il est possible d’appeler le programme avec une partie seulement des arguments attendus. Exemples :
salutation('Dupont', 'Mademoiselle')
NB : Les arguments sans valeur par défaut doivent être spécifiés avant les arguments avec les valeurs par défaut. Par exemple, la définition ci-dessous est incorrecte et renvoie une erreur lors de l’exécution.
def salutation(titre='Monsieur', nom):
1.10.2.1.6. Ordre des arguments lors de l’appel d’une fonction
Dans la plupart des langages de programmation, lors de l’appel d’une fonction les arguments doivent être spécifiés exactement dans le même ordre que celui dans lequel ils ont été indiqués lors de la définition de la fonction. Python fait cependant exception à cette règle en autorisant une souplesse beaucoup plus grande. En effet, on peut faire appel à la fonction en fournissant les arguments correspondants dans n’importe quel ordre, à condition de spécifier nommément les paramètres correspondants tout en assignant les valeurs. Exemple :
def salutation(nom, titre):
print("Bonjour", titre, nom)
Pour appeler cette fonction dans un ordre quelconque on fait :
salutation(titre='Mademoiselle', nom='Dupont') # renvoie Bonjour Mademoiselle Dupont
salutation(nom='Dupont', titre='Mademoiselle') # renvoie Bonjour Mademoiselle Dupont
salutation( nom='Dupont', titre='Monsieur') # renvoie Bonjour Monsieur Dupont
77 Ces exemples montrent que l’ordre de spécification des arguments lors de l’appel de la fonction n’est pas importante tant que les noms et les valeurs des arguments sont explicitement indiquées. Cette règle reste également valable lorsque les paramètres ont reçu tous une valeur par défaut, sous la forme déjà décrite ci-dessus. Cependant, l’ordre de définition doit être respecté dans le cas où certains arguments ont des valeurs par défaut et d’autres non. Il faut juste rappeler que les arguments sans valeurs par défaut doivent être déclarés avant les arguments avec valeurs par défaut