5. Les fonctions (langage Python)

Sommaire

  1. Les fonctions prédéfinies
  2. Créer une fonction
  3. Passer plusieurs arguments à une fonction
  4. Nombre d’arguments indéterminé
  5. Paramètres par défaut

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.

1. 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() : interrompt le programme 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 en chaîne de caractères.

2. Créer une fonction

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

def nomDeLaFonction(paramètre1, paramètre2, ...):
    "Docstring"
    Bloc_d_instruction_indenté
    return résultat
  • Ligne n° 1: Ne pas oublier les deux petits points avant d’indenter le bloc d’instructions!
  • Ligne n° 2: La docstring est une documentation qui explique ce que la fonction réalise.
  • Ligne n° 3: Le bloc d’instructions doit être indenté.
  • Ligne n° 4: Valeur retournée

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

variable = nomDeLaFonction(paramètre1, paramètre2, ...)

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

#!/usr/bin/env python3
# -*- coding: utf8 -*-

# Function
def divisionByTwo(x):
    "dividing a number by two"
    return x/2

# Main program
number = 8
divided_number = divisionByTwo(number)
print(divided_number)

La variable de départ est number (ligne n° 10). À la ligne suivante, j’appelle la fonction divisionByTwo et je lui passe la variable number en paramètre. Le résultat sera stocké dans la variable divided_number que je peux afficher en utilisant la fonction print(). Attention! Dans le code, la fonction doit toujours précéder l’appel de fonction. Je code d’abord la fonction. Puis, je code l’appel de fonction. Vous noterez que le résultat obtenu est 4.0, c’est-à-dire un nombre avec une écriture décimale. Pour obtenir le nombre entier si et seulement si la valeur après le point est zéro, on peut modifier la ligne n° 7 et faire appel aux fonctions int() et float(), comme ceci:

return int(x/2) if int(x/2) == float(x/2) else float(x/2)

Ou bien comme ceci :

if int(x/2) == float(x/2):
    return int(x/2)
else: 
    return float(x/2)

Si la variable number stocke la valeur 8, c’est 4 qui va s’afficher. Si la valeur stockée est 9, le résultat sera 4.5.

Pour afficher la documentation d’une fonction (docstring), faites appel à la méthode __doc__:

print(divisionByTwo.__doc__)
dividing a number by two

3. Passer plusieurs arguments à une fonction

Il est possible de passer plusieurs arguments à une fonction :

#!/usr/bin/env python3
# -*- coding: utf8 -*-

# Function
def division(x, y):
    "Dividing x by y"
    return int(x/y) if int(x/y) == float(x/y) else float(x/y)

# Main program
number = 15
divider = 3
divided_number = division(number, divider)
print(divided_number)
5

4. Nombre d’arguments indéterminé

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, cela a pour effet de créer un tuple, c’est-à-dire une liste qu’il n’est pas possible de modifier après sa déclaration. Créons une fonction qui met un nombre n à l’exposant n + 1 et passons lui un nombre indéfini d’arguments. Les résultats seront stockés dans une liste que je déclare à la ligne n° 7. C’est la fonction append() qui rajoute les résultats à la liste. Nous verrons les listes de façon plus détaillée dans un prochain chapitre.

#!/usr/bin/env python3
# -*- coding: utf8 -*-

# Function
def power(*args):
    "set a number to its power"
    result = []
    for a in args:
        result.append(a**(a + 1))
    return result

# Main program
power(1, 2, 3, 4, 5, 6)
[1, 8, 81, 1024, 15625, 279936]

Veuillez noter qu’à la ligne n° 9, vous pouvez très bien utiliser la fonction pow() qui accepte deux arguments, à savoir le nombre et l’exposant. Cela nous donne:

result.append(pow(a, a + 1))

5. 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. Les deux autres paramètres utilisent leur argument par défaut (2 et 3).

  • Exemple n° 1
#!/usr/bin/env python3
# -*- coding: utf8 -*-

# Exemple n° 1
# Function
def divide(x, divider=2, add=3):
    "dividing a number by a given divider (default choice: 2)"
    
    x +=  add
    if int(x/2) == float(x/2):
        return int(x/2)
    else: 
        return float(x/2)

# Main program
number = 9
divided_number = divide(number)
print(divided_number)
  • Exemple n° 2

Dans ce deuxième exemple, lors de mon appel de fonction, je passe trois variables en arguments.

#!/usr/bin/env python3
# -*- coding: utf8 -*-

# Exemple n° 2
# Function
def addAndDivide(x, divider=2, add=3):
    "add a number to another one and divide the result"
    
    x += add
    if int(x/divider) == float(x/divider):
        return int(x/divider)
    else: 
        return float(x/divider)

# Main program
divided_number = addAndDivide(9, 3, 9)
print(divided_number)

Je peux les passer dans l’ordre:

divided_number = divide(9, 3, 4)

Mais si je ne connais pas l’ordre, je dois préciser quels sont les paramètres par défaut dont je modifie la valeur. Dans ces conditions, je peux déclarer mes paramètres par défaut sans me soucier de l’ordre.

divided_number = divide(9, add=3, divider=4)

Seule contrainte: il faut que les paramètres qui ont une valeur par défaut soient déclarés après les paramètres qui n’ont pas de valeur par défaut, sinon le code va planter.

SyntaxError: positional argument follows keyword argument

Conclusion

Les fonctions sont très pratiques car elles permettent de ne pas réécrire le même code. Il suffit d’appeler la fonction en lui passant les arguments dont elle a besoin pour qu’elle puisse renvoyer son résultat.

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s