Maîtriser les fonctions Python : définition, appel, indentation, arguments et valeurs de retour

Maîtriser les fonctions Python : définition, appel, indentation, arguments et valeurs de retour

Les fonctions sont les briques fondamentales de toute application Python. Elles encapsulent une logique réutilisable, maintiennent le code DRY (Don't Repeat Yourself) et rendent vos programmes plus faciles à lire, tester et maintenir. Dans ce guide, nous parcourrons chaque étape nécessaire pour écrire, appeler et déboguer des fonctions en Python 3 — tout en abordant les différences que vous rencontrerez avec Python 2.

Qu'est-ce qu'une fonction en Python ?

Une fonction Python est un bloc de code autonome qui s'exécute lorsque vous l'invoquez. Vous pouvez la considérer comme un mini-programme qui effectue une tâche unique et bien définie, réutilisable partout où nécessaire. Bien que Python fournisse de nombreuses fonctions intégrées (ex. : print(), input()), vous êtes libre de créer les vôtres, donnant à votre code le pouvoir d'évoluer et de s'adapter.

Définir et appeler une fonction

Les fonctions sont déclarées avec le mot-clé def, suivi du nom de la fonction et d'une liste de paramètres entre parenthèses. Le corps de la fonction commence par deux points et doit être indenté.

def saluer():
    print("Bonjour, Python !")

# Appeler la fonction
saluer()

Sortie : Bonjour, Python !

Pourquoi l'indentation est importante

Python n'utilise pas d'accolades ni d'instructions begin/end explicites. À la place, l'indentation définit la portée. Chaque bloc de code — fonctions, boucles, conditionnelles — doit partager un niveau d'indentation cohérent.

1. Au moins un niveau d'indentation (généralement quatre espaces) est requis après la définition d'une fonction.
2. Toutes les instructions dans cette fonction doivent utiliser la même indentation.
3. Mélanger tabulations et espaces, ou varier la profondeur d'indentation, déclenche une IndentationError.

Exemple d'indentation correcte :

def demo():
    print("Ligne 1")
    print("Ligne 2")

Et une erreur courante :

def demo():
print("Oups")

qui lève : IndentationError: expected an indented block

Utiliser les instructions return

Le mot-clé return renvoie une valeur à l'appelant. Si une fonction se termine sans rencontrer de return, elle renvoie implicitement None.

def carre(x):
    return x * x

print(carre(4))  # 16

Sans return :

def carre(x):
    x * x

print(carre(4))  # None

De plus, afficher l'objet fonction lui-même (ex. : print(carre)) affiche son adresse mémoire, ce qui est rarement utile dans le code applicatif.

Passer des arguments aux fonctions

Les arguments fournissent les données dont une fonction a besoin pour opérer. Les paramètres sont les espaces réservés définis dans la signature de la fonction.

def multiplier(x, y=1):
    return x * y

print(multiplier(4))        # 4 (y vaut 1 par défaut)
print(multiplier(4, 2))     # 8
print(multiplier(y=3, x=2)) # 6 (arguments nommés permettent de réorganiser)

Arguments de longueur variable (*args et **kwargs)

Parfois, vous avez besoin d'une fonction qui accepte un nombre arbitraire d'arguments. Utilisez *args pour les arguments positionnels et **kwargs pour les arguments nommés.

def resumer(*valeurs, **options):
    total = sum(valeurs)
    print(f"Total : {total}")
    if options.get("afficher_details"):
        print("Valeurs :", valeurs)

resumer(1, 2, 3, 4, 5, afficher_details=True)

Python 2 vs Python 3 : différences clés

• Syntaxe print : print "texte" en Python 2 vs print("texte") en Python 3.
• La surcharge de fonctions (plusieurs signatures avec le même nom) n'est pas supportée en Python 2 mais est disponible en Python 3 via functools.singledispatch ou en inspectant les types d'arguments.
• Division entière : 5/2 donne 2 en Python 2 et 2.5 en Python 3 (utilisez // pour la division euclidienne dans les deux versions).

Bonnes pratiques pour la conception de fonctions

• Gardez les fonctions ciblées : une fonction doit effectuer une seule tâche claire.
• Documentez avec une docstring sur la première ligne à l'intérieur de la fonction.

  def additionner(a, b):
      """Renvoie la somme de a et b."""
      return a + b

• Utilisez les annotations de type (Python 3.5+) pour clarifier les types d'arguments attendus et les types de retour.

  def additionner(a: int, b: int) -> int:
      return a + b

• Préférez les arguments nommés pour les paramètres optionnels afin d'améliorer la lisibilité.

Exemple complet

# Exemple d'un script Python 3 complet
def saluer():
    """Affiche un message de bienvenue."""
    print("Bonjour, Python !")

def carre(x: int) -> int:
    """Renvoie le carré de x."""
    return x * x

def multiplier(x: int, y: int = 1) -> int:
    """Renvoie le produit de x et y, avec y valant 1 par défaut."""
    return x * y

# Démonstration
if __name__ == "__main__":
    saluer()
    print(carre(4))        # 16
    print(multiplier(4))   # 4
    print(multiplier(4, 2))# 8
    print(multiplier(y=2, x=4)) # 8

Pour plus de détails, consultez la documentation officielle Python sur les définitions de fonctions.