Procédures vs Fonctions

Plan de cours

Calculer ou agir, telle est la question

Les sous-programmes se déclinent en deux familles : ceux qui produisent une valeur (fonctions), et ceux qui effectuent une action (procédures). Bien les distinguer rend le code intuitif à lire et à utiliser.

Objectifs d'apprentissage

• Différence procédure / fonction
• Écrire les deux types
• Choisir le bon type
• Bibliothèque réutilisable

Concepts clés

1. Fonction — retourne une valeur via Retourner.
2. Procédure — exécute une action, ne retourne rien.
3. Python — def pour les deux ; distinction par présence ou absence de return.
4. Usage — fonction dans une expression, procédure comme instruction.

Avant de commencer — qu'est-ce que vous savez déjà ?

• Q1. En 3ème année, avez-vous utilisé des fonctions Python comme len(...) ou abs(...) ?
• Q2. print(...) retourne-t-il quelque chose, ou agit-il sur l'écran sans valeur ?
• Q3. Quelle est la différence entre « afficher la moyenne » et « calculer la moyenne » ?

1. Le contenu du cours

1.1 Fonction : retourner une valeur

Fonction carre(x : réel) → réel
    Retourner(x × x)
FinFonction

{ Utilisation }
y ← carre(5)        { y vaut 25 }
Écrire(carre(3))    { affiche 9 }

Fonction carre(x : réel) → réel
    Retourner(x × x)
FinFonction

{ Utilisation }
y ← carre(5)        { y vaut 25 }
Écrire(carre(3))    { affiche 9 }

def carre(x: float) -> float:
    return x * x

# Utilisation
y = carre(5)        # y vaut 25
print(carre(3))     # affiche 9

Caractéristiques.

• Une fonction s'utilise dans une expression : 2 × carre(7), Si carre(n) > 100 Alors ….
• Elle a un type de retour déclaré.
• Elle se termine par Retourner(valeur) (algorithmique) ou return valeur (Python).

1.2 Procédure : effectuer une action

Procédure AfficherEncadré(message : chaîne)
    Écrire("┌─────────────────┐")
    Écrire("│ ", message, " │")
    Écrire("└─────────────────┘")
FinProcedure

{ Utilisation }
AfficherEncadré("Bonjour")

Procédure AfficherEncadré(message : chaîne)
    Écrire("┌─────────────────┐")
    Écrire("│ ", message, " │")
    Écrire("└─────────────────┘")
FinProcedure

{ Utilisation }
AfficherEncadré("Bonjour")

def afficher_encadre(message: str) -> None:
    print("┌─────────────────┐")
    print("│", message, "│")
    print("└─────────────────┘")

# Utilisation
afficher_encadre("Bonjour")

Caractéristiques.

• Une procédure s'appelle comme une instruction : AfficherEncadré("Bonjour"), sans ← autour.
• Pas de type de retour (algorithmique) ou -> None (Python).
• Aucun Retourner (ou return sans valeur).

1.3 En Python : un seul mot-clé pour les deux

Python ne distingue pas syntaxiquement procédure et fonction. Toutes sont définies avec def. La distinction se fait sémantiquement :

def calculer_aire(largeur: float, hauteur: float) -> float:
    """Fonction : retourne l'aire."""
    return largeur * hauteur

def afficher_resultat(nom: str, valeur: float) -> None:
    """Procédure : affiche, ne retourne rien."""
    print(f"{nom} = {valeur}")

# Usage
aire = calculer_aire(3, 4)         # appel de fonction dans une expression
afficher_resultat("Aire", aire)    # appel de procédure comme instruction

1.4 Choisir : fonction ou procédure ?

Règle simple :

Si le code appelant a besoin du résultat pour continuer → fonction. Si le code appelant veut juste qu'une action soit effectuée → procédure.

1.5 Exemple complet : calcul de mention

Décomposition

• calculer_moyenne(notes) → fonction (produit un réel).
• determiner_mention(moyenne) → fonction (produit une chaîne).
• afficher_bulletin(nom, moyenne, mention) → procédure (effet de bord : écran).

Code Python

def calculer_moyenne(notes: list[float]) -> float:
    """Retourne la moyenne d'une liste de notes."""
    if len(notes) == 0:
        return 0.0
    return sum(notes) / len(notes)

