Introduction aux fonctions pour réutiliser du code

Qu'est-ce qu'une fonction et pourquoi est-elle indispensable en Python ?

Imaginez que vous cuisinez et que vous devez hacher des oignons pour plusieurs plats différents. Plutôt que de réécrire les étapes "prendre un oignon, l'éplucher, le couper en dés" pour chaque plat, vous pourriez avoir une "compétence" ou une "action" nommée "hacher_oignon". Une fois que vous savez comment "hacher_oignon", vous pouvez simplement invoquer cette action chaque fois que nécessaire. En programmation, et particulièrement en Python, une fonction est très similaire : c'est un bloc de code nommé et organisé, conçu pour effectuer une tâche spécifique. Vous définissez la fonction une seule fois, et vous pouvez ensuite l'appeler (l'exécuter) autant de fois que vous le souhaitez dans votre programme.

L'utilisation des fonctions est fondamentale en programmation pour plusieurs raisons. Le bénéfice le plus évident est la réutilisabilité du code. Au lieu de copier-coller des blocs de code identiques à plusieurs endroits (ce qui est source d'erreurs et difficile à maintenir), vous écrivez le code une seule fois dans une fonction et l'appelez où vous en avez besoin. Cela conduit à des programmes plus courts et plus clairs. Les fonctions favorisent également la modularité : elles vous permettent de décomposer un problème complexe en sous-problèmes plus petits et plus gérables. Chaque fonction s'occupe d'une tâche précise, ce qui rend le code global plus facile à comprendre, à tester et à déboguer. Si un bug survient dans une tâche spécifique, vous savez quelle fonction examiner.

Adopter l'utilisation des fonctions améliore considérablement la lisibilité et la maintenabilité de vos programmes. Un code bien structuré avec des fonctions aux noms descriptifs se lit presque comme un texte en langage naturel, expliquant les étapes de votre programme. De plus, si vous devez modifier la manière dont une tâche particulière est effectuée, vous n'avez qu'à mettre à jour le code à l'intérieur de la fonction correspondante, et cette modification sera automatiquement répercutée partout où la fonction est appelée. C'est l'application du principe DRY (Don't Repeat Yourself - Ne vous répétez pas), un pilier des bonnes pratiques en développement logiciel.

Syntaxe Python : définir et appeler votre première fonction

En Python, la définition d'une fonction commence par le mot-clé def (abréviation de define), suivi du nom que vous souhaitez donner à votre fonction. Ce nom doit respecter les mêmes règles que les noms de variables (commencer par une lettre ou un underscore, contenir des lettres, chiffres, underscores). Après le nom, vous placez des parenthèses (), qui pourront éventuellement contenir des paramètres (nous y reviendrons). La ligne de définition se termine par un deux-points :. Le corps de la fonction, c'est-à-dire l'ensemble des instructions qu'elle exécute, est indenté (généralement de quatre espaces) sous la ligne de définition. Cette indentation est cruciale en Python car elle délimite le bloc de code appartenant à la fonction.

Voyons un exemple simple d'une fonction qui affiche un message de salutation. Nous l'appellerons afficher_salutation. Sa tâche est unique : imprimer "Bonjour et bienvenue !". Voici comment la définir :

def afficher_salutation():
    message = "Bonjour et bienvenue !"
    print(message)

Dans cet exemple, afficher_salutation est le nom de la fonction. Les parenthèses sont vides car cette fonction particulière n'a pas besoin d'informations extérieures pour fonctionner. Le code à l'intérieur (la création de la variable message et l'instruction print()) constitue le corps de la fonction.

Définir une fonction ne l'exécute pas immédiatement. Vous avez simplement appris à Python ce que cette fonction doit faire lorsqu'elle sera sollicitée. Pour exécuter le code à l'intérieur de la fonction, vous devez l'appeler. Un appel de fonction se fait simplement en écrivant son nom suivi de parenthèses. Par exemple, pour exécuter notre fonction afficher_salutation, vous écririez :

# Définition de la fonction (doit être faite avant l'appel)
def afficher_salutation():
    message = "Bonjour et bienvenue !"
    print(message)

# Appel de la fonction
afficher_salutation()  # Ceci va exécuter le code de la fonction et afficher le message

