En bref
Les fonctions Python sont les briques qui transforment des scripts fouillis en programmes organisés : un bloc nommé, défini avec le mot-clé def, qui reçoit des paramètres, exécute son travail et renvoie un résultat avec return. La mécanique de base s’apprend en une heure, définition, appel, valeur de retour, portée locale des variables, mais la richesse du langage se révèle dans la gestion des arguments : valeurs par défaut qui rendent les paramètres optionnels, appels par mot-clé qui documentent eux-mêmes, args et kwargs qui acceptent un nombre variable d’arguments, et annotations de type qui précisent les intentions. Restent les bonnes pratiques qui font les programmes durables : des fonctions courtes à responsabilité unique, des noms qui disent ce qu’elles font, des docstrings qui les documentent, le retour préféré à la modification d’état, et la connaissance du piège le plus célèbre du langage, la valeur par défaut mutable partagée entre les appels. Ce guide déroule le tout avec exemples et exercices en tête.
Il y a un avant et un après : le jour où ton script de cent lignes devient cinq fonctions bien nommées, tu changes de métier sans changer de langage. Les fonctions Python sont l’outil central de cette transformation, et le langage les a dotées d’une souplesse remarquable. Voici le guide pratique complet, de def aux bonnes pratiques, en prolongement de comprendre une fonction, du guide apprendre le Python et du guide complet pour apprendre à coder.
La mécanique de base : def, paramètres, return, portée
Tout commence par le mot-clé def, le nom choisi, les parenthèses et les deux-points, suivis du corps indenté : def saluer(prenom): puis, en retrait, ce que la fonction fait. L’appel se fait par le nom suivi des parenthèses garnies, saluer("Zoé"), et cette distinction entre définir, écrire la recette, et appeler, la cuisiner, est le premier déclic à installer, une fonction définie mais jamais appelée ne s’exécutant tout simplement pas. Les paramètres sont les ingrédients attendus, nommés dans la définition ; les arguments sont les valeurs réellement fournies à l’appel, et Python vérifie la correspondance en levant une erreur explicite si un paramètre requis manque. Le retour, enfin, se fait avec return : return total renvoie la valeur à l’appelant, qui peut la ranger dans une variable ou l’utiliser directement, et le return interrompt immédiatement la fonction, ce qui permet les sorties anticipées élégantes ; une fonction sans return renvoie None, la valeur qui signifie rien, source du grand classique du débutant, afficher avec print au lieu de renvoyer, puis s’étonner que le résultat soit introuvable.
Reste la portée, la règle de territoire qui déroute puis protège : les variables créées dans une fonction sont locales, elles naissent à l’appel, meurent au retour, et n’existent pas au-dehors, deux fonctions pouvant ainsi utiliser chacune son total sans se marcher dessus. Une fonction peut lire les variables du niveau global, mais les modifier exige une déclaration explicite qu’il vaut mieux éviter : la bonne pratique universelle consiste à faire entrer les données par les paramètres et sortir les résultats par le return, la fonction devenant une boîte à entrées et sorties claires plutôt qu’un bras qui fouille dans l’état ambiant. Cette discipline, détaillée pour tous les langages dans comprendre une fonction en programmation, paie immédiatement en Python : les fonctions ainsi écrites se testent isolément, se relisent sans contexte et se réutilisent partout, et c’est très exactement ce qui distingue les bases bien posées du bricolage qui s’effondre au premier projet sérieux.
La richesse des arguments : défauts, mots-clés, args et kwargs
La signature d’une fonction Python est un petit langage en soi, et sa première finesse est la valeur par défaut : def saluer(prenom, message="Bonjour"): rend le second paramètre optionnel, l’appel à un argument utilisant le défaut, l’appel à deux le remplaçant. S’y ajoute l’appel par mot-clé, la politesse signature du langage : envoyer(destinataire="Léo", copie=True) nomme explicitement ce qu’il passe, s’affranchit de l’ordre des paramètres et se lit comme une phrase, un confort qui devient une nécessité dès que les paramètres se multiplient ; les fonctions de la bibliothèque standard et de l’écosystème data en font un usage massif, et savoir lire une signature dans la documentation, paramètres requis, optionnels, par mot-clé seulement, est une compétence quotidienne. Les annotations de type complètent le tableau moderne : def aire(largeur: float, hauteur: float) -> float: déclare les types attendus et rendus, sans contrainte à l’exécution mais avec un double bénéfice, la documentation vivante et l’aide des outils, l’éditeur et les vérificateurs signalant les incohérences avant qu’elles ne deviennent des bugs.
Viennent enfin les célébrités au nom étrange, args et kwargs, qui acceptent l’imprévu. Un paramètre étoilé, def total(*nombres):, ramasse tous les arguments positionnels dans un tuple, permettant d’appeler total avec deux, cinq ou vingt valeurs, exactement comme le font print et max ; un paramètre à double étoile, **options, ramasse de même tous les arguments par mot-clé dans un dictionnaire. Ces mécanismes, impressionnants de l’extérieur, se domestiquent en une séance d’exercices, et leur vrai usage est double : écrire des fonctions génériques, et surtout comprendre celles des autres, les bibliothèques en regorgeant. Un conseil de sobriété les accompagne : dans ton propre code applicatif, les paramètres explicites et nommés restent préférables, args et kwargs se réservant aux cas qui les justifient, car la signature d’une fonction est son contrat, et un contrat vague se paie en relectures. La règle d’or de l’étape : chaque paramètre ajouté doit gagner sa place, une fonction à sept paramètres étant presque toujours deux fonctions qui s’ignorent.
Bonnes pratiques, pièges célèbres et suite du chemin
Les bonnes pratiques des fonctions Python tiennent en une poignée de règles qui font les programmes durables. La responsabilité unique d’abord : une fonction fait une chose, dite par son nom, verbe en tête, calculer_moyenne, envoyer_rapport, selon l’art de bien nommer, et la fonction qui charge, calcule, affiche et sauvegarde est un aveu de découpage manqué. La brièveté ensuite, non par dogme du nombre de lignes mais par lisibilité : une fonction se comprend d’un regard, et le besoin de défiler est un signal. La docstring encore, cette chaîne de documentation placée juste sous la définition, entre triples guillemets, qui explique le rôle, les paramètres et le retour : les outils l’affichent à la demande, help la lit, et ton futur toi la bénira. Le retour plutôt que l’effet enfin : une fonction qui renvoie son résultat se compose et se teste, une fonction qui modifie des variables externes ou imprime directement se marie mal ; quand une erreur survient, lever une exception claire vaut mieux que renvoyer des valeurs magiques.
Deux pièges célèbres méritent leur avertissement encadré. Le premier est le défaut mutable, le bug le plus documenté du langage : écrire def ajouter(element, liste=[]): semble anodin, mais la liste par défaut est créée une seule fois, à la définition, et partagée entre tous les appels, les éléments s’accumulant mystérieusement d’un appel à l’autre ; la parade canonique consiste à utiliser None comme défaut et à créer la liste dans le corps. Le second est l’oubli des parenthèses : passer ma_fonction sans les parenthèses ne l’appelle pas, il passe la fonction elle-même, ce qui est parfois exactement ce qu’on veut, car les fonctions Python sont des valeurs, qu’on range, qu’on passe et qu’on renvoie, la porte vers les lambdas, ces mini-fonctions anonymes idéales en argument de tri, et vers les décorateurs qu’on croisera plus tard. La suite du chemin est toute tracée : pratiquer sur de vrais terrains, les automatisations et les projets Python transformant chaque notion de ce guide en réflexe, jusqu’au jour, proche, où découper en fonctions ne sera plus une étape mais ta façon même de penser un programme.
Questions fréquentes
Comment définit-on une fonction en Python ?
Avec le mot-clé def, un nom, des parenthèses contenant les paramètres et deux-points, suivis du corps indenté : def saluer(prenom): puis les instructions. L’appel se fait par le nom suivi des parenthèses garnies d’arguments, et return renvoie le résultat à l’appelant.
Quelle est la différence entre paramètre et argument ?
Le paramètre est le nom déclaré dans la définition de la fonction, l’ingrédient attendu ; l’argument est la valeur réellement fournie à l’appel. Python vérifie la correspondance et lève une erreur explicite si un paramètre requis ne reçoit pas d’argument.
Que signifient args et kwargs en Python ?
Un paramètre étoilé ramasse tous les arguments positionnels dans un tuple, un paramètre à double étoile ramasse les arguments par mot-clé dans un dictionnaire : la fonction accepte ainsi un nombre variable d’arguments, comme le font print et max. À réserver aux cas qui le justifient.
Quel est le piège de la valeur par défaut mutable ?
Une liste ou un dictionnaire en valeur par défaut est créé une seule fois, à la définition, et partagé entre tous les appels : les éléments s’accumulent mystérieusement. La parade canonique : utiliser None comme défaut et créer l’objet dans le corps de la fonction.
Sources
Cet article a une vocation informative et pédagogique. Les plateformes, outils et formations éventuellement cités le sont à titre d’exemple ; compare plusieurs options avant de t’engager ou de payer.