Une fonction, c'est un bloc d'étapes nommé
Chaque fois que tu te retrouves à écrire les mêmes quelques lignes plus d'une fois — ou que tu veux donner un nom à un petit morceau de logique — tu es prêt à écrire une fonction. Les fonctions sont le premier vrai outil pour gérer la complexité dans un programme Python.
La forme de base :
Décomposons :
defest le mot-clé qui commence une définition de fonction.greetest le nom de la fonction.(name)est la liste de paramètres — les entrées que la fonction prend.- Le deux-points termine l'en-tête ; le bloc indenté en dessous est le corps.
greet("Ada")est un appel. Python exécute le corps avecnamelié à"Ada".
Les fonctions restent dormantes jusqu'à ce qu'elles soient appelées. En définir une ne l'exécute pas. L'appeler avec greet("Ada"), si.
Paramètres et arguments
Le mot paramètre est le nom à l'intérieur de la définition de fonction. Le mot argument est la valeur passée lors de l'appel. Pas énorme dans une conversation décontractée, mais la distinction aide à lire les messages d'erreur.
Ici base et exponent sont des paramètres. 2 et 10 sont des arguments. Python les lie dans l'ordre : premier argument au premier paramètre, et ainsi de suite.
return : renvoyer une valeur
print écrit à l'écran. return rend une valeur à l'appelant pour qu'il puisse l'utiliser :
Sans return, une fonction renvoie None par défaut :
return fait aussi sortir la fonction immédiatement. Tu verras souvent des returns précoces utilisés pour se débarrasser des cas limites avant la logique principale :
Les returns précoces évitent que le corps principal soit profondément imbriqué dans des if/else.
Arguments par défaut
Un paramètre peut avoir une valeur par défaut, utilisée quand l'appelant n'en fournit pas :
Tous les paramètres avec défauts doivent venir après les paramètres sans défauts. def f(a, b=1, c): est une erreur de syntaxe.
Le piège des défauts mutables
C'est le piège Python le plus célèbre. Regarde :
Tu t'attendrais à ce que chaque appel parte d'une liste vide. En fait, la liste par défaut est partagée entre les appels, et les éléments s'accumulent. Python évalue le défaut une fois, quand la fonction est définie, et réutilise cette unique liste pour toujours.
Le motif sûr, c'est d'utiliser None comme défaut et de créer la liste à l'intérieur de la fonction :
Maintenant, chaque appel qui ne passe pas items reçoit une liste fraîche. Cette règle s'applique aux listes, dicts, sets — à tout ce qui est mutable.
Arguments nommés
Tu peux passer les arguments par nom plutôt que par position. Ça te laisse sauter des paramètres du milieu et rend les appels longs plus lisibles :
Les arguments positionnels et nommés peuvent se mélanger, mais les positionnels doivent venir en premier :
Dès qu'une fonction a plus de trois ou quatre paramètres, favoriser les arguments nommés rend les appels bien plus faciles à lire.
Paramètres positional-only et keyword-only
Python te permet de marquer certains paramètres comme appelables seulement par position (avec /) ou seulement par mot-clé (avec *) :
Tu n'as pas besoin de ça dès le premier jour. Ils deviennent utiles quand tu conçois des API et veux verrouiller la façon dont les appelants utilisent ta fonction.
Docstrings et nommage
La première ligne dans une fonction peut être une docstring — une chaîne à triple guillemets que Python traite comme documentation :
Des outils comme help(), les tooltips d'IDE et les générateurs de documentation lisent la docstring automatiquement. Une ligne vaut bien mieux que rien du tout.
Et s'il te plaît, pense au nommage :
- Les noms de fonction devraient être des verbes :
fetch_profile,compute_total,is_valid. - Utilise
lower_snake_case. - Les fonctions qui renvoient un booléen commencent souvent par
is_,has_oucan_.
Un bon nom rend le site d'appel auto-explicatif sans avoir besoin d'un commentaire.
Les fonctions pures sont plus faciles à raisonner
Une fonction pure renvoie la même sortie pour la même entrée et n'a pas d'effets de bord — elle ne modifie pas d'état global, n'écrit pas sur stdout (autre que pour du debug), ne touche pas aux fichiers.
Les deux ont leur place, mais dans du code que tu veux réutiliser et tester, pousse vers les fonctions pures autant que possible.
Un petit exemple qui marche
Une fonction rapide qui combine défauts, arguments nommés et return :
Ensuite : listes d'arguments flexibles
Parfois tu ne sais pas combien d'arguments une fonction sera appelée avec — ou tu veux transférer quels que soient les arguments qui arrivent à une autre fonction. *args et **kwargs gèrent ça. C'est pour la page suivante.
Questions fréquentes
Comment définir une fonction en Python ?
Utilise le mot-clé def, suivi du nom de la fonction, de parenthèses pour les paramètres, et d'un deux-points. Le bloc indenté en dessous est le corps de la fonction. Exemple : def greet(name): print(f'Hi, {name}').
Que fait return en Python ?
return renvoie une valeur à qui a appelé la fonction. Une fonction sans return explicite renvoie None automatiquement. Une fois que return s'exécute, la fonction sort immédiatement — tout code après lui dans le même bloc est sauté.
Qu'est-ce que les arguments par défaut en Python ?
Les arguments par défaut laissent un paramètre avoir une valeur pré-définie utilisée si l'appelant n'en fournit pas. def greet(name='friend'): veut dire greet() sans arguments utilise 'friend'. N'utilise jamais de défauts mutables comme [] — voir plus bas pour le motif sûr.
