En Python, une fonction se crée avec le mot-clé def, suivi d'un nom, de parenthèses qui contiennent les paramètres et de deux-points. Le corps est indenté en dessous, et return renvoie le résultat. On l'utilise ensuite en écrivant son nom suivi de parenthèses : calculer_ttc(100). Le reste de cet article montre comment bien la construire et quels pièges éviter.
La syntaxe de base, ligne par ligne
Prenons un besoin courant en entreprise : passer un prix hors taxes en TTC.
def calculer_ttc(prix_ht, taux_tva=0.2):
"""Renvoie le prix TTC arrondi au centime."""
return round(prix_ht * (1 + taux_tva), 2)
print(calculer_ttc(100)) # 120.0
print(calculer_ttc(100, 0.055)) # 105.5
def annonce la définition. prix_ht et taux_tva sont les paramètres, c'est-à-dire les noms que la fonction utilise en interne. Les valeurs que vous passez à l'appel (100, 0.055) sont les arguments. La chaîne entre triples guillemets, juste sous la ligne def, est la docstring : elle documente la fonction et s'affiche avec help(calculer_ttc).
L'indentation n'est pas décorative. C'est elle qui indique à Python où commence et où s'arrête le corps de la fonction. La convention est de 4 espaces. Si une ligne sort de ce bloc par erreur, elle ne fait plus partie de la fonction.
Définir n'est pas exécuter
Une erreur fréquente chez les débutants : écrire la fonction, lancer le script, et ne rien voir s'afficher. C'est normal. Le bloc def enregistre la fonction en mémoire, il ne l'exécute pas. Il faut l'appeler, et l'appel doit se trouver après la définition dans le fichier.
Autre confusion classique : oublier les parenthèses. calculer_ttc désigne l'objet fonction lui-même, calculer_ttc(100) l'exécute. Si vous voyez s'afficher quelque chose comme , c'est que les parenthèses manquent.
Paramètres : positionnels, nommés et valeurs par défaut
Un argument positionnel est associé au paramètre selon sa place. Un argument nommé est associé par son nom, et l'ordre n'a alors plus d'importance :
calculer_ttc(100, 0.1)
calculer_ttc(taux_tva=0.1, prix_ht=100)
Les deux appels donnent le même résultat. Les arguments nommés rendent le code plus lisible dès qu'une fonction a plus de deux paramètres. Une règle à retenir : dans un appel, les arguments positionnels viennent toujours avant les arguments nommés.
La valeur par défaut (taux_tva=0.2) rend le paramètre facultatif. Attention à un piège documenté dans le tutoriel officiel de Python : la valeur par défaut est évaluée une seule fois, au moment de la définition. Avec une liste, elle est donc partagée entre les appels.
# À éviter
def ajouter_tache(tache, liste=[]):
liste.append(tache)
return liste
ajouter_tache("Relancer le client") # ['Relancer le client']
ajouter_tache("Envoyer le devis") # ['Relancer le client', 'Envoyer le devis']
# Version correcte
def ajouter_tache(tache, liste=None):
if liste is None:
liste = []
liste.append(tache)
return liste
Le deuxième appel de la première version garde la tâche du premier, ce qui n'est presque jamais voulu. Le réflexe : None comme valeur par défaut pour une liste ou un dictionnaire, puis création de l'objet dans le corps de la fonction.
return et print ne font pas la même chose
print() affiche un texte à l'écran. return renvoie une valeur au code qui a appelé la fonction, pour qu'il puisse la stocker ou la réutiliser. Une fonction sans return renvoie None.
def ttc_affiche(prix_ht):
print(prix_ht * 1.2)
total = ttc_affiche(100) + 5 # TypeError : None + 5
La fonction affiche bien 120.0, mais total reçoit None et le calcul plante. Dans une fonction de calcul, utilisez return et laissez l'affichage au code appelant.
Une fonction peut aussi renvoyer plusieurs valeurs. Python les regroupe dans un tuple, que vous pouvez déballer directement :
def ht_et_tva(prix_ttc, taux=0.2):
ht = round(prix_ttc / (1 + taux), 2)
return ht, round(prix_ttc - ht, 2)
ht, tva = ht_et_tva(120) # 100.0 et 20.0
Accepter un nombre variable d'arguments
*args regroupe les arguments positionnels en trop dans un tuple, **kwargs regroupe les arguments nommés en trop dans un dictionnaire. Utile quand vous ne savez pas à l'avance combien de valeurs vous recevrez :
def total_commande(*montants, remise=0):
return round(sum(montants) * (1 - remise), 2)
total_commande(19.9, 45, 12.5) # 77.4
total_commande(19.9, 45, 12.5, remise=0.1) # 69.66
Ici, remise est placé après *montants : il ne peut être passé que par son nom. C'est une bonne façon d'éviter qu'une valeur se retrouve au mauvais endroit.
Portée des variables : ce qui reste dans la fonction
Une variable créée dans une fonction est locale. Elle n'existe que pendant l'exécution de la fonction et n'est pas visible à l'extérieur. Une fonction peut lire une variable définie au niveau du module, mais si elle lui affecte une valeur, Python crée une nouvelle variable locale du même nom.
compteur = 0
def incrementer():
compteur = compteur + 1 # UnboundLocalError
def incrementer_propre(valeur):
return valeur + 1
compteur = incrementer_propre(compteur)
Le mot-clé global permet de modifier la variable du module, mais il rend le code plus difficile à suivre et à tester. Dans la grande majorité des cas, mieux vaut passer la valeur en paramètre et récupérer le résultat avec return.
Les fonctions lambda, pour les cas courts
Une lambda est une fonction anonyme limitée à une seule expression. Son terrain naturel est le paramètre key des fonctions de tri :
clients = [("Durand", 1200), ("Martin", 450), ("Leroy", 3100)]
clients.sort(key=lambda c: c[1], reverse=True)
# [('Leroy', 3100), ('Durand', 1200), ('Martin', 450)]
Dès que la logique dépasse une ligne ou mérite un nom, écrivez une fonction classique avec def. Elle sera plus facile à relire et à tester.
Bien découper son code en fonctions
Quelques repères pratiques, utiles dès vos premiers scripts :
| Signal dans votre code | Ce qu'il faut faire |
|---|---|
| Le même bloc est copié-collé deux fois ou plus | Le transformer en fonction avec des paramètres |
| Une fonction dépasse un écran | La découper en fonctions plus petites qui font chacune une chose |
| Le nom de la fonction contient « et » | Séparer les deux actions |
| Une fonction lit et modifie des variables globales | Passer les valeurs en paramètres et renvoyer le résultat |
| Vous ne savez plus ce qu'une fonction renvoie | Ajouter une docstring et, si besoin, des annotations de type |
Pour les noms, la convention Python est le snake_case avec un verbe : calculer_ttc, charger_fichier, envoyer_relance. Les annotations de type (def calculer_ttc(prix_ht: float) -> float:) n'ont aucun effet à l'exécution, mais elles documentent ce que la fonction attend et permettent à votre éditeur de signaler des incohérences.
Mettre en pratique
Les fonctions s'appuient sur les bases du langage : revoyez si besoin les variables, listes et dictionnaires et l'écriture des boucles for et while. Une fois à l'aise, l'étape suivante consiste à rendre vos fonctions robustes face aux mauvaises saisies, avec la gestion des erreurs et exceptions, puis à les ranger dans des modules que vous saurez importer comme n'importe quelle bibliothèque Python.
Un exercice pour commencer : reprenez un script que vous avez déjà écrit, repérez un bloc répété et transformez-le en fonction avec une docstring et un return. Si vous voulez un parcours encadré, la formation Python à distance de 35 h préparant la certification TOSA alterne e-learning et visio individuelle et est éligible au CPF.