Banc d'optique et lentille convergente

AB = 2.0
OA = -30.0
OA_ = 15.1
AB_ = -1.0

g_tailles = AB_ / AB
g_positions = OA_ / OA

print("grandissement (tailles)   :", round(g_tailles, 3))
print("grandissement (positions) :", round(g_positions, 3))
if g_tailles < 0:
    print("image renversée")
else:
    print("image droite")

Résultats attendus. \(-0{,}5\) avec les tailles, \(-0{,}503\) avec les positions ; image renversée.

Interprétation. Les deux calculs concordent : c'est le théorème de Thalès appliqué aux triangles \(OAB\) et \(OA'B'\). Le signe négatif traduit le renversement de l'image réelle.

Erreurs fréquentes. Écrire OA = 30 sans le signe moins : on obtiendrait \(+0{,}5\) avec les positions, en contradiction avec les tailles.

AB = 2.0
OA = [-15, -20, -25, -30, -40, -50, -60]
OA_ = [30.4, 19.8, 16.8, 15.1, 13.2, 12.6, 11.9]
AB_ = [-4.1, -2.0, -1.3, -1.0, -0.7, -0.5, -0.4]

for i in range(len(OA)):
    g1 = AB_[i] / AB
    g2 = OA_[i] / OA[i]
    if abs(g2) > 1:
        taille = "agrandie"
    else:
        taille = "réduite"
    print("OA =", OA[i], "| gamma (tailles) =", round(g1, 2), "| gamma (positions) =", round(g2, 2), "|", taille)

Résultats attendus. \(\gamma\) passe de −2,03 (objet à 15 cm, image agrandie) à −0,99 (20 cm, même taille), puis à −0,2 (60 cm, réduite). Les deux calculs diffèrent au plus de 0,02.

Interprétation. Plus l'objet est proche du foyer, plus l'image est grande et lointaine. À 20 cm (c'est-à-dire \(2f'\)), l'image est de même taille que l'objet et aussi à 20 cm : on retrouve l'exercice 10. Les petits écarts entre les deux calculs viennent de la précision de lecture des tailles (au millimètre).

Erreurs fréquentes. Tester g2 > 1 sans valeur absolue : toutes les images (renversées, \(\gamma < 0\)) seraient déclarées « réduites ».

import matplotlib.pyplot as plt

AB = 2.0
OA = [-15, -20, -25, -30, -40, -50, -60]
OA_ = [30.4, 19.8, 16.8, 15.1, 13.2, 12.6, 11.9]
AB_ = [-4.1, -2.0, -1.3, -1.0, -0.7, -0.5, -0.4]

g_pos = []
g_tai = []
for i in range(len(OA)):
    g_pos.append(OA_[i] / OA[i])
    g_tai.append(AB_[i] / AB)

plt.plot(g_pos, g_tai, 'o', color='red', label='mesures')
plt.plot([-2.2, 0], [-2.2, 0], '-', color='navy', label='y = x')
plt.title("Deux façons de calculer le grandissement")
plt.xlabel("gamma calculé avec OA' / OA")
plt.ylabel("gamma calculé avec A'B' / AB")
plt.legend()
plt.grid()
plt.show()

Résultat attendu. Les sept points sont pratiquement sur la droite \(y = x\), de −2 à −0,2.

Interprétation. Les deux méthodes donnent le même grandissement, aux incertitudes de mesure près : la relation \(\gamma = \overline{A'B'}/\overline{AB} = \overline{OA'}/\overline{OA}\) est vérifiée expérimentalement. Le point le plus éloigné de la droite est celui de l'objet à 25 cm (−0,65 contre −0,67) : la taille de l'image (1,3 cm) n'est lue qu'au millimètre près.

Erreurs fréquentes. Inverser les deux listes : le graphique reste correct (la droite \(y = x\) est symétrique), mais les axes seraient mal nommés.

def image(OA, f, AB):
    x = 1 / (1 / OA + 1 / f)
    y = AB / OA * x
    return x, y

f = 10.0
AB = 2.0
OA = [-15, -20, -25, -30, -40, -50, -60]
OA_mes = [30.4, 19.8, 16.8, 15.1, 13.2, 12.6, 11.9]

for i in range(len(OA)):
    x, y = image(OA[i], f, AB)
    print("OA =", OA[i], "cm -> OA' prévu =", round(x, 1), "cm (mesuré", OA_mes[i], ") ; A'B' prévu =", round(y, 2), "cm")

Résultats attendus. \(\overline{OA'}\) prévus : 30,0 ; 20,0 ; 16,7 ; 15,0 ; 13,3 ; 12,5 ; 12,0 cm, à moins de 0,4 cm des mesures. Tailles prévues : −4,0 ; −2,0 ; −1,33 ; −1,0 ; −0,67 ; −0,5 ; −0,4 cm.

Interprétation. La construction géométrique avec deux rayons particuliers prévoit correctement la position et la taille de l'image. La relation obtenue pour \(x\) s'appelle la relation de conjugaison ; elle sera étudiée en Première. Les écarts restants viennent de la difficulté à juger de la netteté de l'image (quelques millimètres).

Erreurs fréquentes. Écrire 1 / 1 / OA + 1 / f sans parenthèses : Python calcule alors \((1/1)/\overline{OA} + 1/f'\), un résultat sans rapport.

f = 10.0
OA = -40.0                       # erreur 3 : objet avant la lentille, OA négatif
OA_ = 1 / (1 / OA + 1 / f)
gamma = OA_ / OA                 # erreur 4 : gamma = OA' / OA
if OA_ > 0:
    nature = "réelle"
else:
    nature = "virtuelle"
print("gamma =", round(gamma, 2), "| image", nature)   # erreurs 1 et 2

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

Erreur 2 (bloquante). gama n'existe pas : NameError.

Erreur 3 (silencieuse). Avec \(\overline{OA} = +40\), le programme décrit un objet placé après la lentille : \(\overline{OA'} = 8\ \text{cm}\), un résultat sans lien avec l'expérience.

Erreur 4 (silencieuse). Le rapport est inversé : on calcule \(1/\gamma\). Avec les erreurs 1 à 3 corrigées, le programme afficherait −3,0 (image trois fois plus grande), au lieu de −0,33.

Résultat après correction. \(\gamma = -0{,}33\), image réelle : en accord avec la mesure (image de 0,7 cm pour un objet de 2,0 cm).