Poids, masse et gravitation

g = 9.81
m_g = 250

m_kg = m_g / 1000          # 250 g = 0,250 kg
P = m_kg * g

g_lune = 1.62
P_lune = m_kg * g_lune

print("Masse :", m_kg, "kg")
print("Poids prévu sur Terre :", round(P, 2), "N")
print("Poids sur la Lune :", round(P_lune, 2), "N")

Résultats attendus. Avant correction : une masse de 250 000 kg et un poids de 2 452 500 N, absurdes pour un petit objet. Après correction : 0,25 kg, 2,45 N sur Terre, 0,41 N sur la Lune.

Interprétation. 2,45 N est cohérent avec la mesure au dynamomètre (2,44 N). Sur la Lune, la même masse « pèserait » 6 fois moins.

Erreurs fréquentes. Multiplier par 1 000 au lieu de diviser ; garder les grammes dans \(P = m\,g\) (le résultat serait 1 000 fois trop grand).

m_g = [50, 100, 150, 200, 250, 300]
P = [0.48, 0.99, 1.46, 1.97, 2.44, 2.95]

rapports = []
for i in range(len(m_g)):
    m_kg = m_g[i] / 1000
    r = P[i] / m_kg
    rapports.append(r)
    print("m =", m_kg, "kg   P =", P[i], "N   P/m =", round(r, 2), "N/kg")

g_exp = sum(rapports) / len(rapports)
ecart = abs(g_exp - 9.81) / 9.81 * 100
print("g expérimental :", round(g_exp, 2), "N/kg")
print("écart relatif :", round(ecart, 1), "%")

Résultats attendus. Rapports : 9,6 ; 9,9 ; 9,73 ; 9,85 ; 9,76 ; 9,83 N/kg. Moyenne : 9,78 N/kg. Écart relatif : 0,3 %.

Interprétation. Le rapport \(P/m\) est à peu près constant : le poids est proportionnel à la masse, et le coefficient de proportionnalité est \(g\). L'écart de 0,3 % est faible : la mesure est en accord avec la valeur de référence. Le premier rapport (9,6) est le plus éloigné : pour une petite masse, une erreur de lecture de 0,01 N pèse davantage en proportion.

Erreurs fréquentes. Diviser par la masse en grammes (rapports 1 000 fois trop petits) ; faire la moyenne des poids au lieu de la moyenne des rapports.

import matplotlib.pyplot as plt

m_g = [0, 50, 100, 150, 200, 250, 300]
P = [0, 0.48, 0.99, 1.46, 1.97, 2.44, 2.95]

m_kg = []
P_modele = []
for i in range(len(m_g)):
    m_kg.append(m_g[i] / 1000)
    P_modele.append(9.81 * m_kg[i])

plt.plot(m_kg, P, 'o', color='red', label='mesures')
plt.plot(m_kg, P_modele, '-', color='navy', label='modèle P = 9,81 m')
plt.title("Poids en fonction de la masse")
plt.xlabel("m (kg)")
plt.ylabel("P (N)")
plt.legend()
plt.grid()
plt.show()

Résultat attendu. Les points rouges sont presque exactement sur la droite bleue, qui passe par l'origine et atteint 2,94 N pour 0,300 kg.

Interprétation. Les mesures sont alignées sur une droite passant par l'origine : le poids est proportionnel à la masse. Le modèle \(P = m\,g\) décrit bien l'expérience. Le point (0 ; 0) a été ajouté car une masse nulle a un poids nul.

Erreurs fréquentes. Tracer le modèle avec 'o' (des points au lieu d'une droite) ; oublier plt.legend() (les étiquettes label ne s'affichent pas).

import matplotlib.pyplot as plt
G = 6.67e-11

astres = ["Mercure", "Vénus", "Terre", "Mars", "Jupiter", "Lune"]
M = [3.30e23, 4.87e24, 5.97e24, 6.42e23, 1.90e27, 7.35e22]
R = [2.44e6, 6.05e6, 6.37e6, 3.39e6, 7.15e7, 1.74e6]

for i in range(len(astres)):
    g = G * M[i] / R[i]**2
    print(astres[i], ": g =", round(g, 2), "N/kg")

mT = 5.97e24
RT = 6.37e6
h_km = []
g_h = []
for h in range(0, 36001, 100):
    d = RT + h * 1000                # altitude convertie en mètres
    h_km.append(h)
    g_h.append(G * mT / d**2)
    if h == 0 or h == 400 or h == 35800:
        print("altitude", h, "km : g =", round(G * mT / d**2, 2), "N/kg")

plt.plot(h_km, g_h, '-', color='navy')
plt.title("Intensité de la pesanteur terrestre en fonction de l'altitude")
plt.xlabel("altitude h (km)")
plt.ylabel("g (N/kg)")
plt.grid()
plt.show()

Résultats attendus. Mercure 3,7 ; Vénus 8,87 ; Terre 9,81 ; Mars 3,73 ; Jupiter 24,79 ; Lune 1,62 N/kg. En altitude : 9,81 N/kg au sol ; 8,69 N/kg à 400 km ; 0,22 N/kg à 35 800 km.

Interprétation. Jupiter, très massive, a le \(g\) le plus fort malgré son grand rayon. Autour de la Terre, \(g\) diminue avec l'altitude mais ne s'annule jamais : à 400 km (ISS), il vaut encore 89 % de sa valeur au sol ; à l'altitude des satellites géostationnaires, il n'en reste que 2 %. Les satellites restent soumis à l'attraction terrestre : c'est elle qui les maintient en orbite.

Erreurs fréquentes. Écrire d = h (oublier le rayon de la Terre) ou d = RT + h (oublier la conversion km → m : \(h\) serait négligeable et \(g\) ne varierait presque pas).

G = 6.67e-11         # erreur 3 : exposant négatif
mT = 5.97e24
RT = 6.37e6          # erreur 4 : distances en mètres
h = 400e3

d = RT + h
g = G * mT / d**2    # erreur 2 : la puissance s'écrit **
print("g à l'altitude de l'ISS :", round(g, 2), "N/kg")   # erreur 1 : parenthèse fermée

Erreur 1 (bloquante). La parenthèse du print n'est pas fermée : erreur d'écriture.

Erreur 2 (bloquante). ^ n'est pas la puissance en Python (c'est une opération sur les nombres entiers écrits en binaire) : Python refuse de l'appliquer à un nombre décimal. Le carré s'écrit d**2.

Erreur 3 (silencieuse). 6.67e11 vaut \(6{,}67\times10^{11}\), et non \(6{,}67\times10^{-11}\) : le résultat est \(10^{22}\) fois trop grand.

Erreur 4 (silencieuse). Avec des distances en km, \(d^2\) est \(10^{6}\) fois trop petit, donc \(g\) est \(10^{6}\) fois trop grand.

Résultat après correction. \(g = 8{,}69\ \text{N}\cdot\text{kg}^{-1}\). Avec seulement les erreurs 1 et 2 corrigées, le programme affichait environ \(8{,}7\times10^{28}\ \text{N}\cdot\text{kg}^{-1}\) : une valeur absurde, repérable immédiatement par comparaison avec 9,81.