Module 2.5 – Fonctions

Objectif

Comprendre pourquoi et comment découper un programme en fonctions. Maîtriser les paramètres et les valeurs de retour pour créer du code réutilisable et organisé.

Théorie

Pourquoi découper un programme ?

Un programme peut devenir très long et difficile à comprendre. Les fonctions permettent de :

1. Réutiliser du code

• Écrire une fois, utiliser plusieurs fois
• Éviter la répétition

2. Organiser le code

• Diviser un gros problème en petits problèmes
• Chaque fonction a une responsabilité précise

3. Faciliter la maintenance

• Modifier une fonction modifie son comportement partout
• Plus facile à déboguer

4. Améliorer la lisibilité

• Un nom de fonction explique ce qu'elle fait
• Le code principal devient plus clair

Analogie : Comme des outils dans une boîte à outils. Chaque outil (fonction) a un usage précis et peut être réutilisé.

Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code nommé qui effectue une tâche spécifique et peut retourner un résultat.

Structure de base :

FONCTION nom_fonction(parametre1, parametre2) RETOURNE type
    instructions
    RETOURNER valeur
FIN FONCTION

Exemple simple :

FONCTION saluer(nom) RETOURNE texte
    message ← "Bonjour " + nom
    RETOURNER message
FIN FONCTION

// Utilisation
resultat ← saluer("Jean")
AFFICHER resultat  // "Bonjour Jean"

Paramètres

Les paramètres (ou arguments) sont les données qu'on passe à une fonction.

Fonction sans paramètre

FONCTION obtenir_date() RETOURNE texte
    RETOURNER "2026-01-26"
FIN FONCTION

date ← obtenir_date()

Fonction avec un paramètre

FONCTION calculer_carre(nombre) RETOURNE nombre
    resultat ← nombre * nombre
    RETOURNER resultat
FIN FONCTION

carre_de_5 ← calculer_carre(5)  // 25
carre_de_10 ← calculer_carre(10)  // 100

Fonction avec plusieurs paramètres

FONCTION additionner(a, b) RETOURNE nombre
    somme ← a + b
    RETOURNER somme
FIN FONCTION

resultat ← additionner(5, 3)  // 8

Valeur de retour

La valeur de retour est le résultat que la fonction produit.

Fonction avec retour

FONCTION calculer_moyenne(note1, note2, note3) RETOURNE nombre
    somme ← note1 + note2 + note3
    moyenne ← somme / 3
    RETOURNER moyenne
FIN FONCTION

moyenne_etudiant ← calculer_moyenne(15, 18, 12)  // 15

Fonction sans retour (procédure)

Certaines fonctions ne retournent rien, elles font juste une action :

FONCTION afficher_message(texte)
    AFFICHER texte
FIN FONCTION

afficher_message("Bonjour")  // Affiche "Bonjour"

Portée des variables

Les variables créées dans une fonction sont locales à cette fonction.

Exemple :

FONCTION calculer() RETOURNE nombre
    x ← 10  // Variable locale
    RETOURNER x * 2
FIN FONCTION

x ← 5  // Variable globale (différente)
resultat ← calculer()  // Utilise x = 10 de la fonction
AFFICHER x  // Affiche 5 (la variable globale)

Exemples pratiques

Exemple 1 : Validation d'email

FONCTION est_email_valide(email) RETOURNE booléen
    SI email CONTIENT "@" ET email CONTIENT "." ALORS
        RETOURNER true
    SINON
        RETOURNER false
    FIN SI
FIN FONCTION

SI est_email_valide("jean@exemple.com") ALORS
    AFFICHER "Email valide"
SINON
    AFFICHER "Email invalide"
FIN SI

Exemple 2 : Calculer le maximum

FONCTION maximum(a, b) RETOURNE nombre
    SI a > b ALORS
        RETOURNER a
    SINON
        RETOURNER b
    FIN SI
FIN FONCTION

max ← maximum(15, 23)  // 23

Exemple 3 : Parcourir et afficher un tableau

FONCTION afficher_tableau(tableau)
    POUR i DE 0 À longueur(tableau) - 1 FAIRE
        AFFICHER tableau[i]
    FIN POUR
FIN FONCTION

nombres ← [10, 20, 30]
afficher_tableau(nombres)

Exemple 4 : Rechercher dans un tableau

FONCTION chercher_dans_tableau(tableau, valeur) RETOURNE nombre
    POUR i DE 0 À longueur(tableau) - 1 FAIRE
        SI tableau[i] == valeur ALORS
            RETOURNER i  // Retourne la position
        FIN SI
    FIN POUR
    RETOURNER -1  // Non trouvé
FIN FONCTION

liste ← [5, 10, 15, 20]
position ← chercher_dans_tableau(liste, 15)  // 2
SI position >= 0 ALORS
    AFFICHER "Trouvé à la position " + position
SINON
    AFFICHER "Non trouvé"
FIN SI

Fonctions récursives

Une fonction peut s'appeler elle-même (récursion).

Exemple : Calculer la factorielle

