Séance 2 : Type tableau & Procédures

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

Phase active :

{{ currentPhase === 'all' ? 'Vue complète (Toutes les phases affichées)' : phases[currentPhase - 1].title }}

Situation mobilisatrice • Étape 2

Traitement d'un lot d'échantillons par l'automate de laboratoire

Dans la séance précédente, nous avons validé un échantillon isolé. En conditions réelles, le laboratoire de recherche reçoit quotidiennement des lots de N flacons (5 ≤ N ≤ 50). L'automate doit :

1. Réception & Saisie

Enregistrer les identifiants bruts des flacons saisis par le technicien dans un tableau indexé.

2. Nettoyage préliminaire

Retirer le préfixe parasite @ au début de chaque cellule avec la primitive Effacer.

3. Rapport d'analyse

Valider chaque flacon et afficher le relevé complet des mesures et concentrations chimiques.

Phase 1 : Rappel et extension au lot d'échantillons (5 min)

Pourquoi le tableau ?

Imaginez devoir manipuler 50 flacons avec des variables simples : il faudrait déclarer code1, code2, ..., code50. Cela rendrait l'écriture des boucles impossible et le code ingérable.

Pour résoudre ce problème, on recourt à la structure de données Tableau à une dimension :

Homogène : Tous les éléments stockés sont strictement de même type (ex: 50 chaînes ou 50 réels).
Statique : Sa taille maximale est définie dès la déclaration (50 cases mémoires allouées).
Indexé : Chaque cellule est accessible directement en temps constant grâce à son indice i (0 ≤ i < N). En conventions 2024, le premier indice est 0.

Représentation mémoire du tableau indexé :

T[0]

"@CH-94B"

T[1]

"@AC-12D"

...

T[N-1]

"@BA-78K"

Règle d'indexation en Python 3 : Tout comme les conventions algorithmiques 2024, le premier élément d'un tableau est obligatoirement à l'indice 0 (soit T[0]), et le dernier élément d'un lot de N flacons est situé à l'indice N - 1 (soit T[N - 1]).

Phase 2 : Structuration des données (TDNT & TDOG) (15 min)

Formalisation des types

Lorsqu'une structure de tableau est passée entre plusieurs modules ou réutilisée, la convention tunisienne impose la définition d'un Nouveau Type dans le TDNT (Tableau de Déclaration des Nouveaux Types).

TDNT (Tableau de Déclaration des Nouveaux Types)

Type	Description
`TabMesures`	Tableau de 50 réel
`TabCodes`	Tableau de 50 chaîne

La dimension 50 représente la capacité maximale de flacons pouvant être traités par lot.

TDOG (Tableau de Déclaration des Objets Globaux)

