Fonctions en Python

• Comprendre l'utilité et la structure d'une fonction en Python
• Savoir définir et appeler une fonction avec ou sans paramètres
• Être capable d'utiliser une valeur de retour (return)

Pourquoi utiliser des fonctions ? Définition et appel

Une fonction est un bloc de code nommé, conçu pour accomplir une tâche spécifique. On peut la voir comme une petite machine à laquelle on donne éventuellement quelque chose (des données en entrée), qui effectue un traitement, et qui peut nous rendre un résultat. L'intérêt principal est la réutilisation : une fois définie, on peut 'appeler' la fonction (l'utiliser) autant de fois qu'on le souhaite, sans avoir à réécrire son code. Cela rend le programme plus clair, plus court et plus facile à corriger ou à modifier. Pour définir une fonction, on utilise le mot-clé `def`, suivi du nom de la fonction (sans espaces, commençant par une lettre), de parenthèses `()` et d'un deux-points `:`. Le code de la fonction (son 'corps') est indenté (décalé vers la droite). Pour l'utiliser, il suffit d'écrire son nom suivi de parenthèses. Exemple concret : Vous créez un jeu où le personnage saute souvent. Au lieu d'écrire à chaque fois les 5 lignes de code pour gérer le saut (vérifier la touche, modifier la position, jouer un son, etc.), vous les mettez dans une fonction `sauter()`. Ensuite, un simple `sauter()` dans votre programme déclenchera toute l'action.

Personnaliser l'action : les paramètres et les arguments

Pour rendre une fonction plus flexible et puissante, on peut lui donner des informations spécifiques à chaque appel. Ces informations sont appelées des arguments. Lors de la définition de la fonction, on déclare des paramètres à l'intérieur des parenthèses. Les paramètres sont comme des variables locales qui attendent d'être remplies par les arguments fournis lors de l'appel. Par exemple, une fonction `bonjour(prenom)` a un paramètre `prenom`. Quand on l'appelle avec `bonjour('Léa')`, l'argument `'Léa'` est assigné au paramètre `prenom` à l'intérieur de la fonction. On peut avoir plusieurs paramètres, séparés par des virgules. L'ordre des arguments lors de l'appel doit correspondre à l'ordre des paramètres. On peut aussi donner des valeurs par défaut aux paramètres (ex: `def bonjour(prenom='collègue'):`). Si aucun argument n'est fourni pour ce paramètre, la valeur par défaut est utilisée. Cela permet d'avoir des fonctions qui peuvent s'adapter à différents contextes : une fonction `calculer_aire(longueur, largeur)` peut calculer l'aire de n'importe quel rectangle, pas juste d'un rectangle particulier.

Récupérer un résultat : l'instruction return

Une fonction peut effectuer des calculs ou des traitements, mais souvent, on a besoin de récupérer le résultat pour l'utiliser ailleurs dans le programme. C'est le rôle de l'instruction `return`. Quand Python rencontre `return` dans une fonction, il arrête l'exécution de la fonction et renvoie (retourne) la valeur qui suit le `return` à l'endroit où la fonction a été appelée. Cette valeur peut alors être stockée dans une variable, utilisée dans un calcul ou affichée. Une fonction sans `return` renvoie une valeur spéciale appelée `None` (qui signifie 'rien'). Exemple concret : Une fonction `calculer_prix_ttc(prix_ht)` qui reçoit un prix hors taxes, calcule le prix TTC (prix_ht * 1.2) et utilise `return prix_ht * 1.2` pour renvoyer ce résultat. Lors de l'appel, on peut écrire `mon_prix = calculer_prix_ttc(100)` pour stocker la valeur 120 dans la variable `mon_prix`. L'instruction `return` est cruciale pour séparer clairement le traitement (fait par la fonction) de l'utilisation du résultat (fait par le programme principal).

Applications pratiques

Mettons en pratique avec deux exemples progressifs. 1) Fonction simple sans retour : Créons une fonction `afficher_regles()` qui imprime trois lignes de règles pour un jeu. On la définit une fois, et on l'appelle au début du programme. 2) Fonction avec paramètres et retour : Créons une fonction `calculer_energie_cinetique(masse, vitesse)`. Elle utilise la formule physique E = 1/2 * masse * vitesse². Les paramètres sont `masse` (en kg) et `vitesse` (en m/s). À l'intérieur, elle calcule l'énergie cinétique et la renvoie avec `return`. Dans le programme principal, on appelle `energie = calculer_energie_cinetique(10, 5)` pour calculer l'énergie d'un objet de 10 kg allant à 5 m/s. La valeur 125 (joules) est stockée dans `energie`. On peut ensuite l'afficher ou l'utiliser dans d'autres calculs. 3) Défi : Essayez d'écrire une fonction `est_majeur(age)` qui prend un âge en paramètre et qui RETOURNE (n'affiche pas) `True` si l'âge est >= 18, et `False` sinon.