Séance 5 : Modularité 2 (Les Procédures & Modes de passage)

Phase {{ currentPhase === 'all' ? 'Toutes' : currentPhase + ' / ' + phases.length }}

Phase active :

{{ currentPhase === 'all' ? 'Vue d\'ensemble (Toutes les phases)' : phases[currentPhase - 1].title }}

Étape 1

Situation & Démonstration interactive

15 min

Énoncé

« Saisir deux entiers X et Y dans [1, 100], permuter leurs valeurs à l'aide d'une procédure dédiée, puis afficher les valeurs avant et après la permutation. Observer l'impact du mode de passage des paramètres. »

Simulateur Mémoire : Passage par Valeur vs par Adresse (@)

Jeux d'essai :

Choisir le mode de passage pour Permuter :

Variable globale X :

Variable globale Y :

1. Mémoire Appelant (Avant appel)

@0x101 X {{ simX }}

@0x102 Y {{ simY }}

2. Pile Locale : Permuter({{ isSwapped ? '@a, @b' : 'a, b' }})

TDOL (local) aux {{ simX }}

3. Mémoire Appelant (Après retour)

@0x101 X {{ finalX }}

@0x102 Y {{ finalY }}

Grâce au symbole @, les paramètres formels modifient directement les cases mémoires réelles des variables X et Y dans le programme appelant.

En passage par valeur, seules les copies temporaires (a et b) ont été inversées. Les variables globales X et Y conservent leurs valeurs initiales.

Terminal Python

Questions de réflexion :

Algorithmique

Python

Étape 2

Modes de passage & Portée des identificateurs

15 min

Critère	Fonction	Procédure
Rôle principal	Calcule et retourne une valeur unique	Exécute un traitement (action, affichage, modification)
En-tête algorithmique	`Fonction Nom(...) : Type_simple`	`Procédure Nom(pf1: T1, @pf2: T2)`
Syntaxe d'appel	Dans une expression : `v ← Nom(...)`	Instruction autonome : `Nom(...)`
Modification d'arguments	Non (calcul pur)	Possible via le passage par adresse (`@`)

Passage par valeur (par défaut)

Le paramètre effectif transmet une copie de sa valeur. La variable de l'appelant reste totalement inchangée.

Procédure Afficher(val: Entier)

Passage par adresse (@)

Le paramètre formel pointe directement sur la case mémoire de la variable effective. Toute modification est répercutée.

Procédure Permuter(@a: Entier, @b: Entier)

Variable Locale (T.D.O.L.)

Déclarée au sein du sous-programme. Accessible exclusivement dans son bloc d'exécution. Détruite dès la sortie du module.

Variable Globale (T.D.O.G.) & mot-clé global

Déclarée dans le programme principal. En Python, si une procédure doit modifier une variable simple globale sans retour, elle la déclare via global nom_var.

Étape 3

Algorithme & Programme Python

25 min

Solution Modulaire (Procédures) Conforme 2024-2025

// 1. Procédure de saisie contrôlée par adresse (@n)
Procédure Saisie (@n: Entier, min: Entier, max: Entier)
DEBUT
    Répéter
        Écrire("Donner un entier entre ", min, " et ", max, " : ")
        Lire(n)
    Jusqu'à (n ≥ min) Et (n ≤ max)
FIN

// 2. Procédure de permutation par adresse (@a, @b)
Procédure Permuter (@a: Entier, @b: Entier)
DEBUT
    aux ← a
    a ← b
    b ← aux
FIN

// 3. Procédure d'affichage avec passage par valeur
Procédure AfficherCouple (msg: Chaîne, v1: Entier, v2: Entier)
DEBUT
    Écrire(msg, " : X = ", v1, " | Y = ", v2)
FIN

// 4. Algorithme Principal
ALGORITHME GestionPermutation
DEBUT
    Saisie(x, 1, 100)
    Saisie(y, 1, 100)
    
    AfficherCouple("Avant permutation", x, y)
    Permuter(x, y)
    AfficherCouple("Après permutation", x, y)
FIN

Déclarations : T.D.O.L. & T.D.O.G.

T.D.O.L. (Saisie)

Objet	Type / Nature
Néant (aucun objet local supplémentaire)

T.D.O.L. (Permuter)

Objet	Type / Nature
`aux`	Entier (variable locale d'échange)

T.D.O.L. (AfficherCouple)

Objet	Type / Nature
Néant (uniquement paramètres formels)

T.D.O.G. (Programme Principal)

Objet	Type / Nature
`x, y`	Entier
`Saisie, Permuter, AfficherCouple`	Procédures

gestion_permutation.py

# 1. Procédure de saisie
def saisie_intervalle(borne_min, borne_max):
    val = 0
    while not (borne_min <= val <= borne_max):
        val = int(input(f"Donner un entier entre {borne_min} et {borne_max} : "))
    return val

# 2. Procédure de permutation via mot-clé global
def permuter():
    global x, y
    aux = x
    x = y
    y = aux

# 3. Procédure d'affichage (passage par valeur)
def afficher_couple(msg, a, b):
    print(msg, "-> X =", a, "| Y =", b)

# --- Programme Principal ---
x = saisie_intervalle(1, 100)
y = saisie_intervalle(1, 100)

afficher_couple("Avant permutation", x, y)
permuter()
afficher_couple("Après permutation", x, y)

Conformité Officielle

Mot-clé global : Conformément à la convention d'inspection 2024 (section 7.d), la modification de scalaires globaux en procédure se déclare avec global.
Paramètre par adresse (@) : En algorithmique, le symbole @ est obligatoire devant les paramètres formels modifiés.
Règle d'appel : L'appel d'une procédure s'effectue comme une instruction autonome, sans affectation.

Étape 4

Bilan & Auto-évaluation (Quiz)

5 min

Questions flash :

Algo {{ f.resAlgo }}

Python {{ f.resPy }}

Auto-évaluation : Quiz Procédures (10 questions)

Score : {{ quizScore }} / {{ quizQuestions.length }}

Explication : {{ q.explanation }}

Séance 5 terminée !

Vous maîtrisez désormais les deux piliers de la modularité : Fonctions et Procédures.

Série 6 (6 exercices)

Étape {{ currentPhase }} / {{ phases.length }} {{ phases[currentPhase - 1].shortTitle }}