Fonction Python : définir, appeler et réutiliser du code sans confondre paramètres et arguments
Une fonction Python donne un nom à une tâche et permet de la réutiliser sans recopier les mêmes instructions. Pour retenir le principe, suivez ce chemin : on la définit avec def, on l’appelle par son nom, on lui transmet éventuellement des données, puis elle peut renvoyer un résultat avec return. Ces mécanismes rendent un script plus lisible, plus facile à tester et plus simple à modifier.
Une fonction organise une tâche précise
Dans un programme, une fonction regroupe un bloc d’instructions qui répond à un besoin identifiable : calculer un prix, vérifier un mot de passe, formater un nom ou afficher un message. Au lieu d’écrire cette logique à plusieurs endroits, on la centralise une fois et on l’appelle chaque fois que nécessaire. Cette organisation réduit la répétition et facilite la maintenance du code.
Python possède des fonctions natives, déjà disponibles dans le langage, comme print(), len() ou round(). Vous pouvez aussi créer vos propres fonctions : elles portent alors les règles propres à votre projet. Une méthode ressemble à une fonction, mais elle est liée à un objet. Par exemple, texte.upper() est une méthode appliquée à une chaîne de caractères.
Fonction, procédure et résultat exploitable
Dans l’usage courant, une fonction peut produire un résultat ou effectuer une action. Une fonction qui calcule une remise et renvoie le montant obtenu est une « vraie » fonction au sens pratique. Une fonction qui se contente d’afficher un message agit davantage comme une procédure. En Python, les deux s’écrivent avec def ; la différence tient principalement à la présence de return.
| Élément | Rôle | Exemple d’usage |
|---|---|---|
| Fonction native | Outil fourni par Python | len("chat") renvoie 4 |
| Fonction créée | Règle définie pour le projet | Calculer une taxe ou un total |
| Procédure | Action sans résultat explicitement renvoyé | Afficher une confirmation |
| Retour de valeur | Résultat récupérable après l’appel | Stocker un calcul dans une variable |
Définir et appeler une fonction avec def
La définition commence par le mot-clé def, suivi d’un nom, de parenthèses et de deux-points. Le bloc d’instructions placé juste après doit être indenté. Cette indentation n’est pas décorative : elle indique à Python quelles lignes appartiennent à la fonction. Une ligne mal indentée peut donc empêcher l’exécution du script ou modifier la structure du bloc.
Une structure minimale s’écrit ainsi : def saluer():, puis, sur la ligne suivante avec un retrait, print("Bonjour"). Cette définition ne lance encore rien. Pour exécuter le bloc, il faut appeler la fonction plus loin dans le script avec saluer(). Cette séparation entre définition et appel évite une confusion fréquente chez les débutants : écrire une fonction ne suffit pas à déclencher son exécution.
Choisir un nom qui explique l’intention
Préférez un verbe ou une expression descriptive en minuscules, avec des mots séparés par des traits de soulignement : calculer_total, envoyer_notification ou est_majeur. Un nom comme fonction1 ne renseigne ni sur l’action ni sur le résultat attendu. Un nom clair aide à comprendre un appel plusieurs lignes ou plusieurs fichiers plus loin.
Une fonction ne sert pas uniquement à éviter les doublons. Elle sépare aussi les responsabilités du programme. Une donnée brute, telle qu’un prix, une date ou un nom, peut être transmise à un traitement dédié, puis son résultat peut être utilisé ailleurs. En séparant la transformation, l’affichage et la décision, vous évitez qu’un calcul dépende directement d’un message destiné à l’écran. Les corrections restent alors locales et les résultats plus prévisibles.
Paramètres et arguments : la donnée entre au bon endroit
Les parenthèses d’une fonction peuvent contenir des paramètres. Un paramètre est le nom prévu dans la définition pour recevoir une information. L’argument est la valeur réellement fournie lors de l’appel. Dans def afficher_age(age):, age est un paramètre. Dans afficher_age(30), 30 est l’argument.
Position, nom et valeur par défaut
Par défaut, les arguments sont associés aux paramètres selon leur position. Avec def presenter(nom, ville):, l’appel presenter("Lina", "Lyon") attribue « Lina » à nom et « Lyon » à ville. Inverser les deux valeurs ne provoque pas toujours une erreur, mais produit souvent un résultat incohérent, surtout lorsque les deux arguments ont le même type.
Les arguments nommés rendent l’appel plus explicite : presenter(ville="Lyon", nom="Lina"). L’ordre devient alors moins important, puisque chaque valeur indique le paramètre auquel elle correspond. Vous pouvez également définir une valeur par défaut, par exemple def presenter(nom, ville="Paris"):. L’appelant peut omettre ville, mais peut la remplacer au besoin. Les paramètres obligatoires doivent être placés avant ceux qui ont une valeur par défaut.
Quand utiliser *args et **kwargs
Les formes *args et **kwargs capturent un nombre variable d’arguments. *args rassemble des arguments positionnels supplémentaires dans un tuple ; **kwargs rassemble des arguments nommés supplémentaires dans un dictionnaire. Elles sont utiles lorsqu’une fonction doit accepter une quantité variable de données ou transmettre des options à une autre fonction.
Ces formes ne doivent toutefois pas masquer une liste de paramètres connue à l’avance. Si les informations attendues sont clairement définies, des paramètres explicites restent plus faciles à lire, à appeler et à documenter. Pour débuter, commencez donc par une signature simple, puis utilisez *args ou **kwargs lorsque le besoin est réel.
Return transforme une action en valeur réutilisable
L’instruction return termine l’exécution de la fonction et transmet une valeur à l’endroit de l’appel. Avec def doubler(nombre): return nombre * 2, l’expression doubler(5) vaut 10. Vous pouvez alors écrire resultat = doubler(5), utiliser ce résultat dans un calcul ou le tester dans une condition.
À l’inverse, print() affiche une information, mais ne renvoie pas le résultat du calcul au reste du programme. Une fonction qui contient uniquement print renvoie implicitement None. Il faut donc distinguer « montrer un résultat » et « fournir un résultat ». Pour une logique métier, privilégiez généralement return, puis affichez la valeur à l’extérieur si nécessaire. Cette séparation permet aussi de réutiliser la fonction dans un autre contexte, sans imposer un affichage.
Plusieurs valeurs et annotation de type
Une fonction peut renvoyer plusieurs valeurs : return minimum, maximum. Python les regroupe dans un tuple, que vous pouvez récupérer avec bas, haut = bornes(valeurs). Cette écriture permet de nommer directement les deux résultats au moment de l’appel.
Les annotations de type peuvent aussi rendre le contrat plus visible, comme dans def doubler(nombre: int) -> int:. Elles indiquent le type attendu pour l’argument et le type annoncé pour le retour. Elles aident à lire le code et certains outils peuvent les vérifier, mais Python ne les impose pas automatiquement lors de l’exécution.
Portée des variables et réflexes pour un code fiable
Une variable créée dans une fonction est en principe locale : elle n’existe que pendant l’exécution de cette fonction et n’est pas accessible à l’extérieur. Cette règle limite les modifications involontaires dans le reste du programme. Une variable définie hors des fonctions est globale au module et peut être lue depuis une fonction, sous certaines conditions.
Si vous affectez une valeur à un nom dans une fonction, Python le considère comme local. Pour modifier volontairement une variable globale, il faut utiliser global. Cette possibilité existe, mais elle rend le comportement d’un programme plus difficile à suivre, car la fonction dépend alors d’un état extérieur. Préférez transmettre une valeur en paramètre et renvoyer la nouvelle valeur avec return : les entrées et les sorties restent visibles dans l’appel.
Documenter et limiter chaque fonction
Ajoutez une docstring juste sous la ligne def, sous la forme d’un texte entre triples guillemets. Elle explique le rôle de la fonction, ses paramètres et son retour. Vous pouvez la consulter avec help(nom_de_la_fonction) ou via l’attribut __doc__. Une documentation courte suffit souvent si le nom de la fonction et ses paramètres sont déjà explicites.
Enfin, testez une fonction avec des valeurs ordinaires, des valeurs limites et des entrées inattendues. Vérifiez aussi le résultat renvoyé lorsqu’aucun return n’est exécuté. Une petite fonction bien nommée, documentée et centrée sur une seule tâche devient un élément fiable que vous pourrez réemployer dans tout votre script.
- Fonction Python : définir, appeler et réutiliser du code sans confondre paramètres et arguments - 15 octobre 2026
- L’audit trail rend chaque action vérifiable, de la modification à la preuve - 14 octobre 2026
- Quelle stratégie de modernisation logicielle choisir : incrémentale, parallèle ou big bang ? - 13 octobre 2026