def determiner_mention(moyenne: float) -> str:
    """Retourne la mention correspondant à la moyenne."""
    if moyenne >= 16:
        return "Très Bien"
    elif moyenne >= 14:
        return "Bien"
    elif moyenne >= 12:
        return "Assez Bien"
    elif moyenne >= 10:
        return "Passable"
    else:
        return "Refusé"

def afficher_bulletin(nom: str, moyenne: float, mention: str) -> None:
    """Affiche le bulletin d'un élève."""
    print("─" * 40)
    print(f"Élève    : {nom}")
    print(f"Moyenne  : {moyenne:.2f} / 20")
    print(f"Mention  : {mention}")
    print("─" * 40)

# Programme principal
notes = [15.5, 12.0, 17.0, 14.5, 13.0]
nom = "Salma Trabelsi"

moyenne = calculer_moyenne(notes)
mention = determiner_mention(moyenne)
afficher_bulletin(nom, moyenne, mention)

Trace

2. Exercices pratiques

Niveau Débutant — Type bac courant

Fonction celsius_to_fahrenheit(c : réel) → réel
    Retourner(c × 9 / 5 + 32)
FinFonction

def celsius_to_fahrenheit(c: float) -> float:
    return c * 9 / 5 + 32

# Tests
print(celsius_to_fahrenheit(0))      # 32.0
print(celsius_to_fahrenheit(100))    # 212.0
print(celsius_to_fahrenheit(36.6))   # 97.88

Niveau Intermédiaire — Type bac difficile

================================
   CALCULATRICE — Menu
================================
  1. Addition
  2. Soustraction
  3. Multiplication
  4. Division
  0. Quitter
================================

def afficher_menu() -> None:
    print("=" * 32)
    print("   CALCULATRICE — Menu")
    print("=" * 32)
    print("  1. Addition")
    print("  2. Soustraction")
    print("  3. Multiplication")
    print("  4. Division")
    print("  0. Quitter")
    print("=" * 32)

def lire_choix() -> int:
    while True:
        choix = int(input("Votre choix (0-4) : "))
        if 0 <= choix <= 4:
            return choix
        print("Choix invalide, recommencer.")

# Programme principal
afficher_menu()
choix = lire_choix()
print(f"Vous avez choisi l'option {choix}")

Niveau Avancé — Hors bac (bonus)

import math

def aire_rectangle(L: float, l: float) -> float:
    return L * l

def aire_cercle(r: float) -> float:
    return math.pi * r * r

def aire_triangle(b: float, h: float) -> float:
    return (b * h) / 2

def perimetre_rectangle(L: float, l: float) -> float:
    return 2 * (L + l)

def afficher_figure(nom: str, aire: float, perimetre: float = -1) -> None:
    print("┌" + "─" * 36 + "┐")
    print(f"│ {nom:<34} │")
    print(f"│ Aire      : {aire:>10.2f}            │")
    if perimetre >= 0:
        print(f"│ Périmètre : {perimetre:>10.2f}            │")
    print("└" + "─" * 36 + "┘")

# Programme principal
afficher_figure(
    "Rectangle 5 × 3",
    aire_rectangle(5, 3),
    perimetre_rectangle(5, 3),
)
afficher_figure("Cercle r = 7", aire_cercle(7))
afficher_figure("Triangle b=4, h=6", aire_triangle(4, 6))

⚠️ Erreurs fréquentes au bac

Avant le quiz, mémorisez ces pièges classiques qui font perdre des points :

• Erreur 1. Utiliser une fonction quand on n'a rien à retourner (afficher, modifier en place). Préférer une procédure.
• Erreur 2. Oublier Retourner (algo) ou return (Python) dans une fonction. Le compilateur ne signale pas toujours l'erreur.
• Erreur 3. Écrire une Fonction en algorithmique sans Retourner à la fin → incohérence pénalisée.
• Erreur 4. Penser que print(x) retourne la valeur affichée. Non : print retourne None. Pour utiliser une valeur affichée, calculer et stocker d'abord.

3. Quiz de vérification

En résumé

• ✅ Fonction = retourne une valeur, s'utilise dans une expression.
• ✅ Procédure = effectue une action, s'appelle comme instruction.
• ✅ Python : def pour les deux, return distingue.
• ✅ Choix : si le résultat doit être utilisé, fonction ; sinon, procédure.

Prochaine leçon : Paramètres : passage par valeur et par variable — comment les modules échangent des données.