Les fonctions 🧩

Imagine que tu doives calculer la moyenne de la classe plusieurs fois. Tu ne vas pas réécrire le calcul à chaque fois, si ? Les fonctions sont là pour ça : des mini-programmes à l'intérieur de ton programme que tu peux appeler quand tu veux.

---

1. Pourquoi des fonctions ? 🤔

Les fonctions, c'est comme des recettes dans un livre de cuisine :

• Une recette a un nom ("Crêpes", "Gâteau au chocolat")
• Elle prend des ingrédients (les paramètres)
• Elle produit un plat (le résultat)
• Tu peux la réutiliser autant de fois que tu veux

Avantages des fonctions :

• ✅ Réutiliser du code sans le copier-coller
• ✅ Organiser son programme en petits morceaux lisibles
• ✅ Tester chaque morceau indépendamment
• ✅ Éviter les répétitions

---

2. Définir et appeler une fonction 🏗️

En Python, on crée une fonction avec def, suivi du nom, de parenthèses () et de deux-points : :

def carrer(x):          # def = définir une fonction
    """Retourne le carré de x."""  # Documentation
    return x * x        # return = donner le résultat

# Appel de la fonction
resultat = carrer(5)    # On appelle carrer avec x = 5
print(resultat)         # Affiche : 25

Comment ça marche ?

1. carrer(5) → le programme appelle la fonction avec x = 5
2. Il entre dans la fonction et exécute return 5 * 5
3. Le résultat (25) est renvoyé et stocké dans resultat
4. Le programme reprend là où il s'était arrêté

En pseudo-code :

Exécution pas à pas
pseudo
1/9
1DEBUT2    resultat ← carrer(5)    ⬅ J'appelle la fonction avec 53    afficher(resultat)       ⬅ J'affiche le résultat4FIN5 6FONCTION carrer(x)          ⬅ Je définis la fonction7    RETOURNER x * x         ⬅ Je calcule et je renvoie8FIN FONCTION9 
🟢
DEBUT
DÉPARTLe programme démarre, toutes les variables sont prêtes.
Le programme démarre. Tout est initialisé, prêt à exécuter les instructions.

Regarde le diagramme interactif "Exécution pas à pas" plus bas : tu verras la flèche entrer dans carrer(), calculer, puis revenir dans main() ! 🕹️

---

3. Paramètres et valeur de retour 📦

Les paramètres sont les "ingrédients" qu'on donne à la fonction. Le retour (return) est le "plat" qu'elle nous renvoie.

def saluer(nom, age=0):              # 'nom' est obligatoire, 'age' est optionnel (vaut 0 par défaut)
    if age:
        return f"Bonjour {nom}, tu as {age} ans"
    return f"Bonjour {nom}"

print(saluer("Alice", 25))  # → "Bonjour Alice, tu as 25 ans"
print(saluer("Bob"))        # → "Bonjour Bob"

🔍 À retenir :

• Les paramètres sont les entrées de la fonction
• return est la sortie — il renvoie une valeur et arrête la fonction
• Une fonction sans return renvoie None (rien)

Exécution pas à pas
pseudo
1/8
1FONCTION saluer(nom, age)2    SI age > 0 ALORS3        RETOURNER "Bonjour " + nom + ", tu as " + age + " ans"4    SINON5        RETOURNER "Bonjour " + nom6    FIN SI7FIN FONCTION8 
🧩
FONCTION saluer(nom, age)
FONCTION saluer(nom, age)Le programme exécute cette action, puis passe à la suivante.
On définit une fonction appelée "saluer(nom, age)". Cette fonction contient des instructions qui seront exécutées quand on l'appelle.

---

4. Portée des variables — le "champ d'action" 🌍

Une variable créée dans une fonction n'existe qu'à l'intérieur de cette fonction. On dit qu'elle est locale.

x = 10  # Variable GLOBALE : elle existe partout

def ma_fonction():
    y = 5  # Variable LOCALE : elle n'existe que dans cette fonction
    print(x)  ✅ On peut LIRE une variable globale

ma_fonction()       # Affiche : 10
print(y)            # ❌ ERREUR ! y n'existe pas ici

💡 Astuce pour t'en souvenir :

• Les variables locales sont comme des ingrédients dans la cuisine du chef. Personne d'autre n'y touche.
• Les variables globales sont comme le sucre dans le placard commun. Tout le monde peut le voir.
• En général, on préfère les variables locales — c'est plus propre et moins source d'erreurs !

---

5. Exercice : fonction maximum 🏆

Écris une fonction qui trouve le plus grand de trois nombres :

def maximum(a, b, c):
    max = a
    if b > max:
        max = b
    if c > max:
        max = c
    return max

print(maximum(3, 7, 5))  # Affiche : 7
print(maximum(12, 4, 9)) # Affiche : 12

---

6. Pour aller plus loin : la récursivité 🔄

Une fonction récursive c'est une fonction qui s'appelle elle-même. Comme des poupées russes : chaque poupée en contient une plus petite.

Deux ingrédients obligatoires :

1. Un cas de base — la condition qui arrête les appels (sinon → boucle infinie !)
2. Un appel récursif — la fonction s'appelle elle-même avec un problème plus petit

Exemple : la factorielle (5! = 5 × 4 × 3 × 2 × 1)

Exécution pas à pas
pseudo
1/8
1FONCTION factorielle(n)2    SI n <= 1 ALORS              ⬅ Cas de base : 1! = 13        RETOURNER 14    SINON5        RETOURNER n * factorielle(n - 1)  ⬅ Appel récursif6    FIN SI7FIN FONCTION8 
🧩
FONCTION factorielle(n)
FONCTION factorielle(n)Le programme exécute cette action, puis passe à la suivante.
On définit une fonction appelée "factorielle(n)". Cette fonction contient des instructions qui seront exécutées quand on l'appelle.

def factorielle(n):
    if n <= 1:           # Cas de base : si n vaut 0 ou 1, on s'arrête
        return 1
    return n * factorielle(n - 1)  # Appel récursif : on calcule n × (n-1)!

print(factorielle(5))    # 5 × 4 × 3 × 2 × 1 = 120

Pas à pas pour factorielle(5) :

1. factorielle(5) → 5 n'est pas ≤ 1, donc → 5 * factorielle(4)
2. factorielle(4) → 4 n'est pas ≤ 1, donc → 4 * factorielle(3)
3. factorielle(3) → → 3 * factorielle(2)
4. factorielle(2) → → 2 * factorielle(1)
5. factorielle(1) → 1 ≤ 1 → cas de base ! → retourne 1
6. Les appels se "dépilent" : 2×1 = 2 → 3×2 = 6 → 4×6 = 24 → 5×24 = 120 🎉

Regarde le CallStackVisualizer plus bas : tu verras la pile d'appels s'empiler et se dépiler en direct !

7. Exercices pour toi 🎯

Exercice 1 : Factorielle — teste la fonction ci-dessus dans l'onglet Sandbox

Exercice 2 : Fibonacci

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 55

Exercice 3 : Ta propre fonction ! Écris une fonction est_pair(n) qui retourne True si n est pair, False sinon. Teste-la avec plusieurs nombres.

💡 Rappel : Une fonction doit faire une seule chose et la faire bien. Si ta fonction fait trop de choses, découpe-la en plusieurs petites fonctions !