FONCTION factorielle(n) RETOURNE nombre
    SI n <= 1 ALORS
        RETOURNER 1
    SINON
        RETOURNER n * factorielle(n - 1)
    FIN SI
FIN FONCTION

resultat ← factorielle(5)  // 5 * 4 * 3 * 2 * 1 = 120

Attention : La récursion doit avoir une condition d'arrêt, sinon boucle infinie.

Bonnes pratiques

1. Nommer clairement

• ✅ calculer_moyenne
• ❌ f1 ou calcul

2. Une fonction, une responsabilité

• ✅ Une fonction qui calcule la moyenne
• ❌ Une fonction qui calcule la moyenne ET affiche ET sauvegarde

3. Paramètres clairs

• ✅ calculer_prix_ttc(prix_ht, taux_tva)
• ❌ calculer(x, y)

4. Documenter

• Expliquer ce que fait la fonction
• Expliquer les paramètres
• Expliquer la valeur de retour

Exercice

1. Créer une fonction simple

   • Créez une fonction multiplier qui prend deux nombres et retourne leur produit

2. Fonction avec condition

   • Créez une fonction est_majeur qui prend un age et retourne true si >= 18

3. Fonction sur tableau

   • Créez une fonction somme_tableau qui prend un tableau de nombres et retourne leur somme

4. Fonction avec plusieurs cas

   • Créez une fonction categorie_age qui prend un age et retourne :
     • "Enfant" si < 12
     • "Adolescent" si 12-17
     • "Adulte" si 18-64
     • "Senior" si >= 65

5. Combiner des fonctions

   • Créez une fonction moyenne qui calcule la moyenne d'un tableau
   • Créez une fonction appreciation qui prend une moyenne et retourne une appréciation
   • Utilisez les deux fonctions ensemble

Quiz

1. Pourquoi utiliser des fonctions ?

   • Pour rendre le code plus long
   • Pour réutiliser du code et mieux l'organiser
   • Pour compliquer les choses

2. Que sont les paramètres d'une fonction ?

   • Les résultats de la fonction
   • Les données qu'on passe à la fonction
   • Les variables globales

3. Que fait "RETOURNER" dans une fonction ?

   • Arrête le programme
   • Renvoie une valeur comme résultat
   • Affiche quelque chose

4. Peut-on appeler une fonction depuis une autre fonction ?

   • Oui
   • Non
   • Seulement dans certains langages

5. Quelle est une bonne pratique pour nommer une fonction ?

   • Utiliser des lettres simples (f, g, h)
   • Utiliser un nom descriptif (calculer_moyenne)
   • Utiliser des chiffres (fonction1, fonction2)

Mini défi

Mission : Créer une bibliothèque de fonctions mathématiques

Créez un ensemble de fonctions réutilisables pour des calculs mathématiques :

Fonctions à créer :

1. additionner(a, b)

   • Retourne la somme de a et b

2. soustraire(a, b)

   • Retourne a - b

3. multiplier(a, b)

   • Retourne a * b

4. diviser(a, b)

   • Retourne a / b
   • Gérer le cas où b = 0 (retourner une erreur ou 0)

5. puissance(base, exposant)

   • Retourne base^exposant
   • Exemple : puissance(2, 3) = 8

6. maximum(liste)

   • Prend un tableau de nombres
   • Retourne le plus grand nombre

7. minimum(liste)

   • Prend un tableau de nombres
   • Retourne le plus petit nombre

8. moyenne(liste)

   • Prend un tableau de nombres
   • Retourne la moyenne

9. est_pair(nombre)

   • Retourne true si le nombre est pair, false sinon

10. calculer_statistiques(liste)

    • Prend un tableau de nombres
    • Retourne un dictionnaire avec : min, max, moyenne, somme

Programme principal : Créez un programme qui utilise toutes ces fonctions avec des exemples :

nombres ← [10, 5, 20, 15, 8]

AFFICHER "Somme : " + additionner(10, 5)
AFFICHER "Maximum : " + maximum(nombres)
AFFICHER "Moyenne : " + moyenne(nombres)

stats ← calculer_statistiques(nombres)
AFFICHER "Min : " + stats["min"]
AFFICHER "Max : " + stats["max"]
AFFICHER "Moyenne : " + stats["moyenne"]

Critères :

• ✅ Toutes les fonctions sont créées
• ✅ Chaque fonction a un nom clair
• ✅ Les paramètres sont bien définis
• ✅ Les valeurs de retour sont correctes
• ✅ Gestion des cas d'erreur (division par zéro)
• ✅ Code bien organisé et commenté

Objectif : Maîtriser les fonctions et créer du code modulaire et réutilisable.

---

Validation : Vous pouvez passer au Parcours 3 quand vous êtes capable de créer des fonctions avec paramètres et valeurs de retour, et de les utiliser pour organiser votre code.

Félicitations ! Vous avez terminé le Parcours 2 - Algorithmique & structures de données. Vous maîtrisez maintenant les fondamentaux de la programmation !