Fonctions

Introduction

Quand un même calcul revient à plusieurs endroits d'un programme, le copier-coller n'est pas la bonne solution : la moindre correction devient fastidieuse, et le code devient illisible. La fonction est la réponse — on nomme un bloc de code et on l'appelle chaque fois qu'on en a besoin. [PG01]

Une fonction est aussi un outil de pensée : elle donne un nom à une idée, isole un calcul de son contexte, et permet de raisonner sur des morceaux indépendamment du reste. C'est l'un des piliers de la structuration des programmes.

Définir une fonction

En Python, la définition d'une fonction se fait avec le mot-clé def, suivi du nom de la fonction, de la liste de ses paramètres entre parenthèses, puis d'un : qui ouvre le bloc indenté du corps de la fonction.

def carre(n):
    return n * n

Cette fonction :

• s'appelle carre,
• attend un paramètre nommé n,
• retourne la valeur n * n.

Le mot-clé return termine immédiatement la fonction et renvoie la valeur indiquée à l'endroit où la fonction a été appelée.

Appeler une fonction

Définir une fonction ne l'exécute pas — il faut ensuite l'appeler en lui passant des arguments.

def carre(n):
    return n * n

resultat = carre(5)
print(resultat)         # 25
print(carre(7))         # 49
print(carre(2) + carre(3))  # 4 + 9 = 13

À l'appel carre(5), le paramètre n prend la valeur 5 le temps de l'exécution du corps de la fonction. Le return n * n renvoie alors 25, qui est stocké dans la variable resultat.

Plusieurs paramètres, valeur de retour

Une fonction peut avoir zéro, un ou plusieurs paramètres.

def somme(a, b):
    return a + b

def saluer(prenom):
    return "Bonjour " + prenom

def afficher_separateur():
    print("-" * 20)

print(somme(3, 4))         # 7
print(saluer("Ada"))       # Bonjour Ada
afficher_separateur()      # --------------------

afficher_separateur ne retourne rien d'utile : elle a un effet de bord (elle affiche) mais pas de valeur de retour explicite. En Python, une fonction sans return renvoie automatiquement la valeur spéciale None.

Sortie attendue :

Somme   : 7
Maximum : 7
Maximum : 9

def maximum(a, b):
    if a > b:
        return a
    return b   # exécuté uniquement si a <= b

Pourquoi écrire des fonctions ?

Trois bénéfices majeurs :

1. Réutiliser : écrire une fois, appeler partout.
2. Nommer : donner un nom au calcul (distance, est_premier, convertir_en_celsius…) rend le code parlant.
3. Isoler : ce qui se passe à l'intérieur de la fonction ne pollue pas l'extérieur. On peut tester la fonction seule.

Comparez :

# Calculer plusieurs distances entre points 2D
import math
x1, y1 = 0, 0
x2, y2 = 3, 4
d1 = math.sqrt((x2-x1)**2 + (y2-y1)**2)

x3, y3 = 1, 1
x4, y4 = 4, 5
d2 = math.sqrt((x4-x3)**2 + (y4-y3)**2)

print(d1, d2)

import math

def distance(x1, y1, x2, y2):
    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

print(distance(0, 0, 3, 4))   # 5.0
print(distance(1, 1, 4, 5))   # 5.0

La version avec fonction est plus courte, plus lisible, et la formule est écrite une seule fois — donc moins d'occasions de se tromper.

Portée des variables (notion)

Les variables définies à l'intérieur d'une fonction (paramètres ou variables locales) n'existent que pendant l'exécution de la fonction.

def double(n):
    resultat = n * 2
    return resultat

print(double(5))      # 10
print(resultat)       # NameError : resultat n'existe pas ici

À l'inverse, une fonction peut lire une variable définie à l'extérieur, mais ce n'est pas une bonne pratique — on préfère passer toutes les données nécessaires en paramètres.

def f(x):
    return x + 1   # transforme et retourne, sans toucher à l'extérieur

Plusieurs valeurs de retour

Une fonction peut renvoyer un tuple (une suite figée de valeurs) pour transmettre plusieurs résultats à la fois ; la notion de tuple sera étudiée en détail au chapitre PC — Types construits.

def division_euclidienne(a, b):
    quotient = a // b
    reste = a % b
    return quotient, reste

q, r = division_euclidienne(17, 5)
print(q, r)        # 3 2

Cette syntaxe sert souvent pour les fonctions qui renvoient un couple naturel : (min, max), (succès, valeur), (quotient, reste).

Pièges courants

Pour aller plus loin

Une fonction bien écrite, c'est une fonction spécifiée : on sait ce qu'elle attend en entrée et ce qu'elle promet en sortie. C'est l'objet du cours suivant sur la spécification [PG04].