Cinétique chimique en Python — Rien ne va de soi

Objectif de la fiche : caractériser numériquement la vitesse de disparition d'un colorant lors d'une transformation chimique, tester une loi de vitesse par régression, puis relier le modèle obtenu à une équation différentielle et à un temps de demi-réaction.

Cette fiche est autonome : tu n'as besoin d'aucun autre document, les mesures d'absorbance sont recopiées directement dans le script. 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).

＋

Contexte : suivre une réaction dans le temps

À savoir

La partie « cinétique » du programme cherche à répondre à deux questions : comment mesurer la vitesse de disparition d'une espèce chimique à l'échelle macroscopique, et comment expliquer cette vitesse à l'échelle microscopique, celle des molécules ?
Une vitesse de disparition d'une espèce se définit comme v_d = -dC/dt, l'opposé de la dérivée de sa concentration par rapport au temps — un choix qui évite de manipuler des grandeurs négatives.
L'expérience étudiée ici : un bécher contient 25 mL d'une solution d'érioglaucine (un colorant bleu, E133) à 1,0×10⁻⁵ mol/L. À l'instant t = 0, on y ajoute 1 mL d'eau de Javel diluée (environ 0,4 mol/L en ions hypochlorite) : le colorant se décolore progressivement, une réaction que l'on peut suivre par spectrophotométrie, puisque l'œil détecte directement la perte de couleur.
Le maximum d'absorption du colorant se situe à 630 nm. Une courbe d'étalonnage préalable a permis de déterminer le coefficient d'absorption molaire : ε = 9,8×10⁴ L·mol⁻¹·cm⁻¹. L'absorbance a été mesurée toutes les 20 secondes.

Les données du suivi cinétique

À savoir

Voici un extrait des mesures d'absorbance A réalisées toutes les 20 secondes, sur les 5 premières minutes du suivi.
Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.

etape0_donnees.py

import numpy as np
import matplotlib.pyplot as plt

# Instants de mesure (s) et absorbance correspondante
t = [0, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300]
A = [0.973, 0.930, 0.884, 0.842, 0.803, 0.765, 0.729, 0.693, 0.660,
        0.628, 0.598, 0.570, 0.5429, 0.515, 0.489, 0.462]

Tracer l'absorbance, puis la concentration

Consigne

Trace d'abord A en fonction de t, avec des points ('.'), une grille et les étiquettes 't en min' / 'A'.
La loi de Beer-Lambert, A = ε·l·C (avec l = 1 cm, la longueur de cuve), permet de remonter à la concentration : C = A/ε. Construis la liste C avec une compréhension de liste : [k/9.8E4 for k in A] calcule k/ε pour chaque valeur k de la liste A, sans avoir besoin d'écrire de boucle for classique.
Trace ensuite C en fonction de t.

etape1_beer_lambert.py

plt.figure(1)
# TODO : trace A en fonction de t
plt.plot(_, _, '_')
plt.xlabel('________')
plt.ylabel('_')
plt.grid()
plt.show()

# TODO : convertis A en concentration C, grâce à la loi de Beer-Lambert
C = [_/_____ for k in _]

plt.figure(2)
plt.plot(_, _, '_')
plt.xlabel('________')
plt.ylabel('________________')
plt.grid()
plt.show()

Indice

Une compréhension de liste [expression for variable in liste] est une écriture compacte, équivalente à une boucle for qui construirait une nouvelle liste élément par élément — tu la retrouveras très souvent en Python.

Résultat attendu

Les deux courbes ont la même allure décroissante (normal, C est proportionnelle à A), mais avec des échelles très différentes : C varie entre environ 10⁻⁵ et 5×10⁻⁶ mol/L.

Calculer la vitesse de disparition

Consigne

