Paramètres : passage par valeur et par variable

Plan de cours

Copie ou pointeur : le destin des arguments

Comment les sous-programmes reçoivent leurs données, et surtout renvoient leurs effets : c'est le mécanisme des paramètres. Sujet de toutes les confusions au bac, et heureusement de toutes les bonnes questions de cours.

Concepts clés

1. Paramètre formel (signature) vs effectif (appel).
2. Passage par valeur = copie ; modifications locales.
3. Passage par variable = même mémoire ; modifications persistent.
4. En Python : immuables (int, str, tuple) → comme par valeur. Mutables (list, dict) → comme par référence.

Avant de commencer

• Q1. Si une fonction modifie un paramètre x, le x de l'appelant change-t-il ?
• Q2. En Python, est-ce que def f(L): L.append(5) modifie le tableau de l'appelant ?
• Q3. Pourquoi écrire Procédure echange(VAR a, VAR b) en algorithmique tunisien ?

1. Le contenu du cours

1.1 Vocabulaire de base

Exemple :

def calculer(a, b):       # a, b : paramètres formels
    return a + b

x = 3
y = 5
resultat = calculer(x, y)  # x, y : paramètres effectifs

1.2 Le passage par valeur

Mode par défaut en algorithmique tunisien quand on n'écrit rien devant le paramètre.

Syntaxe algorithmique

Procédure exemple(x : entier)
    x ← x + 10
FinProcédure

Trace mentale

Appel : exemple(5)
   x reçoit la VALEUR 5 (copie)
   x ← x + 10 → x devient 15 (dans le sous-programme)
Fin de l'appel : la copie est détruite, la variable de l'appelant est intacte.

Conséquence. Si vous passez n = 5 à la procédure et qu'elle fait x ← x + 10, votre n reste 5 après l'appel.

1.3 Le passage par variable

Syntaxe algorithmique tunisienne

On préfixe le paramètre du mot-clé VAR :

Procédure incrementer(VAR x : entier)
    x ← x + 1
FinProcédure

Appel et trace :

n ← 5
incrementer(n)
→ x et n désignent la MÊME case mémoire
→ x ← x + 1 → la case devient 6
→ n vaut maintenant 6 après l'appel

1.4 Python : pas de syntaxe explicite mais une règle simple

Python n'a pas de mot-clé VAR ou ref. Mais le comportement dépend du type de l'argument :

Exemple 1 — Immuable (entier)

def incrementer(x):
    x = x + 1
    print("dans fonction, x =", x)

n = 5
incrementer(n)
print("après appel, n =", n)

Sortie :

dans fonction, x = 6
après appel, n = 5

L'entier n n'est pas modifié. C'est comme un passage par valeur.

Exemple 2 — Mutable (liste)

def ajouter_zero(T):
    T.append(0)
    print("dans fonction, T =", T)

L = [1, 2, 3]
ajouter_zero(L)
print("après appel, L =", L)

Sortie :

dans fonction, T = [1, 2, 3, 0]
après appel, L = [1, 2, 3, 0]

La liste est modifiée : c'est comme un passage par référence.

1.5 Cas canonique : échange de deux variables

En notation tunisienne :

Procédure echanger(VAR a : entier, VAR b : entier)
    Variables locales : temp : entier
    Début
        temp ← a
        a ← b
        b ← temp
    Fin
FinProcédure

Appel :

x ← 3 ; y ← 7
echanger(x, y)
{ Maintenant x = 7 et y = 3 }

En Python — version 1 (avec une liste, par référence)

def echanger(T, i, j):
    T[i], T[j] = T[j], T[i]

L = [3, 7, 12]
echanger(L, 0, 1)
print(L)   # [7, 3, 12]

En Python — version 2 (avec un tuple de retour, idiomatique)

def echanger(a, b):
    return b, a

x, y = 3, 7
x, y = echanger(x, y)
print(x, y)   # 7 3

1.6 Retourner plusieurs valeurs

Quand on a besoin de plusieurs résultats, deux options :

Option A — Plusieurs paramètres VAR (algorithmique)

Procédure division_entiere(a : entier, b : entier, VAR q : entier, VAR r : entier)
    q ← a DIV b
    r ← a MOD b
FinProcédure

Option B — Tuple de retour (Python idiomatique)

