Physique-chimie · 1re · Enseignement de spécialité · Fiche n°1

Trouver le réactif
qui manque le premier.

Dans une transformation chimique, un des réactifs finit toujours par s'épuiser avant l'autre : c'est le réactif limitant. Plutôt que de le calculer à la main, tu vas écrire un script Python qui le détermine tout seul, en augmentant petit à petit l'avancement de la réaction jusqu'à ce qu'un réactif vienne à manquer — l'occasion de découvrir la boucle while.

reactif_limitant.py — aperçux = 0.000 mol
I₂ S₂O₃²⁻

Objectif de la fiche : déterminer la composition de l'état final d'un système siège d'une transformation chimique totale — c'est-à-dire l'avancement maximal et le réactif limitant — à l'aide du langage Python.

Cette fiche est autonome : tu n'as besoin d'aucun autre document. Elle ne demande ni numpy ni matplotlib : tout se joue avec des listes, une boucle while, et à la fin, une fonction. Chaque étape contient un script incomplet à compléter, puis à copier-coller dans Thonny (ou dans la console Basthon tout en bas de la page si tu n'as pas Thonny sous la main).

00

La réaction étudiée

À savoir
  • Dans une transformation chimique totale, les réactifs sont consommés jusqu'à ce que l'un d'eux disparaisse complètement : c'est le réactif limitant. Il arrête la réaction, même s'il reste de l'autre réactif en excès.
  • Cette fiche s'appuie sur la réaction entre le diiode et les ions thiosulfate en solution aqueuse : I₂(aq) + 2 S₂O₃²⁻(aq) = 2 I⁻(aq) + S₄O₆²⁻(aq).
  • L'objectif : écrire un script qui augmente progressivement l'avancement x de la réaction, tant que les deux réactifs sont encore présents, jusqu'à ce que l'un des deux s'épuise.
01

Saisir les quantités initiales

Consigne
  • La fonction input('un message') affiche le message donné et attend que l'utilisateur tape une réponse au clavier. Cette réponse est toujours renvoyée sous forme de texte (une chaîne de caractères), même si l'utilisateur a tapé un nombre.
  • La fonction float(...) convertit ce texte en nombre décimal, seul format utilisable pour la suite des calculs.
  • Demande à l'utilisateur la quantité initiale de diiode (stocke le texte dans I2_0, puis convertis-le dans nI2_0), puis fais de même pour le thiosulfate (S2O3_0 puis nS2O3_0).
etape1_saisie.py
# TODO : demande et convertis la quantité initiale de diiode
I2_0 = input('____________________________')
nI2_0 = _____(I2_0)

# TODO : demande et convertis la quantité initiale de thiosulfate
S2O3_0 = input('_______________________________')
nS2O3_0 = _____(S2O3_0)
Indice

Le message passé à input peut être n'importe quel texte informatif, par exemple 'quantité initiale en diiode en mol :' — c'est ce texte qui s'affichera à l'utilisateur au moment de la saisie.

Résultat attendu

À l'exécution, la console attend que tu tapes une valeur (par exemple 2) puis appuie sur Entrée, deux fois de suite — une fois pour le diiode, une fois pour le thiosulfate.

02

Initialiser l'avancement et les listes

Consigne
  • Initialise l'avancement x à 0, et choisis un petit incrément d'avancement a = 0.001 mol : à chaque tour de boucle, x augmentera de cette petite valeur.
  • Crée une variable limitant, une chaîne de caractères vide (''), qui accueillera plus tard le nom du réactif limitant.
  • Crée deux listes, qI2 et qS2O3, contenant chacune une seule valeur pour l'instant : la quantité de matière initiale du réactif correspondant.
etape2_initialisation.py
limitant = __  # initialisation de la chaîne de caractère correspondant au réactif limitant
x = _       # avancement initial
a = _____   # pas d'avancement
qI2 = [______]
qS2O3 = [________]
Résultat attendu

Cette étape ne produit aucun affichage : elle prépare simplement les variables et les listes qui vont être utilisées et complétées dans la boucle while de l'étape suivante.

03

La boucle while

Consigne
  • Contrairement à une boucle for, une boucle while ne connaît pas à l'avance le nombre de tours qu'elle va effectuer : elle continue tant qu'une condition reste vraie. C'est exactement ce qu'il faut ici, puisqu'on ne sait pas à l'avance combien de petits pas d'avancement seront nécessaires avant qu'un réactif s'épuise.
  • La condition d'arrêt : continuer tant que la dernière valeur de qI2 ET la dernière valeur de qS2O3 sont strictement positives. La dernière valeur d'une liste liste s'obtient avec liste[-1].
  • À chaque tour : augmente x de a, puis ajoute à qI2 la nouvelle quantité de diiode restante (nI2_0 - x, car le coefficient stœchiométrique du diiode vaut 1) avec .append(...), et de même pour qS2O3 (nS2O3_0 - 2*x, car le coefficient du thiosulfate vaut 2).
etape3_boucle_while.py
while qI2[__]>0 and qS2O3[__]>0 :
    x = x + _
    qI2.append(________)
    qS2O3.append(___________)
Indice

liste[-1] revient exactement au même que dans les fiches précédentes : l'indice -1 désigne toujours le dernier élément d'une liste, quelle que soit sa longueur — pratique ici, puisque la liste grandit à chaque tour de boucle.

Résultat attendu

Aucun affichage immédiat, mais la boucle tourne en coulisses : avec nI2_0 = 2 et nS2O3_0 = 3, elle s'arrête d'elle-même une fois que qS2O3 atteint 0, après 1500 petits pas de 0,001 mol.

04

Identifier le réactif limitant et conclure

Consigne
  • Une fois la boucle terminée, l'un des deux réactifs (au moins) a une dernière quantité négative ou nulle : c'est lui qui a arrêté la réaction. Teste qI2[-1]<=0 : si c'est vrai, affecte la chaîne 'diiode' à limitant. Fais de même pour qS2O3[-1]<=0 avec 'thiosulfate'.
  • Affiche enfin le résultat avec print, en arrondissant l'avancement à 2 chiffres avec round(x, 2).
etape4_resultat.py
if qI2[-1]<=0 :
    limitant = '________'
if qS2O3[-1]<=0 :
    limitant = '____________'

print('Le réactif limitant est le ', ________, '\n Avancement maximum : ', round(_, _), 'mol')
Résultat attendu

Avec les valeurs saisies à l'étape 1 égales à 2 (diiode) et 3 (thiosulfate), la console affiche : Le réactif limitant est le thiosulfate et Avancement maximum : 1.5 mol. Essaie avec d'autres valeurs initiales : le réactif limitant n'est pas forcément celui introduit en plus faible quantité, à cause des nombres stœchiométriques différents (1 pour le diiode, 2 pour le thiosulfate).

05

Généraliser avec une fonction

Consigne
  • Le script précédent ne fonctionne que pour une réaction précise. Pour le rendre réutilisable avec n'importe quelle réaction aA A + aB B = aC C + aD D, transforme-le en fonction.
  • Une fonction Python débute par def nom_fonction(arguments) : et se termine par return(...), qui renvoie le ou les résultats calculés à l'intérieur.
  • Définis react_lim(aA, aB, nA, nB), qui reprend exactement la même logique que les étapes précédentes (avec des noms génériques A et B à la place de diiode et thiosulfate), et renvoie un couple : la liste RL des réactifs limitants ('A' et/ou 'B'), et l'avancement maximal arrondi.
etape5_fonction.py
def react_lim(aA, aB, nA, nB) :
    x = 0                # Initialisation de l'avancement
    dx = 0.00001          # Incrément d'avancement
    qA = [__]            # Liste stockant les quantités de matière successives de A
    qB = [__]            # Idem pour B
    RL = []               # Liste qui stockera le nom du réactif limitant
    while qA[__]>0 and qB[__]>0 :
        x = x + dx
        qA.append(nA - __*x)
        qB.append(nB - __*x)
    if qA[-1]<=0 :
        RL.append('_')
    if qB[-1]<=0 :
        RL.append('_')
    return(__, round(_, 2))

react_lim(5, 2, 2, 3)
Indice

À l'intérieur de la fonction, les noms aA, aB, nA, nB jouent exactement le même rôle que les coefficients stœchiométriques et les quantités initiales des étapes précédentes — seuls les noms changent, la logique de la boucle while reste identique.

Résultat attendu

react_lim(5, 2, 2, 3) modélise une réaction « 5 A pour 2 B », avec 2 mol de A et 3 mol de B initialement. La fonction renvoie (['A'], 0.4) : le réactif limitant est A, et l'avancement maximal vaut 0,4 mol. Essaie d'appeler la fonction avec d'autres valeurs pour t'entraîner à l'interpréter.

Pense-bête — boucle while et fonctions

while condition :répète tant que la condition est vraie
liste[-1]dernier élément d'une liste
liste.append(v)ajoute v à la fin de la liste
def f(args) :débute la définition d'une fonction
return(...)renvoie le résultat et termine la fonction
float(input(...))lit et convertit une saisie clavier

Pas de Thonny sous la main ? Utilise Basthon

Ouvrir dans un nouvel onglet ↗
Basthon est une console Python qui tourne directement dans le navigateur, sans rien installer. Colle ici (avec Ctrl+V ou Cmd+V) le code copié avec les boutons « Copier le code » ci-dessus, puis appuie sur Entrée pour l'exécuter.