La vitesse de disparition s'estime, entre deux mesures successives, par un taux de variation : v ≈ -(C[i+1]-C[i]) / (t[i+1]-t[i]).
Construis deux listes vides v et t2, puis remplis-les avec une boucle while : tant que i < len(t)-1, ajoute t[i] à t2 et le taux de variation correspondant à v, avant d'incrémenter i.
Le dernier point de mesure ne permet pas de calculer de taux de variation (il n'y a pas de point suivant) : c'est pour cela que la boucle s'arrête à len(t)-1, et que v et t2 auront une valeur de moins que t et C.

etape2_vitesse.py

v = []
t2 = []
i = 0
while i < len(t) - _ :
    t2.append(t[_])
    v.append(-(C[i+_] - C[_]) / (t[i+_] - t[_]))
    i = i + _

plt.figure(3)
plt.plot(t2, v, '_')
plt.xlabel('____')
plt.ylabel('_______________')
plt.grid()
plt.show()

Résultat attendu

Une courbe qui décroît, comme la concentration elle-même : la vitesse de disparition du colorant n'est pas constante, mais diminue au fil du temps.

Tester une loi de vitesse

Consigne

La vitesse et la concentration décroissent toutes les deux : sont-elles liées ? Pour le savoir, trace v en fonction de la concentration (et non plus du temps).
Comme v a une valeur de moins que C, crée d'abord C1 = C[:-1] (tous les termes de C sauf le dernier), pour que les deux listes se correspondent.

etape3_v_egale_f_C.py

# TODO : concentration redimensionnée pour correspondre à v
C1 = C[:__]

plt.figure(4)
plt.plot(__, _, '_')
plt.xlabel('________________')
plt.ylabel('_______________')
plt.grid()
plt.show()

Résultat attendu

Le nuage de points ressemble, en première approximation, à une droite passant par l'origine : un indice fort en faveur d'une loi de vitesse simple, du type v = k·C (une loi dite « d'ordre 1 »).

Régression et vérification par les résidus

Consigne

Modélise le nuage de points (C1, v) par une droite avec np.polyfit(C1, v, 1). Construis ensuite, avec une compréhension de liste, le tableau des valeurs prédites par ce modèle : Mod1 = [a*k+b for k in C1].
Superpose le modèle aux points mesurés.
Pour préciser la validation, calcule les résidus — l'écart entre chaque point mesuré et le modèle — puis trace-les en fonction de C1. S'ils sont répartis aléatoirement de part et d'autre de zéro, sans motif particulier, le modèle linéaire est validé.

etape4_regression.py

# TODO : régression linéaire de v en fonction de C1
mod = np.polyfit(__, _, _)
a = mod[_]
b = mod[_]
Mod1 = [_*k + _ for k in C1]

plt.figure(5)
plt.plot(C1, v, '_')
plt.plot(C1, Mod1, '__')
plt.xlabel('________________')
plt.ylabel('_______________')
plt.grid()
plt.show()

# TODO : résidus (écarts entre mesures et modèle)
delta_v = [v[i] - Mod1[_] for i in range(len(v))]
plt.figure(6)
plt.plot(C1, delta_v, '_')
plt.grid()
plt.show()

Indice

Comme np.polyfit(..., 1), la variable mod contient deux coefficients : mod[0] la pente, mod[1] l'ordonnée à l'origine — exactement les a et b de l'équation v = a·C + b.

Résultat attendu

La droite de régression passe bien au milieu du nuage de points. Le graphe des résidus ne montre aucune tendance visible (pas de courbe en U, pas de dérive) : les points sont dispersés au hasard autour de zéro. Ce test confirme qu'une loi d'ordre 1 est une modélisation raisonnable de cette transformation.

De la loi de vitesse à l'équation différentielle

À savoir

La régression a validé la loi v = -dC/dt = k·C, avec k = a, la pente trouvée à l'étape 4 (de l'ordre de 2,2×10⁻³ s⁻¹). Cette relation est une équation différentielle : dC/dt + k·C = 0.
On peut vérifier que la fonction C(t) = C0 · e^-k·t est solution de cette équation — un exercice classique de dérivation qui vaut la peine d'être refait à la main.
Ce modèle permet de calculer directement le temps de demi-réaction (le temps au bout duquel la concentration a été divisée par 2) : t_1/2 = ln(2)/k, soit ici environ 3,2×10² s — une valeur cohérente avec l'estimation graphique directe sur la courbe C(t) (de l'ordre de 2,8×10² s).

Conclusion

Ce modèle mathématique permet d'évaluer la concentration du colorant à n'importe quel instant sans avoir à refaire de mesures, à condition de rester dans des conditions comparables (même température, même rapport des concentrations en réactifs). C'est exactement ce type de modèle qu'un industriel pourrait exploiter pour prévoir des durées de décoloration.

＋

Et à l'échelle microscopique ?

Pour la culture

Cette fiche s'est concentrée sur l'échelle macroscopique (des mesures, des courbes, des lois). Le programme de terminale explore aussi l'échelle microscopique : comment expliquer ces vitesses par ce qui se passe entre les molécules ?
Un mécanisme réactionnel décompose une transformation en une succession d'actes élémentaires, faisant parfois intervenir des intermédiaires réactionnels — formés puis consommés, jamais introduits ni observés en fin de réaction — à ne pas confondre avec un catalyseur, introduit par l'expérimentateur et régénéré en fin de mécanisme.
Les flèches courbes utilisées pour représenter un acte élémentaire symbolisent le déplacement d'un doublet d'électrons, jamais celui d'un atome — une confusion fréquente à éviter.
Cette partie du programme, essentiellement conceptuelle, ne fait pas l'objet d'un script Python dans cette fiche : elle est mentionnée ici pour compléter le panorama de la partie cinétique.

Pense-bête — de la mesure au modèle

[f(k) for k in liste]	compréhension de liste (équivaut à une boucle for)
while i < n :	boucle tant que la condition est vraie
liste[:-1]	tous les éléments sauf le dernier

résidus dispersés au hasard	modèle validé
v = k·C	loi de vitesse d'ordre 1
t_1/2 = ln(2)/k	temps de demi-réaction (ordre 1)

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.