Définir et appeler des fonctions

Pourquoi utiliser des fonctions ? Réutilisabilité et organisation

Les fonctions sont un élément essentiel de tout langage de programmation. Elles vous permettent de regrouper un ensemble d'instructions en un bloc réutilisable, que vous pouvez appeler à plusieurs endroits de votre programme. Cela évite la duplication de code, rend votre programme plus lisible, plus facile à maintenir et à déboguer.

Imaginez que vous ayez besoin de calculer l'aire d'un cercle à plusieurs endroits dans votre programme. Au lieu de réécrire la formule (π * rayon²) à chaque fois, vous pouvez définir une fonction `calculer_aire_cercle(rayon)` qui prend le rayon en argument et renvoie l'aire. Vous pouvez ensuite appeler cette fonction chaque fois que vous avez besoin de calculer l'aire d'un cercle.

Les fonctions favorisent également l'organisation de votre code. En regroupant les instructions en fonctions logiques, vous structurez votre programme en unités plus petites et plus faciles à comprendre. Cela rend votre code plus modulaire et plus évolutif.

Syntaxe de définition d'une fonction : `def`, paramètres et `return`

En Python, vous définissez une fonction en utilisant le mot-clé `def`, suivi du nom de la fonction, de parenthèses `()`, et de deux-points (`:`). Le corps de la fonction (le bloc d'instructions à exécuter) est indenté.

Les parenthèses peuvent contenir des paramètres (ou arguments), qui sont des variables que vous pouvez utiliser à l'intérieur de la fonction. Les paramètres permettent de rendre votre fonction plus flexible et plus générale, en lui permettant de traiter différentes données.

Une fonction peut renvoyer une valeur en utilisant le mot-clé `return`. La valeur renvoyée peut être de n'importe quel type (nombre, chaîne de caractères, liste, etc.). Si vous n'utilisez pas `return`, la fonction renvoie implicitement `None`.

Par exemple : `def additionner(a, b): return a + b`. Cette fonction prend deux paramètres, `a` et `b`, et renvoie leur somme.

Nous verrons comment définir des fonctions avec et sans paramètres, comment utiliser `return`, et comment appeler des fonctions.

Arguments positionnels et arguments nommés

Lorsque vous appelez une fonction, vous devez lui passer des arguments qui correspondent aux paramètres définis dans la définition de la fonction. Il existe deux types d'arguments : les arguments positionnels et les arguments nommés.

Les arguments positionnels sont passés dans l'ordre dans lequel les paramètres sont définis. Par exemple, si vous avez une fonction `def saluer(nom, age):`, vous devez passer le nom en premier et l'âge en second : `saluer('Alice', 30)`.

Les arguments nommés sont passés en spécifiant le nom du paramètre suivi du signe égal (`=`) et de la valeur. Par exemple : `saluer(age=30, nom='Alice')`. L'ordre des arguments nommés n'a pas d'importance.

Vous pouvez mélanger les arguments positionnels et nommés, mais les arguments positionnels doivent toujours être placés avant les arguments nommés.

Nous verrons comment utiliser les arguments positionnels et nommés, et quels sont les avantages de chaque approche.

Valeurs par défaut des arguments

Vous pouvez spécifier des valeurs par défaut pour les paramètres d'une fonction. Si un argument n'est pas passé lors de l'appel de la fonction, la valeur par défaut est utilisée. Cela rend votre fonction plus flexible et plus facile à utiliser.

Pour spécifier une valeur par défaut, vous utilisez le signe égal (`=`) après le nom du paramètre dans la définition de la fonction. Par exemple : `def saluer(nom, age=18):`. Dans cet exemple, si vous appelez `saluer('Alice')`, la valeur par défaut `18` sera utilisée pour le paramètre `age`.

Les paramètres avec des valeurs par défaut doivent toujours être placés après les paramètres sans valeurs par défaut dans la définition de la fonction.

Nous verrons comment utiliser les valeurs par défaut, et comment éviter les pièges courants liés aux valeurs par défaut mutables (comme les listes ou les dictionnaires).

Documentation des fonctions (docstrings)

Il est important de documenter vos fonctions pour expliquer ce qu'elles font, comment les utiliser, et quels sont les types des paramètres et de la valeur de retour. En Python, vous pouvez documenter une fonction en utilisant une docstring (chaîne de documentation).

Une docstring est une chaîne de caractères placée en première ligne du corps de la fonction, juste après la ligne `def`. Elle est délimitée par des triples guillemets simples (`'''`) ou des triples guillemets doubles (`"""`).

La docstring doit contenir une description concise de la fonction, suivie d'une description plus détaillée si nécessaire. Elle peut également inclure des informations sur les paramètres (avec le type attendu), la valeur de retour (avec le type), et les exceptions potentielles.

Les docstrings sont utilisées par les outils de documentation automatique (comme Sphinx) et par les IDE pour afficher des informations d'aide sur les fonctions. Elles sont également accessibles en utilisant la fonction intégrée `help()` ou l'attribut `__doc__` de la fonction.

Nous verrons comment écrire des docstrings claires et complètes, et comment utiliser les conventions de style recommandées pour les docstrings (comme le format reStructuredText ou le format Google).