Compter en pesant

m_100 = 2.31
m_paquet = 500

m_grain = m_100 / 100
N = m_paquet / m_grain
paquets = N / 1000

print("masse d'un grain :", m_grain, "g")
print("nombre de grains :", round(N))
print("nombre de paquets de 1000 :", round(paquets, 1))

Résultats attendus. Un grain : 0,0231 g. Le paquet contient environ 21 645 grains, soit 21,6 paquets de 1 000.

Interprétation. On a « compté » plus de 20 000 grains avec deux pesées. Le résultat n'est pas exact au grain près (les grains n'ont pas tous la même masse), mais l'ordre de grandeur est fiable. Pour les molécules, on remplace « paquet de 1 000 » par « mole » (\(6{,}02\times10^{23}\)).

Erreurs fréquentes. Multiplier au lieu de diviser (\(500 \times 0{,}0231 = 11{,}6\) grains : absurde pour un paquet de 500 g) ; oublier de diviser m_100 par 100.

elements = ["C", "H", "O"]
masses = [1.99e-26, 1.67e-27, 2.66e-26]
nombres = [6, 12, 6]                       # glucose ; eau : [0, 2, 1] ; saccharose : [12, 22, 11]

m_molecule = 0
for i in range(len(elements)):
    m_molecule = m_molecule + nombres[i] * masses[i]
    print(elements[i], ":", nombres[i], "atome(s)")

print("masse d'une molécule :", m_molecule, "kg")

Résultats attendus. Glucose : \(2{,}99\times10^{-25}\) kg (Python affiche 2.9904e-25). Eau : \(2{,}99\times10^{-26}\) kg. Saccharose : \(5{,}68\times10^{-25}\) kg.

Interprétation. Une molécule de glucose (24 atomes) est 10 fois plus lourde qu'une molécule d'eau (3 atomes). L'écriture e-25 de Python signifie \(\times10^{-25}\).

Erreurs fréquentes. Écrire m_molecule = nombres[i] * masses[i] sans m_molecule + : la variable est écrasée à chaque tour et seul le dernier élément compte ; écrire 1,99e-26 avec une virgule.

import matplotlib.pyplot as plt

NA = 6.02e23
m_eau = 2.99e-26
m_sel = 9.71e-26
m_sucre = 5.68e-25

masses_g = []
n_eau = []
n_sel = []
n_sucre = []
for m in range(0, 101, 10):
    masses_g.append(m)
    n_eau.append(m * 1e-3 / m_eau / NA)
    n_sel.append(m * 1e-3 / m_sel / NA)
    n_sucre.append(m * 1e-3 / m_sucre / NA)

plt.plot(masses_g, n_eau, 'o-', color='blue', label='eau')
plt.plot(masses_g, n_sel, 's-', color='green', label='sel')
plt.plot(masses_g, n_sucre, '^-', color='red', label='sucre')
plt.title("Quantité de matière en fonction de la masse")
plt.xlabel("m (g)")
plt.ylabel("n (mol)")
plt.legend()
plt.grid()
plt.show()

Résultat attendu. Trois droites passant par l'origine. Pour 100 g : 5,6 mol d'eau, 1,7 mol de sel, 0,29 mol de sucre.

Interprétation. \(n\) est proportionnelle à la masse pour une espèce donnée : doubler la masse double le nombre d'entités. La pente dépend de l'espèce : l'eau, dont la molécule est la plus légère, a la droite la plus pentue. La masse seule ne suffit donc pas à comparer des quantités de matière : il faut connaître l'espèce.

Erreurs fréquentes. Oublier * 1e-3 (valeurs 1 000 fois trop grandes) ; utiliser m_eau dans les trois calculs (trois courbes confondues).

NA = 6.02e23
MASSE = {"H": 1.67e-27, "C": 1.99e-26, "O": 2.66e-26, "Na": 3.82e-26,
         "Cl": 5.89e-26, "Fe": 9.27e-26, "Cu": 1.06e-25}

def masse_entite(symboles, nombres):
    m = 0
    for i in range(len(symboles)):
        m = m + nombres[i] * MASSE[symboles[i]]
    return m

def quantite(m_g, symboles, nombres):
    N = m_g * 1e-3 / masse_entite(symboles, nombres)
    n = N / NA
    return N, n

echantillons = [
    ["eau (20 mL)", 20.0, ["H", "O"], [2, 1]],
    ["sucre (1 morceau)", 5.6, ["C", "H", "O"], [12, 22, 11]],
    ["sel (1 cuillère)", 6.0, ["Na", "Cl"], [1, 1]],
    ["clou en fer", 3.0, ["Fe"], [1]],
    ["fil de cuivre", 8.9, ["Cu"], [1]],
]

for e in echantillons:
    N, n = quantite(e[1], e[2], e[3])
    print(e[0], ":", e[1], "g ->", "N =", "{:.2e}".format(N), "; n =", "{:.3g}".format(n), "mol")

Résultats attendus.

Interprétation. 20 mL d'eau contiennent à peu près une mole de molécules. Le morceau de sucre, plus lourd que le clou, contient pourtant moins d'entités : ses molécules sont très lourdes (45 atomes). La notation "{:.2e}".format(N) affiche un nombre en écriture scientifique avec 2 décimales.

Erreurs fréquentes. Oublier la conversion en kg (\(N\) et \(n\) 1 000 fois trop grands : 1 110 mol pour 20 mL d'eau !) ; écrire n = N * NA.

mH = 1.67e-27
mO = 2.66e-26
NA = 6.02e23                 # erreur 2 : point décimal

m_eau = 2 * mH + mO          # erreur 1 : lettre O, pas le chiffre 0
N = 10e-3 / m_eau            # erreur 3 : masse en kg
n = N / NA                   # erreur 4 : on divise par NA
print("n =", n, "mol")

Erreur 1 (bloquante). m0 (avec un zéro) n'existe pas : NameError. La variable s'appelle mO (lettre O).

Erreur 2 (bloquante). NA = 6,02e23 ne crée pas un nombre : la virgule fabrique un couple de deux valeurs (6 et \(2\times10^{23}\)). Python refuse ensuite de le multiplier par N : TypeError.

Erreur 3 (silencieuse). 10 est en grammes alors que m_eau est en kg : \(N\) est 1 000 fois trop grand.

Erreur 4 (silencieuse). \(n = N \times N_A\) au lieu de \(N/N_A\).

Résultat après correction. \(n \approx 0{,}555\ \text{mol}\). Avec seulement les erreurs 1 et 2 corrigées, le programme affichait environ \(2\times10^{50}\) mol ; avec l'erreur 4 corrigée mais pas la 3, 555 mol. Les deux sont absurdes pour 10 g d'eau.