def division_entiere(a, b):
    q = a // b
    r = a % b
    return q, r

quotient, reste = division_entiere(17, 5)
print(quotient, reste)   # 3 2

1.7 Trace d'exécution — Mode mixte

Énoncé. Un programme appelle :

n ← 5
T ← [1, 2, 3]
modifier(n, T)

avec la procédure :

Procédure modifier(VAR n : entier, T : tableau d'entiers)
    n ← n + 100
    T[0] ← 99
FinProcédure

Question. Que valent n et T après l'appel ?

2. Exercices pratiques

Niveau Débutant — Type bac courant

Procédure A(x : entier)
    x ← x * 2
FinProcédure

Procédure B(VAR x : entier)
    x ← x * 2
FinProcédure

Procédure C(x : entier)
    Écrire(x * 2)
FinProcédure

Niveau Intermédiaire — Type bac difficile

Procédure echanger(VAR x : entier, VAR y : entier)
    Variables : temp : entier
    Début
        temp ← x
        x ← y
        y ← temp
    Fin
FinProcédure

Procédure trier_trois(VAR a : entier, VAR b : entier, VAR c : entier)
    Début
        Si a > b Alors echanger(a, b) FinSi
        Si b > c Alors echanger(b, c) FinSi
        Si a > b Alors echanger(a, b) FinSi
    Fin
FinProcédure

def trier_trois(a, b, c):
    return sorted([a, b, c])

Niveau Avancé — Hors bac (bonus)

Procédure statistiques(
    notes : tableau de N réels,
    N : entier,
    VAR moy : réel,
    VAR mini : réel,
    VAR maxi : réel,
    VAR nb_admis : entier
)

Procédure statistiques(notes, N, VAR moy, VAR mini, VAR maxi, VAR nb_admis)
    Variables : i : entier, somme : réel
    Début
        somme ← 0
        mini ← notes[1]
        maxi ← notes[1]
        nb_admis ← 0
        Pour i de 1 à N Faire
            somme ← somme + notes[i]
            Si notes[i] < mini Alors mini ← notes[i] FinSi
            Si notes[i] > maxi Alors maxi ← notes[i] FinSi
            Si notes[i] >= 10 Alors nb_admis ← nb_admis + 1 FinSi
        FinPour
        moy ← somme / N
    Fin
FinProcédure

def statistiques(notes):
    """Retourne (moyenne, min, max, nb_admis)."""
    somme = 0
    mini = notes[0]
    maxi = notes[0]
    nb_admis = 0
    
    for note in notes:
        somme += note
        if note < mini:
            mini = note
        if note > maxi:
            maxi = note
        if note >= 10:
            nb_admis += 1
    
    moy = somme / len(notes)
    return moy, mini, maxi, nb_admis

# Appel
notes = [12, 8, 15, 18, 9, 13.5]
moy, mini, maxi, n_admis = statistiques(notes)
print(f"Moyenne : {moy:.2f}")
print(f"Min : {mini}, Max : {maxi}")
print(f"Admis : {n_admis}/{len(notes)}")

return moy, mini, maxi, nb_admis   # retourne un tuple à 4 éléments

moy, mini, maxi, n_admis = statistiques(notes)

⚠️ Erreurs fréquentes au bac

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

• Erreur 1. Oublier VAR devant un paramètre qu'on veut modifier (passage par variable obligatoire).
• Erreur 2. Modifier un paramètre passé par valeur en croyant modifier l'original. Ne marche que pour les types mutables (tableaux/listes).
• Erreur 3. En Python, croire qu'un entier passé en paramètre sera modifié à l'extérieur. Faux : les entiers sont immuables.
• Erreur 4. Confondre paramètre formel (celui de la déclaration) et paramètre effectif (celui de l'appel).

3. Quiz de vérification

En résumé

Avant la leçon 3.4 (Traitements sur tableaux), vérifiez que vous savez :

• ✅ Marquer VAR quand un paramètre doit être modifié,
• ✅ Prédire la valeur d'une variable après un appel de procédure,
• ✅ Distinguer mutables (listes) et immuables (entiers, chaînes) en Python,
• ✅ Retourner plusieurs valeurs (par tuple en Python, par VAR en algorithmique).

Les tableaux que vous verrez à la leçon suivante sont toujours manipulés via passage par référence — d'où l'importance de bien comprendre les modes.