Logiciels & applications

Fonctions Python : un résultat réutilisable, pas seulement un affichage

26 octobre 2026 Élise Prévost-Lemercier 9 min de lecture

Une fonction Python regroupe des instructions sous un nom pour les exécuter à la demande. On la définit avec def, on l’appelle avec des parenthèses et on récupère son résultat avec return. Elle peut recevoir des données, effectuer un calcul et transmettre une valeur au reste du programme, sans répéter le même code.

Table des matières

Passer d’un calcul isolé à une fonction réutilisable

Supposons que votre programme calcule plusieurs aires de rectangles. Au lieu de réécrire chaque multiplication, vous pouvez nommer cette opération. Voici un exemple exécutable sur une seule ligne pour la définition, puis une seconde instruction à saisir séparément :

Pratiquer les fonctions Python

Complétez les quatre exercices dans l’ordre. Votre code est vérifié à partir de sa structure et de résultats attendus.

Progression 0 / 4 réussi

Exercice 1

Définir une fonction

Complétez la fonction cube avec def. Le corps de la fonction doit être indenté et calculer le cube d’un nombre.

Votre code Python

Exercice 2

Appeler une fonction avec un argument

Écrivez un appel à cube avec la valeur 3, puis stockez le résultat dans une variable nommée resultat.

Votre code Python

Exercice 3

Renvoyer une valeur avec `return`

Écrivez une fonction cube qui renvoie le résultat avec return, puis testez-la avec cube(3). N’utilisez pas print pour produire le résultat de la fonction.

Votre code Python

Exercice 4

Calculer un nombre de pixels

Écrivez calculer_pixels(largeur, hauteur). La fonction doit renvoyer le nombre total de pixels avec la formule largeur × hauteur, puis vérifiez que calculer_pixels(800, 600) == 480000.

Votre code Python

Corrections expliquées

1. Définition et indentation

def cube(nombre):
    return nombre ** 3

def commence la définition d’une fonction. Après les deux-points, les instructions du corps doivent être indentées. Cette indentation indique à Python quelles lignes appartiennent à la fonction.

2. Paramètre et argument

resultat = cube(3)

nombre est un paramètre : c’est le nom utilisé dans la définition. 3 est un argument : c’est la valeur réellement fournie lors de l’appel. Ici, la valeur 3 est transmise au paramètre nombre.

3. La différence entre return et print

def cube(nombre):
    return nombre ** 3

return renvoie une valeur à l’endroit où la fonction a été appelée. Cette valeur peut être stockée ou utilisée dans un autre calcul. print affiche seulement du texte à l’écran ; il ne remplace pas le renvoi d’une valeur.

4. Calculer les pixels

def calculer_pixels(largeur, hauteur):
    return largeur * hauteur

resultat = calculer_pixels(800, 600)

Le nombre de pixels se calcule avec une multiplication : 800 × 600 = 480000. Une fonction qui ne contient pas de return renvoie implicitement None. None signifie qu’aucune valeur exploitable n’a été renvoyée ; ce n’est pas la même chose que zéro.

def calculer_aire_rectangle(longueur, largeur): return longueur * largeur

print(calculer_aire_rectangle(5, 3))

Le résultat affiché est 15. La définition associe un nom à un traitement ; l’appel déclenche ce traitement. Définir une fonction ne signifie donc pas exécuter immédiatement son corps.

Reconnaître les éléments de la syntaxe

Après def viennent le nom, les paramètres entre parenthèses et les deux-points. Dans une écriture sur plusieurs lignes, les instructions du corps doivent être indentées de manière cohérente, habituellement avec quatre espaces. Les exemples courts présentés ici tiennent sur une ligne ; pour un traitement plus long, placez chaque instruction sur une ligne indentée.

Choisissez un nom explicite comme calculer_aire_rectangle plutôt que f. Un nom peut contenir des lettres, des chiffres et des caractères de soulignement, mais ne commence pas par un chiffre et ne doit pas être un mot réservé. Évitez également de nommer votre fonction print ou len : vous masqueriez ces outils prédéfinis.

