Fonctions : paramètres et valeurs de retour

2. return n'est pas print

return renvoie une valeur qu'on peut réutiliser : la ranger dans une variable, la recalculer, la passer à une autre fonction… print ne fait qu'afficher du texte à l'écran ; il ne renvoie rien d'exploitable. C'est LE piège numéro un du début de prépa.

def double_print(x):
    print(x * 2)      # affiche seulement

def double_return(x):
    return x * 2      # renvoie une valeur réutilisable

a = double_print(3)   # affiche 6, mais a vaut None
b = double_return(3)  # b vaut 6 (rien n'est affiché)
print(b + 1)          # affiche 7

3. Plusieurs paramètres et arguments

Une fonction peut avoir plusieurs paramètres, séparés par des virgules. À l'appel, les arguments sont associés aux paramètres dans l'ordre (arguments positionnels) : le premier argument remplit le premier paramètre, et ainsi de suite.

def puissance(base, exposant):
    return base ** exposant

print(puissance(2, 10))   # 2 ** 10 = 1024
print(puissance(10, 2))   # 10 ** 2 = 100

Arguments par défaut

On peut donner à un paramètre une valeur par défaut : si l'appel ne fournit pas d'argument pour lui, Python utilise la valeur par défaut. Pratique pour rendre un paramètre optionnel.

def salut(nom, poli=True):
    if poli:
        return "Bonjour " + nom
    else:
        return "Salut " + nom

print(salut("Ada"))          # Bonjour Ada
print(salut("Ada", False))   # Salut Ada

4. Renvoyer plusieurs valeurs

Une fonction peut renvoyer plusieurs valeurs d'un coup en les séparant par des virgules après return. Python les regroupe alors dans un tuple (une liste figée de valeurs). Côté appelant, on récupère chaque valeur avec le dépaquetage x, y = ....

def divise(a, b):
    quotient = a // b
    reste = a % b
    return quotient, reste   # renvoie un tuple (q, r)

q, r = divise(17, 5)         # dépaquetage : q = 3, r = 2
print(q)   # 3
print(r)   # 2

5. Portée : variables locales et globales

Une variable créée dans une fonction est locale : elle n'existe que pendant l'exécution de la fonction et disparaît ensuite. Elle est invisible à l'extérieur. Les paramètres, eux aussi, sont des variables locales.

def f():
    n = 10        # n est locale à f
    return n

print(f())        # affiche 10
# print(n)        # -> erreur : n n'existe pas en dehors de f

À l'inverse, une variable définie hors de toute fonction est globale et peut être lue depuis une fonction. Mais s'appuyer là-dessus rend le code fragile et difficile à relire.

seuil = 10          # variable globale

def au_dessus(x):
    return x > seuil   # lit la globale seuil

print(au_dessus(15))  # True

6. Composer des fonctions

La grande force des fonctions : une fonction peut en appeler une autre. On construit ainsi des programmes en assemblant des briques testées séparément. On écrit une petite fonction utile, puis on la réutilise partout.

def est_pair(n):
    return n % 2 == 0

def compte_pairs(debut, fin):
    total = 0
    for k in range(debut, fin + 1):
        if est_pair(k):        # on réutilise est_pair
            total = total + 1
    return total

print(compte_pairs(1, 10))     # 5 (2, 4, 6, 8, 10)

7. Exercices d'application

À faire de tête (ou au brouillon) avant d'ouvrir le corrigé.

def est_pair(n):
    return n % 2 == 0

def division(a, b):
    return a // b, a % b

q, r = division(17, 5)   # dépaquetage : q = 3, r = 2
print(q, r)              # affiche 3 2

def montre(x):
    print(x + 1)

def calcule(x):
    return x + 1

a = montre(4)
r = calcule(4)
print(r + 10)

8. Erreurs classiques (les pièges qui coûtent des points)

Voici les fautes qu'on retrouve dans presque toutes les copies de début de prépa. Les connaître, c'est déjà les éviter.

8. Pour aller plus loin

Les fonctions sont partout : dès que tu manipules des listes, que tu écris un algorithme de recherche ou une fonction qui s'appelle elle-même, tu réinvestis tout ce chapitre. Enchaîne avec :

• Récursivité — une fonction qui s'appelle elle-même, cas de base et return
• Listes — parcourir, construire et renvoyer des listes depuis une fonction
• Recherche dichotomique — un algorithme classique écrit comme une fonction à paramètres