Si vous exécutez ce script, "Bonjour et bienvenue !" s'affichera dans la console. Vous pouvez appeler afficher_salutation() plusieurs fois si nécessaire.

Les paramètres et arguments : communiquer avec vos fonctions Python

Souvent, une fonction a besoin d'informations spécifiques pour accomplir sa tâche. Par exemple, une fonction qui calcule l'aire d'un rectangle a besoin de connaître la longueur et la largeur de ce rectangle. Ces informations sont transmises à la fonction via des paramètres. Les paramètres sont des variables listées entre les parenthèses lors de la définition de la fonction. Ils agissent comme des emplacements réservés pour les valeurs que la fonction recevra lorsqu'elle sera appelée.

Lorsque vous appelez une fonction qui attend des paramètres, vous devez fournir des valeurs pour ces paramètres. Ces valeurs sont appelées des arguments. Prenons une fonction saluer_personne qui prend un nom en paramètre et affiche une salutation personnalisée :

def saluer_personne(nom):  # 'nom' est un paramètre
    print(f"Bonjour, {nom} !")

# Appels de la fonction avec différents arguments
saluer_personne("Alice")    # "Alice" est un argument. Affiche: Bonjour, Alice !
saluer_personne("Bob")      # "Bob" est un argument. Affiche: Bonjour, Bob !

Ici, nom est un paramètre de la fonction saluer_personne. Lorsque nous appelons saluer_personne("Alice"), la chaîne de caractères "Alice" est l'argument qui est assigné au paramètre nom à l'intérieur de la fonction.

Une fonction peut avoir plusieurs paramètres, séparés par des virgules. Par défaut, les arguments sont passés aux paramètres en fonction de leur position : le premier argument va au premier paramètre, le deuxième au deuxième, et ainsi de suite. C'est ce qu'on appelle les arguments positionnels.

def decrire_animal(espece, nom):
    print(f"J'ai un(e) {espece} qui s'appelle {nom}.")

decrire_animal("chat", "Moustache") # Affiche: J'ai un(e) chat qui s'appelle Moustache.

Python offre aussi la possibilité d'utiliser des arguments par mot-clé (keyword arguments). Cela vous permet de spécifier explicitement à quel paramètre chaque argument correspond, rendant l'appel de fonction plus lisible, surtout avec de nombreux paramètres, et vous libérant de la contrainte de l'ordre.

decrire_animal(nom="Fido", espece="chien") # Affiche: J'ai un(e) chien qui s'appelle Fido.

Il est également possible de définir des valeurs par défaut pour les paramètres. Si un argument n'est pas fourni pour un paramètre ayant une valeur par défaut lors de l'appel de la fonction, cette valeur par défaut sera utilisée. Les paramètres avec des valeurs par défaut doivent toujours être placés après les paramètres sans valeur par défaut dans la définition de la fonction.

def souhaiter_bonjour(nom, message="Comment allez-vous ?"):
    print(f"Bonjour {nom}, {message}")

souhaiter_bonjour("Claire")                  # Affiche: Bonjour Claire, Comment allez-vous ?
souhaiter_bonjour("David", "Passez une bonne journée !") # Affiche: Bonjour David, Passez une bonne journée !

La déclaration `return` : ce que vos fonctions Python vous rapportent

Jusqu'à présent, nos fonctions ont effectué des actions, comme afficher du texte à l'écran. Cependant, il est très fréquent qu'une fonction calcule une valeur ou produise un résultat que nous souhaitons utiliser ailleurs dans notre programme. Pour qu'une fonction renvoie une valeur à l'endroit où elle a été appelée, on utilise l'instruction return.

Lorsqu'une instruction return est rencontrée dans une fonction, l'exécution de la fonction s'arrête immédiatement et la valeur spécifiée après return est renvoyée. Cette valeur peut ensuite être assignée à une variable ou utilisée directement dans une expression. Prenons l'exemple d'une fonction qui additionne deux nombres :

def additionner(a, b):
    somme = a + b
    return somme  # La fonction renvoie la valeur de 'somme'