Une fonction sans paramètre conserve ses parenthèses : def saluer(): return « Bonjour ». L’appel saluer() renvoie la chaîne « Bonjour ». Sans les parenthèses, saluer désigne l’objet fonction, sans l’exécuter.

Transmettre les bonnes données avec les paramètres

Un paramètre est un nom inscrit dans la définition. Un argument est une valeur transmise lors de l’appel. Dans calculer_aire_rectangle(longueur, largeur), longueur et largeur sont les paramètres ; dans calculer_aire_rectangle(5, 3), les nombres 5 et 3 sont les arguments.

Schéma du fonctionnement des fonctions Python avec paramètres, exécution et valeur retournée

Position, nom et valeur par défaut

Avec des arguments positionnels, l’ordre détermine l’affectation : le premier argument alimente le premier paramètre. Les arguments nommés rendent cette correspondance explicite. Ainsi, calculer_aire_rectangle(largeur=3, longueur=5) renvoie aussi 15, même si les noms apparaissent dans un ordre différent.

Une valeur par défaut rend un argument facultatif. Par exemple : def calculer_prix(prix_unitaire, quantite=1): return prix_unitaire * quantite. L’appel calculer_prix(1.15) utilise une quantité de 1 ; calculer_prix(1.15, quantite=3) utilise une quantité de 3. Python emploie le point comme séparateur décimal.

Dans cette syntaxe simple, les paramètres obligatoires précèdent ceux qui ont une valeur par défaut. Lors d’un appel, placez également les arguments positionnels avant les arguments nommés.

Éviter le piège des valeurs par défaut modifiables

Une liste utilisée comme valeur par défaut est créée à la définition, et non à chaque appel. Si la fonction la modifie, les appels suivants peuvent retrouver son contenu. Pour une liste indépendante à chaque exécution, utilisez None par défaut, puis créez une nouvelle liste dans le corps lorsque le paramètre vaut None. Cette précaution concerne aussi les dictionnaires et les autres objets mutables.

Récupérer et tester un résultat plutôt que simplement l’afficher

print affiche ; return transmet. Cette distinction permet de construire un programme à partir de petits calculs. Avec def cube(nombre): return nombre ** 3, l’instruction resultat = cube(3) conserve 27 dans resultat. Vous pouvez ensuite afficher cette valeur, la comparer ou l’utiliser dans une autre opération. L’appel cube(4) renvoie 64.

En revanche, def afficher_cube(nombre): print(nombre ** 3) affiche le cube, mais ne le retourne pas. Affecter son appel à une variable produit donc None. Une fonction qui atteint la fin sans return explicite renvoie cette valeur particulière. Un return sans expression renvoie également None et termine immédiatement l’appel.

Écriture	Effet	Résultat réutilisable
print(5 + 3)	Affiche 8	L’appel à print renvoie None
return 5 + 3	Termine la fonction	Transmet 8 à l’appelant
return longueur, largeur	Regroupe deux valeurs	Renvoie un tuple

Considérez une valeur retournée comme une graine : elle peut alimenter plusieurs traitements sans refaire le travail initial. Une fonction calculant la définition d’une image de 800 par 600 pixels renvoie 480 000 ; ce même résultat peut ensuite servir à comparer des images, estimer un volume de données ou produire un affichage. Séparer le calcul de sa présentation préserve ces possibilités.

Pour vérifier vos fonctions, écrivez des assertions après leur définition : assert cube(3) == 27, puis assert calculer_aire_rectangle(5, 3) == 15. Si une condition est fausse, Python lève une AssertionError. Testez aussi les limites pertinentes, comme une dimension nulle. Les assertions servent ici à tester, pas à valider les entrées d’un utilisateur en production.

Maîtriser les variables et repérer les erreurs fréquentes