Objet	Type / Nature
`N`	Entier (Nombre d'échantillons reçus)
`T_mes`	TabMesures
`T_cod`	TabCodes
`Saisir_Lot`	Procédure
`Nettoyer_Codes`	Procédure
`Afficher_Rapport`	Procédure

Règle stricte d'implémentation des tableaux en Python (Conventions 2024-2025) :

En Python pour les sections scientifiques tunisiennes, les tableaux sont obligatoirement créés avec la bibliothèque numpy (et non pas des listes standards Python) :

Déclaration officielle Python avec numpy

from numpy import array

# Déclaration d'un tableau de 50 chaînes initialisées à vide
T_cod = array([''] * 50, dtype='U20')

# Déclaration d'un tableau de 50 réels initialisés à 0.0
T_mes = array([float()] * 50)

Phase 3 : Activité modulaire 3 – Procédures de saisie et nettoyage (20 min)

Procédures & Effacer

Focus Didactique : Fonctions vs Procédures & Passage de paramètres

Fonction :

Calcule et retourne une seule valeur simple avec Retourner. Appelée au sein d'une expression ou d'une affectation (ex: res ← Valide_Code(code)).

Procédure :

Exécute une suite d'instructions et peut modifier plusieurs variables ou un tableau. Appelée comme une instruction autonome (ex: Nettoyer_Codes(T, N)).

Mode de passage par adresse : En algorithmique 2024, pour qu'un module modifie directement la variable passée par l'appelant, on ajoute le symbole @ devant le nom du paramètre (ex: @T : TabCodes). En Python, les tableaux numpy sont automatiquement passés par adresse !

1. Procédure `Saisir_Lot`

Lit le nombre d'échantillons N avec contrôle de saisie (5 ≤ N ≤ 50), puis remplit le tableau T avec les identifiants bruts.

TDOL Saisir_Lot :

Objet	Type	Rôle
`i`	Entier	Compteur de parcours (0 à N - 1)

Algorithme Saisir_Lot

Procédure Saisir_Lot (@T : TabCodes, @N : entier)
DEBUT
    Répéter
        Écrire ("Donner la taille du lot (5 à 50) : ")
        Lire (N)
    Jusqu'à (N ≥ 5) Et (N ≤ 50)
    
    Pour i de 0 à N - 1 Faire
        Écrire ("Identifiant du flacon N° ", i + 1, " : ")
        Lire (T[i])
    Fin Pour
FIN

Implémentation Python Saisir_Lot

def Saisir_Lot(T):
    taille = 0
    # Contrôle de saisie : boucle Répéter ... Jusqu'à
    while taille not in range(5, 51):
        taille = int(input("Donner la taille du lot (5 à 50) : "))
    
    # Remplissage itératif du tableau numpy T
    for i in range(taille):
        T[i] = input("Identifiant du flacon N° " + str(i + 1) + " : ")
        
    return taille

Le tableau T est modifié par adresse en mémoire. L'entier scalaire étant immuable en Python, la taille est retournée.

2. Procédure `Nettoyer_Codes`

Parcourt le tableau. Si une cellule commence par le préfixe parasite @, elle le supprime avec la primitive officielle Effacer(ch, d, f).

TDOL Nettoyer_Codes :

Objet	Type	Rôle
`i`	Entier	Compteur d'itération (0 à N - 1)

Algorithme Nettoyer_Codes

Procédure Nettoyer_Codes (@T : TabCodes, N : entier)
DEBUT
    Pour i de 0 à N - 1 Faire
        Si (Long(T[i]) > 0) Et (T[i][0] = "@") Alors
            // Suppression du 1er caractère (position 0, indice 1 exclu)
            T[i] ← Effacer(T[i], 0, 1)
        Fin Si
    Fin Pour
FIN

Implémentation Python Nettoyer_Codes

def Nettoyer_Codes(T, N):
    for i in range(N):
        # Vérifier si la cellule commence par le caractère parasite '@'
        if len(T[i]) > 0 and T[i][0] == "@":
            # Traduction officielle de Effacer(T[i], 0, 1) :
            # Découpage par tranche en conservant dès l'indice 1
            T[i] = T[i][1:]

Le passage par adresse natif de T permet la modification directe des flacons en mémoire.

Traduction Python de la primitive Effacer : Selon les conventions officielles 2024, Effacer(ch, d, f) correspond en Python à la concaténation des tranches ch = ch[:d] + ch[f:]. Pour supprimer le caractère en position 0, on a T[i] = T[i][:0] + T[i][1:], soit simplement T[i] = T[i][1:].

Phase 4 : Synthèse et intégration algorithmique (20 min)

Programme Principal Orchestrateur

Le programme principal Controle_Lot_Echantillons coordonne l'enchaînement séquentiel : Saisir_Lot → Nettoyer_Codes → Validation & Mesures → Afficher_Rapport.

3. Procédure `Afficher_Rapport` :

Parcourt les N flacons du lot, évalue si leur concentration se situe dans l'intervalle conforme [10.0, 50.0] mg/L et affiche le rapport formaté ligne par ligne.

TDOL Afficher_Rapport :

Objet	Type	Rôle
`i`	Entier	Compteur de parcours (0 à N - 1)

Algorithme Procédure Afficher_Rapport

Procédure Afficher_Rapport (T_cod : TabCodes, T_mes : TabMesures, N : entier)
DEBUT
    Écrire_nl ("=== RAPPORT DE CONTRÔLE DU LABORATOIRE ===")
    Écrire_nl ("Flacon | Concentration (mg/L) | Statut")
    Écrire_nl ("-----------------------------------------")
    Pour i de 0 à N - 1 Faire
        // Un flacon est valide si sa concentration est entre 10 et 50 mg/L
        Si (T_mes[i] ≥ 10.0) Et (T_mes[i] ≤ 50.0) Alors
            Écrire_nl (T_cod[i], " | ", T_mes[i], " | CONFORME")
        Sinon
            Écrire_nl (T_cod[i], " | ", T_mes[i], " | ANOMALIE DOSAGE")
        Fin Si
    Fin Pour
FIN

Implémentation Python Afficher_Rapport

def Afficher_Rapport(T_cod, T_mes, N):
    print("\n=== RAPPORT DE CONTRÔLE DU LABORATOIRE ===")
    print("Flacon\t| Concentration (mg/L)\t| Statut")
    print("-----------------------------------------")
    for i in range(N):
        if 10.0 <= T_mes[i] <= 50.0:
            statut = "CONFORME"
        else:
            statut = "ANOMALIE DOSAGE"
        # Affichage élément par élément (recommandation officielle)
        print(T_cod[i], "\t|", T_mes[i], "\t\t|", statut)

Conformément aux directives officielles d'inspection, l'affichage des tableaux en Python doit obligatoirement être effectué élément par élément à l'aide d'une boucle for.

Programme Principal Orchestrateur : `Controle_Lot_Echantillons`

Le programme principal coordonne l'enchaînement séquentiel complet : Saisir_Lot → Nettoyer_Codes → Mesures → Afficher_Rapport.

Algorithme principal : Controle_Lot_Echantillons

ALGORITHME Controle_Lot_Echantillons
DEBUT
    // 1. Saisie de N et des identifiants bruts
    Saisir_Lot (T_cod, N)
    
    // 2. Nettoyage des préfixes @ parasites
    Nettoyer_Codes (T_cod, N)
    
    // 3. Traitement des mesures et concentrations
    Pour i de 0 à N - 1 Faire
        Écrire ("Entrer la concentration mesurée pour le flacon ", T_cod[i], " (mg/L) : ")
        Lire (T_mes[i])
    Fin Pour
    
    // 4. Affichage du rapport récapitulatif
    Afficher_Rapport (T_cod, T_mes, N)
FIN

Script Python complet (Python 3.12 + numpy)

from numpy import array

# ====================================================
# 1. Procédure de saisie de la taille et remplissage
# ====================================================
def Saisir_Lot(T):
    taille = 0
    while taille not in range(5, 51):
        taille = int(input("Donner la taille du lot (5 à 50) : "))
    
    for i in range(taille):
        T[i] = input("Identifiant du flacon N° " + str(i + 1) + " : ")
    return taille

# ====================================================
# 2. Procédure de nettoyage : suppression de '@' initial
# ====================================================
def Nettoyer_Codes(T, N):
    for i in range(N):
        if len(T[i]) > 0 and T[i][0] == "@":
            T[i] = T[i][1:]

# ====================================================
# 3. Procédure d'affichage du rapport élément par élément
# ====================================================
def Afficher_Rapport(T_cod, T_mes, N):
    print("\n=== RAPPORT DE CONTRÔLE DU LABORATOIRE ===")
    print("Flacon\t| Concentration (mg/L)\t| Statut")
    print("-----------------------------------------")
    for i in range(N):
        if 10.0 <= T_mes[i] <= 50.0:
            statut = "CONFORME"
        else:
            statut = "ANOMALIE DOSAGE"
        print(T_cod[i], "\t|", T_mes[i], "\t\t|", statut)

# ====================================================
# PROGRAMME PRINCIPAL
# ====================================================
# Déclaration officielle des tableaux numpy
T_cod = array([''] * 50, dtype='U20')
T_mes = array([float()] * 50)

# 1. Saisie du lot
N = Saisir_Lot(T_cod)

# 2. Nettoyage des flacons
Nettoyer_Codes(T_cod, N)

# 3. Mesures de concentration
for i in range(N):
    T_mes[i] = float(input("Concentration mesurée pour " + T_cod[i] + " (mg/L) : "))

# 4. Rapport d'analyse final
Afficher_Rapport(T_cod, T_mes, N)

Simulateur Interactif de Traitement du Lot (Laboratoire)

Visualisez l'état du tableau T_cod en mémoire, déclenchez la procédure Nettoyer_Codes pour supprimer les caractères @ résiduels avec Effacer, puis générez le rapport d'analyse en direct.

État actuel des cases mémoires du tableau T_cod :

T[{{ idx }}]
{{ item.code }}
{{ item.conc }} mg/L

Rapport Officiel Généré par l'Automate :

Flacon Nettoyé	Concentration (mg/L)	Statut Qualité	Recommandation
{{ item.code }}	{{ item.conc }}	{{ item.conc >= 10 && item.conc <= 50 ? 'CONFORME' : 'ANOMALIE DOSAGE' }}	{{ item.conc >= 10 && item.conc <= 50 ? 'Validé pour archivage' : 'À redoser immédiatement' }}

Auto-évaluation : Maîtrise des Tableaux & Procédures

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

Tirage aléatoire actif : 10 questions ont été sélectionnées au sort parmi une banque de {{ allQuestions.length }} questions.

10 questions actives

Q{{ idx + 1 }}. {{ q.question }}

Explication : {{ q.explanation }}