Modèles moléculaires et schémas de Lewis

nom = "oxygène"
v = 6

liaisons = 8 - v
non_liants = (v - liaisons) // 2
total = 2 * (liaisons + non_liants)

print(nom, ":", v, "électrons de valence")
print("liaisons :", liaisons)
print("doublets non liants :", non_liants)
print("électrons autour :", total)

Résultats attendus. Oxygène : 2 liaisons, 2 doublets non liants. Azote : 3 et 1. Carbone : 4 et 0. Chlore : 1 et 3. Le total vaut 8 à chaque fois.

Interprétation. Le programme retrouve la règle de l'octet : quel que soit l'atome, liaisons et doublets non liants l'entourent de 8 électrons. Ce sont aussi les nombres de trous des boules du modèle moléculaire.

Erreurs fréquentes. Oublier de diviser par 2 (on compterait des électrons au lieu de doublets) ; utiliser / qui donne 2.0 au lieu de 2 (le résultat reste juste, mais il s'affiche avec une virgule).

symboles = ["H", "C", "N", "O", "F", "Cl"]
valences = [1, 4, 5, 6, 7, 7]

for i in range(len(symboles)):
    v = valences[i]
    if symboles[i] == "H":
        liaisons = 2 - v        # duet
    else:
        liaisons = 8 - v        # octet
    non_liants = (v - liaisons) // 2
    print(symboles[i], ": v =", v, "| liaisons :", liaisons, "| doublets non liants :", non_liants)

Résultats attendus. Avant correction, H a 7 liaisons et −3 doublets non liants : absurde. Après correction : H 1 et 0 ; C 4 et 0 ; N 3 et 1 ; O 2 et 2 ; F 1 et 3 ; Cl 1 et 3.

Interprétation. F et Cl ont le même résultat : ils sont dans la même colonne du tableau périodique (7 électrons de valence). Quand le nombre de liaisons diminue, le nombre de doublets non liants augmente.

Erreurs fréquentes. Écrire symboles[i] = "H" (un seul = sert à affecter, la comparaison s'écrit ==) ; oublier les deux-points après if et else.

import matplotlib.pyplot as plt

doublets = [1, 2, 3]
E_C = [3.61, 6.36, 8.70]
E_N = [1.69, 4.33, 9.79]

plt.plot(doublets, E_C, 'o-', color='black', label='carbone')
plt.plot(doublets, E_N, 's-', color='blue', label='azote')
plt.title("Énergie de liaison selon le nombre de doublets liants")
plt.xlabel("nombre de doublets liants")
plt.ylabel("énergie de liaison (eV)")
plt.legend()
plt.grid()
plt.show()

rapport_C = E_C[2] / E_C[0]
rapport_N = E_N[2] / E_N[0]
print("C : triple / simple =", round(rapport_C, 1))
print("N : triple / simple =", round(rapport_N, 1))

Résultats attendus. Deux courbes croissantes. Rapports : 2,4 pour le carbone, 5,8 pour l'azote.

Interprétation. Plus il y a de doublets liants entre deux atomes, plus la liaison est solide. Mais l'énergie n'est pas proportionnelle au nombre de doublets : pour le carbone, la triple vaut moins de 3 simples (2,4) ; pour l'azote, elle en vaut presque 6. Cela explique la grande stabilité du diazote \(\text{N}_2\), qui forme 78 % de l'air et réagit très peu.

Erreurs fréquentes. Confondre E_N[0] (premier élément) et E_N[1] (deuxième) ; oublier plt.legend().

symboles = ["H", "He", "Li", "Be", "B", "C", "N", "O", "F",
            "Ne", "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar"]

def valence(Z):
    sous_couches = [(1, 2), (2, 2), (2, 6), (3, 2), (3, 6)]
    reste = Z
    n_max = 1
    v = 0
    for n, capacite in sous_couches:
        if reste == 0:
            break
        e = min(reste, capacite)
        reste = reste - e
        if n > n_max:
            n_max = n
            v = 0
        v = v + e
    return v

def charge(Z):
    v = valence(Z)
    if Z == 2 or Z == 10 or Z == 18:
        return 0
    if v <= 3:
        return v               # perd v électrons
    if v >= 5:
        return -(8 - v)        # gagne 8 - v électrons
    return None

def ecrire_ion(symbole, q):
    if q is None:
        return "pas d'ion courant"
    if q == 0:
        return "pas d'ion (gaz noble)"
    signe = "+" if q > 0 else "-"
    nombre = "" if abs(q) == 1 else str(abs(q))
    return symbole + nombre + signe

for Z in range(1, 19):
    s = symboles[Z - 1]
    print("Z =", Z, "|", s, "| v =", valence(Z), "|", ecrire_ion(s, charge(Z)))

Résultats attendus. H+, Li+, Be2+, B3+, N3-, O2-, F-, Na+, Mg2+, Al3+, P3-, S2-, Cl- ; « pas d'ion courant » pour C et Si ; « pas d'ion (gaz noble) » pour He, Ne et Ar. (Le programme écrit les charges sur la ligne, par exemple Mg2+ pour \(\text{Mg}^{2+}\).)

Interprétation. Les éléments d'une même colonne donnent des ions de même charge : Li⁺ et Na⁺, O²⁻ et S²⁻, F⁻ et Cl⁻. Le programme retrouve tous les ions du cours. Mais un modèle a des limites : le bore, par exemple, ne forme pas d'ion B³⁺ dans ses composés courants ; il forme des liaisons covalentes. Une prévision doit toujours être confrontée à l'expérience.

Erreurs fréquentes. Écrire return 8 - v (charge positive pour un atome qui gagne des électrons) ; placer le test des gaz nobles après le test v <= 3 : l'hélium, avec v = 2, deviendrait He²⁺.

atomes = ["H", "C", "N", "O"]
valences = [1, 4, 5, 6]

for i in range(len(atomes)):
    v = valences[i]
    if atomes[i] == "H":
        liaisons = 2 - v                  # erreur 3 : H suit la règle du duet
    else:
        liaisons = 8 - v
    non_liants = (v - liaisons) // 2      # erreur 4 : on compte des paires
    total = 2 * (liaisons + non_liants)
    print(atomes[i], ":", liaisons, "liaison(s),", non_liants, "doublet(s) non liant(s), total", total, "électrons")
    # erreurs 1 et 2 : guillemet refermé, nom de variable corrigé

Erreur 1 (bloquante). Le dernier texte "électrons) n'a pas de guillemet fermant : erreur d'écriture, Python ne lance même pas le programme.

Erreur 2 (bloquante). La variable s'appelle non_liants mais le print utilise non_liant : Python ne connaît pas ce nom.

Erreur 3 (silencieuse). Pour H, \(8 - 1 = 7\) liaisons : impossible, l'hydrogène n'en forme qu'une (duet).

Erreur 4 (silencieuse). v - liaisons compte des électrons, pas des doublets. Avant correction, O affiche 4 doublets non liants et 12 électrons autour de lui, au lieu de 2 et 8.

Résultat après correction. H : 1 liaison, 0 doublet non liant, 2 électrons ; C : 4, 0, 8 ; N : 3, 1, 8 ; O : 2, 2, 8.