Une variable créée dans une fonction est locale : son nom n’est normalement accessible que pendant cet appel, dans son espace de noms. Une variable définie au niveau du module est globale à ce module. La fonction peut la lire si aucun nom local ne la masque.

Pour réaffecter une variable globale depuis une fonction, il faut déclarer ce nom avec global avant son utilisation. Cette possibilité crée toutefois une dépendance moins visible. Préférez généralement recevoir une valeur en paramètre et retourner le résultat : le comportement devient plus facile à comprendre et à tester.

IndentationError : vérifiez l’alignement du corps et évitez de mélanger tabulations et espaces.
TypeError à l’appel : contrôlez les arguments manquants, surnuméraires ou fournis deux fois.
NameError : vérifiez l’orthographe du nom et exécutez la définition avant l’appel.
Résultat égal à None : recherchez un return absent ou une branche qui ne retourne rien.

Documentez également le contrat de la fonction avec une docstring, une chaîne placée au début du corps : données attendues, résultat et restrictions. Si une entrée est invalide, une exception explicite, par exemple ValueError, permet de signaler le problème plutôt que de renvoyer un résultat trompeur.

Étendre les fonctions Python sans compliquer les bases

Lorsque les mécanismes précédents sont acquis, quelques outils répondent à des besoins plus spécifiques. Ils ne remplacent pas une fonction simple, bien nommée et centrée sur une tâche.

*args recueille les arguments positionnels supplémentaires dans un tuple. Avec def somme(*args): return sum(args), somme(1, 2, 3, 4) renvoie 10.
**kwargs recueille les arguments nommés supplémentaires dans un dictionnaire. Inversement, * et ** permettent de déballer une séquence ou un dictionnaire lors d’un appel.
lambda crée une fonction limitée à une expression : lambda nombre: nombre ** 3. Elle convient notamment à une petite transformation passée à une autre fonction.
Les annotations, comme dans def cube(nombre: int) -> int: return nombre ** 3, indiquent les types attendus sans les imposer automatiquement à l’exécution.

Une fonction imbriquée est définie dans une autre fonction et peut utiliser des noms de sa portée englobante. Une fonction récursive, elle, s’appelle elle-même : elle doit posséder un cas d’arrêt, comme n == 0 pour la factorielle, et progresser vers ce cas. Pour une simple répétition, une boucle reste souvent plus lisible.

Pour pratiquer, créez maintenant une fonction qui calcule le nombre de pixels à partir d’une largeur et d’une hauteur. Retournez leur produit, vérifiez que l’appel avec 800 et 600 donne 480 000, puis affichez le résultat en dehors de la fonction. Cet exercice réunit l’essentiel : paramètres, appel, return et test.

À propos
Articles récents

Élise Prévost-Lemercier

Les articles signés Élise Prévost-Lemercier sur geckogeek.fr traitent de « Logiciels & applications » et « Sécurité & données ». Il s'agit d'un nom de plume de la rédaction.

Les derniers articles par Élise Prévost-Lemercier (tout voir)

Fonctions Python : un résultat réutilisable, pas seulement un affichage - 26 octobre 2026
Data Architect : concevoir les données ne suffit pas, il faut relier les métiers - 25 octobre 2026
LPWAN : connecter des capteurs sur plusieurs kilomètres, sans sacrifier leur batterie - 24 octobre 2026

Passer d’un calcul isolé à une fonction réutilisable

Définir une fonction

Appeler une fonction avec un argument

Renvoyer une valeur avec return

Calculer un nombre de pixels

Corrections expliquées

Reconnaître les éléments de la syntaxe

Transmettre les bonnes données avec les paramètres

Position, nom et valeur par défaut

Éviter le piège des valeurs par défaut modifiables

Récupérer et tester un résultat plutôt que simplement l’afficher

Maîtriser les variables et repérer les erreurs fréquentes

Étendre les fonctions Python sans compliquer les bases

Partager cet article

Articles qui pourraient vous intéresser :

Renvoyer une valeur avec `return`