Les fonctions

Les fonctions sont l'outil #1 pour organiser et réutiliser son code. Au niveau Basique, on utilisait des fonctions natives (len, sum, sorted…). Au niveau Opérationnel, vous allez créer les vôtres. C'est la différence entre « savoir utiliser Python » et « coder en Python ».

Pourquoi des fonctions ?

Imaginez devoir calculer la moyenne de 3 listes de notes différentes. Sans fonction :

notes_alice = [12, 15, 14, 16]
notes_bob = [11, 10, 9, 8]
notes_charlie = [18, 17, 19, 16]

print("Alice :", sum(notes_alice) / len(notes_alice))
print("Bob   :", sum(notes_bob) / len(notes_bob))
print("Charlie :", sum(notes_charlie) / len(notes_charlie))

On répète la même logique (sum(...) / len(...)) trois fois. Avec une fonction :

def moyenne(notes):
    return sum(notes) / len(notes)

print("Alice :", moyenne([12, 15, 14, 16]))
print("Bob   :", moyenne([11, 10, 9, 8]))
print("Charlie :", moyenne([18, 17, 19, 16]))

Les fonctions apportent trois bénéfices majeurs :

1. Réutilisation : on écrit la logique une fois, on l'utilise N fois.
2. Lisibilité : moyenne(notes) est plus parlant que sum(notes)/len(notes).
3. Maintenance : si la formule change, on corrige un seul endroit.

Définir et appeler une fonction

Syntaxe de définition

def nom_fonction(parametres):
    """Docstring (optionnelle mais recommandée)."""
    # corps de la fonction
    return valeur       # optionnel

Premier exemple

def saluer():
    print("Bonjour TOSA !")

# Appel
saluer()
saluer()

Décomposition :

• def : mot-clé qui annonce une définition de fonction.
• saluer : nom de la fonction (en snake_case).
• () : parenthèses — obligatoires, même sans paramètre.
• : : deux-points (comme pour if, for, while).
• indentation : le bloc appartient à la fonction.

Les paramètres

Les paramètres permettent de passer des données à la fonction.

def saluer(prenom):
    print("Bonjour", prenom)

saluer("Alice")
saluer("Bob")

Plusieurs paramètres, séparés par des virgules :

def additionner(a, b):
    resultat = a + b
    print(resultat)

additionner(3, 5)
additionner(10, 20)

Vocabulaire précis : paramètre vs argument

def multiplier(a, b):   # a et b sont des paramètres
    return a * b

r = multiplier(3, 5)    # 3 et 5 sont des arguments

C'est un détail, mais le TOSA peut tester le vocabulaire.

L'instruction return

return renvoie une valeur à l'appelant et sort immédiatement de la fonction.

def carre(x):
    return x * x

r = carre(5)
print(r)
print(carre(10) + carre(3))

Différence fondamentale entre print et return

Une fonction peut avoir plusieurs return

Utile pour les conditions :

def valeur_absolue(x):
    if x >= 0:
        return x
    else:
        return -x

print(valeur_absolue(5))
print(valeur_absolue(-7))

Une fonction peut ne rien returner

Dans ce cas, elle renvoie implicitement None :

def bonjour(nom):
    print("Bonjour", nom)
    # pas de return

resultat = bonjour("Alice")
print("resultat =", resultat)      # None

Retour multiple (tuple implicite)

On peut renvoyer plusieurs valeurs séparées par des virgules — c'est en fait un tuple.

def min_max(nombres):
    return min(nombres), max(nombres)

result = min_max([3, 1, 4, 1, 5, 9, 2, 6])
print(result)
print(type(result))

# Déballage direct
petit, grand = min_max([3, 1, 4, 1, 5, 9, 2, 6])
print("Min:", petit, "Max:", grand)