resultat = additionner(5, 3)  # On appelle la fonction et stocke le résultat
print(f"Le résultat de l'addition est : {resultat}")  # Affiche: Le résultat de l'addition est : 8
print(f"10 + 20 = {additionner(10, 20)}") # Utilisation directe. Affiche: 10 + 20 = 30

Dans cet exemple, additionner(5, 3) évalue à 8, qui est ensuite stocké dans la variable resultat.

Que se passe-t-il si une fonction n'a pas d'instruction return explicite, ou si elle a une instruction return sans valeur (par exemple, juste return) ? Dans ce cas, la fonction renvoie implicitement une valeur spéciale en Python appelée None. None est un type de données qui représente l'absence de valeur. Nos premières fonctions comme afficher_salutation() renvoyaient None. Il est important de comprendre cela, car si vous essayez d'assigner le résultat d'une telle fonction à une variable, cette variable contiendra None.

def fonction_sans_return_explicite():
    print("Cette fonction ne renvoie rien explicitement.")

valeur_recue = fonction_sans_return_explicite() # Affiche le message de la fonction
print(f"Valeur reçue de la fonction : {valeur_recue}") # Affiche: Valeur reçue de la fonction : None

Une fonction peut également retourner plusieurs valeurs. En Python, cela se fait généralement en retournant un tuple. Le tuple peut ensuite être "dépaqueté" dans plusieurs variables lors de l'appel.

def operations_base(a, b):
    som = a + b
    diff = a - b
    return som, diff # Retourne un tuple (som, diff)

somme_val, difference_val = operations_base(10, 4)
print(f"Somme : {somme_val}, Différence : {difference_val}") # Somme : 14, Différence : 6

Les bonnes pratiques pour des fonctions Python claires et efficaces

Ecrire des fonctions qui fonctionnent est une première étape, mais écrire des fonctions claires, lisibles et maintenables est tout aussi crucial, surtout lorsque vous travaillez sur des projets plus importants ou en équipe. La première bonne pratique concerne le nommage. Choisissez des noms de fonctions qui décrivent clairement ce que fait la fonction. Utilisez la convention snake_case (mots en minuscules séparés par des underscores), par exemple calculer_moyenne ou verifier_acces_utilisateur. Un nom explicite permet de comprendre l'intention de la fonction sans avoir à lire son code interne.

Une autre pratique essentielle est la documentation de vos fonctions à l'aide de chaînes de documentation, appelées docstrings. Une docstring est une chaîne de caractères littérale qui apparaît comme la première instruction dans la définition d'une fonction (ou d'un module, d'une classe). Elle est encadrée par des triples guillemets (simples ou doubles : """ ... """ ou ''' ... '''). Une bonne docstring explique brièvement ce que fait la fonction, quels sont ses paramètres (et leurs types attendus si pertinent), et ce qu'elle retourne. Les docstrings peuvent être consultées interactivement avec la fonction help().

def calculer_aire_rectangle(longueur, largeur):
    """Calcule l'aire d'un rectangle.

    Args:
        longueur (float or int): La longueur du rectangle.
        largeur (float or int): La largeur du rectangle.

    Returns:
        float or int: L'aire calculée du rectangle.
    """
    if not (isinstance(longueur, (int, float)) and isinstance(largeur, (int, float))):
        raise TypeError("La longueur et la largeur doivent être des nombres.")
    if longueur < 0 or largeur < 0:
        raise ValueError("La longueur et la largeur doivent être positives.")
    return longueur * largeur

# Vous pouvez ensuite voir la docstring avec :
# help(calculer_aire_rectangle)
# print(calculer_aire_rectangle.__doc__)

Visez le principe de responsabilité unique (Single Responsibility Principle - SRP) : une fonction devrait idéalement faire une seule chose et la faire bien. Si une fonction effectue de nombreuses opérations distinctes, il est souvent préférable de la décomposer en plusieurs fonctions plus petites et plus ciblées. Cela rend chaque fonction plus facile à comprendre, à tester et à réutiliser. De même, essayez de garder vos fonctions relativement courtes. Des fonctions longues sont souvent un signe qu'elles font trop de choses ou que leur logique pourrait être simplifiée. Une fonction qui tient sur un écran est généralement plus facile à appréhender.