Vinaigre, bicarbonate et réactif limitant

M_bic = 84.0
M_CO2 = 44.0
M_acide = 60.0

m_bic = 1.0
m_CO2 = 0.50
m_acide = 1.60

n_bic = m_bic / M_bic
n_CO2 = m_CO2 / M_CO2
n_acide = m_acide / M_acide

print("n_bic   =", round(n_bic, 4), "mol")
print("n_CO2   =", round(n_CO2, 4), "mol")
print("n_acide =", round(n_acide, 4), "mol")

Résultats attendus. \(n_{\text{bic}} = 0{,}0119\ \text{mol}\), \(n_{\text{CO}_2} = 0{,}0114\ \text{mol}\), \(n_{\text{acide}} = 0{,}0267\ \text{mol}\).

Interprétation. \(n_{\text{bic}} < n_{\text{acide}}\) : avec des coefficients égaux à 1, le bicarbonate est limitant. L'équation prévoit alors \(n_{\text{CO}_2} = n_{\text{bic}}\) : on trouve 0,0114 au lieu de 0,0119, soit 5 % de moins (CO₂ resté dissous).

Erreurs fréquentes. Multiplier par \(M\) au lieu de diviser (valeurs de l'ordre de 80 mol : absurde pour 1 g).

m_bic = [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5]
m_CO2 = [0.25, 0.50, 0.74, 0.99, 1.11, 1.12, 1.10]
n_acide = 1.60 / 60.0

for i in range(len(m_bic)):
    n_bic = m_bic[i] / 84.0
    n_CO2 = m_CO2[i] / 44.0
    if n_bic < n_acide:
        limitant = "bicarbonate"
        n_prevu = n_bic
    else:
        limitant = "acide"
        n_prevu = n_acide
    print(m_bic[i], "g | limitant :", limitant, "| CO2 prévu :", round(n_prevu, 4), "mol | mesuré :", round(n_CO2, 4), "mol")

Résultats attendus. Bicarbonate limitant pour 0,5 à 2,0 g ; acide limitant pour 2,5 à 3,5 g. CO₂ prévu : 0,006 ; 0,0119 ; 0,0179 ; 0,0238 ; puis 0,0267 mol. Mesures : environ 5 % de moins.

Interprétation. Tant que le bicarbonate est limitant, chaque ajout produit plus de CO₂. Dès que l'acide devient limitant, ajouter du bicarbonate ne sert plus à rien : il reste au fond du bécher, et la quantité de CO₂ plafonne.

Erreurs fréquentes. Comparer les masses (1,60 g d'acide et 2,0 g de bicarbonate) au lieu des quantités de matière : on se tromperait de réactif limitant pour l'essai à 2,0 g.

import matplotlib.pyplot as plt

m_bic = [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5]
m_CO2 = [0.25, 0.50, 0.74, 0.99, 1.11, 1.12, 1.10]
n_acide = 1.60 / 60.0

n_bic = []
n_CO2 = []
for i in range(len(m_bic)):
    n_bic.append(m_bic[i] / 84.0)
    n_CO2.append(m_CO2[i] / 44.0)

x_mod = []
y_mod = []
for k in range(0, 46):
    x = k * 0.001
    x_mod.append(x)
    y_mod.append(min(x, n_acide))

plt.plot(n_bic, n_CO2, 'o', color='red', label='mesures')
plt.plot(x_mod, y_mod, '-', color='navy', label='modèle (équation)')
plt.title("CO2 dégagé en fonction du bicarbonate ajouté")
plt.xlabel("n bicarbonate (mol)")
plt.ylabel("n CO2 (mol)")
plt.legend()
plt.grid()
plt.show()

Résultat attendu. Le modèle est une droite de pente 1 jusqu'à 0,0267 mol, puis un plateau. Les points de mesure suivent la même forme, un peu en dessous (environ 5 %).

Interprétation. La pente 1 de la première partie traduit les coefficients 1 : 1 de l'équation (une mole de bicarbonate donne une mole de CO₂). La cassure, vers 0,027 mol de bicarbonate, marque les proportions stœchiométriques ; sa hauteur donne la quantité d'acide du vinaigre. On pourrait ainsi doser l'acide d'un vinaigre inconnu.

Erreurs fréquentes. Utiliser max au lieu de min (le modèle monterait indéfiniment au lieu de plafonner).

def limitant(nA, a, nB, b):
    qA = nA / a
    qB = nB / b
    if qA < qB:
        return "A", qA
    elif qB < qA:
        return "B", qB
    else:
        return "aucun (proportions stœchiométriques)", qA

reactions = [
    ["CH4 + 2 O2",      0.20, 1, 0.30, 2],
    ["C3H8 + 5 O2",     0.50, 1, 2.0, 5],
    ["Cu2+ + 2 HO-",    2.0e-3, 1, 3.0e-3, 2],
    ["2 H2 + O2",       4.0, 2, 2.0, 1],
]

for r in reactions:
    nom, nA, a, nB, b = r
    lim, x = limitant(nA, a, nB, b)
    reste_A = nA - a * x
    reste_B = nB - b * x
    print(nom, "| limitant :", lim, "| reste A :", round(reste_A, 5), "mol | reste B :", round(reste_B, 5), "mol")

Résultats attendus. Méthane : B (O₂) limitant, reste 0,05 mol de CH₄. Propane : B (O₂), reste 0,1 mol de C₃H₈. Cuivre : B (HO⁻), reste 0,0005 mol de Cu²⁺. Dihydrogène : aucun, proportions stœchiométriques, rien ne reste.

Interprétation. On retrouve les résultats du cours et des exercices 6 et 7. Le réactif limitant a toujours un reste nul ; le quotient \(x\) mesure « combien de fois » la réaction a eu lieu, en moles.

Erreurs fréquentes. Écrire reste_A = nA - x en oubliant le coefficient : faux dès que \(a \neq 1\) (pour 2 H₂ + O₂, il resterait 2 mol de H₂).

M_CO2 = 44.0                     # erreur 2 : variable manquante
n_bic = 3.0 / 84.0               # erreur 3 : n = m / M
n_acide = 1.60 / 60.0

if n_bic < n_acide:              # erreurs 1 (deux-points) et 4 (sens de la comparaison)
    n_CO2 = n_bic
else:
    n_CO2 = n_acide
m_CO2 = n_CO2 * M_CO2
print("masse de CO2 attendue :", round(m_CO2, 2), "g")

Erreur 1 (bloquante). Il manque les deux-points à la fin de la ligne if : erreur de syntaxe.

Erreur 2 (bloquante). M_CO2 n'a jamais été défini : NameError.

Erreur 3 (silencieuse). 3.0 * 84.0 donne 252 « mol » : il faut diviser la masse par la masse d'une mole.

Erreur 4 (silencieuse). La condition choisit la plus grande quantité : c'est le réactif en excès, pas le limitant. Avec les erreurs 1 à 3 corrigées, on obtiendrait 1,57 g, plus que le plateau mesuré.

Résultat après correction. 1,17 g, la valeur du plateau prévue par l'équation (acide limitant).