Exercices corrigés : Python appliqué aux maths, à la physique et à la chimie (Seconde)

a) La boucle `range(-1, 6)` parcourt les entiers de $-1$ à $5$, la borne de droite étant EXCLUE. On calcule $f$ pour chacun : $f(-1)=1+4+1=6$, $f(0)=1$, $f(1)=1-4+1=-2$, $f(2)=4-8+1=-3$, $f(3)=9-12+1=-2$, $f(4)=16-16+1=1$, $f(5)=25-20+1=6$. Le tableau affiché est donc $6\,;\,1\,;\,-2\,;\,-3\,;\,-2\,;\,1\,;\,6$.

b) Le plus petit résultat, $-3$, est obtenu pour $x=2$. Le calcul le confirme et va plus loin que la machine : la forme canonique s'écrit $f(x)=(x-2)^2-3$, car $(x-2)^2=x^2-4x+4$ et il faut retirer $3$ pour retrouver le $+1$. Comme un carré est toujours positif ou nul, $f(x)\ge -3$ pour tout $x$, avec égalité uniquement en $x=2$. Le programme SUGGÈRE le minimum sur sept valeurs, le calcul le DÉMONTRE sur tous les réels : la différence est exactement celle entre une observation et une preuve.

c) `range` ne fabrique que des entiers, donc on ne peut pas lui demander un pas de $0{,}5$. On boucle sur des entiers et on divise : `for k in range(-2, 11):` puis `x = k/2` puis `print(x, x*x - 4*x + 1)`. Le compteur $k$ va de $-2$ à $10$, ce qui donne bien $x$ de $-1$ à $5$ par pas de $0{,}5$, soit treize lignes.

d) Il manque la dernière ligne, celle de $x=5$ : `range(-1, 5)` s'arrête à $4$ inclus, alors que la version de l'énoncé allait jusqu'à $5$. C'est l'erreur la plus fréquente du chapitre. La règle à retenir dans les deux sens : `range(a, b)` contient $a$, ne contient pas $b$, et compte $b-a$ valeurs. Ici $5-(-1)=6$ valeurs au lieu de sept.

Le fil de tout l'exercice : le programme ne fait rien d'autre que remplacer $x$ par des valeurs successives dans une expression que l'on a écrite soi-même. S'il affiche des résultats faux, ce n'est presque jamais la machine, c'est la formule ou les bornes de la boucle.

for k in range(-2, 11):
    x = k/2
    print(x, x*x - 4*x + 1)

a) Elle renvoie la vitesse moyenne en kilomètres par heure, puisque $v=\frac{d}{t}$ et que l'unité d'un quotient est le quotient des unités : des kilomètres divisés par des heures donnent des km/h. Une fonction ne connaît pas les unités, c'est à celui qui l'appelle de fournir des données cohérentes.

b) L'erreur n'est pas informatique, elle est physique : $1$ h $48$ min ne s'écrit pas $1{,}48$ h. Les minutes se comptent par soixante, pas par cent. Il faut convertir : $48$ min $=\frac{48}{60}$ h $=0{,}8$ h, donc la durée vaut $1{,}8$ h. On écrit `print(vitesse(234, 1.8))`, ce qui donne $\frac{234}{1{,}8}=130$ km/h. L'écart avec le résultat erroné est énorme, $158$ contre $130$, et rien dans le programme ne le signale : la machine calcule exactement ce qu'on lui a demandé.

c) On divise par $3{,}6$ : `def en_ms(v):` puis ` return v/3.6`. En effet $1$ km/h $=\frac{1000\ \text{m}}{3600\ \text{s}}=\frac{1}{3{,}6}$ m/s. Ici `en_ms(130)` renvoie $\frac{130}{3{,}6}\approx 36{,}1$ m/s. Vérification de bon sens : un nombre exprimé en m/s est toujours PLUS PETIT que le même en km/h, donc si le résultat avait été $468$, le sens de l'opération aurait été inversé.

d) Python interrompt le programme avec une erreur de division par zéro, qui n'est pas définie en machine pas plus qu'en mathématiques. On protège la fonction par un test : `def vitesse(d, t):` puis ` if t == 0:` puis ` return None` puis ` return d/t`. Cela reflète la réalité physique : une distance parcourue en une durée nulle n'a pas de sens.

Le fil : dans un exercice de sciences, la partie fragile n'est pas la division, c'est la préparation des données. Une durée en heures et minutes, une distance en mètres, une masse en grammes doivent être converties AVANT d'entrer dans la fonction.

def vitesse(d, t):
    if t == 0:
        return None
    return d/t

def en_ms(v):
    return v/3.6

print(vitesse(234, 1.8))
print(en_ms(vitesse(234, 1.8)))

a) La quantité de matière vaut $n=\frac{5{,}85}{58{,}5}=0{,}100$ mol. Le volume vaut $500$ mL $=0{,}500$ L, donc $c=\frac{0{,}100}{0{,}500}=0{,}200$ mol/L. La fonction renvoie $0{,}2$.

b) Il obtient $\frac{0{,}1}{500}=2\times 10^{-4}$, soit $0{,}0002$. Il se trompe d'un FACTEUR MILLE, parce qu'il a fourni un volume en millilitres à une formule qui attend des litres. Aucune erreur ne s'affiche : le programme tourne, produit un nombre, et ce nombre est faux. C'est exactement pour cela qu'en chimie on écrit l'unité à côté de chaque valeur avant de taper quoi que ce soit.

c) La dilution conserve la quantité de matière : $c_1 V_1 = c_2 V_2$, donc $V_1=\frac{c_2 V_2}{c_1}$. On écrit `def volume_a_prelever(c1, c2, V2):` puis ` return c2*V2/c1`. Ici $V_1=\frac{0{,}050\times 0{,}100}{0{,}200}=0{,}025$ L, soit $25$ mL. On prélève donc $25$ mL de la solution mère et l'on complète à $100$ mL avec de l'eau distillée. Contrôle immédiat : la concentration a été divisée par quatre, le volume prélevé est bien le quart du volume final.

d) On ajoute un test au début : ` if c2 > c1:` puis ` return None`. La raison est physique et non informatique : diluer, c'est ajouter du solvant, donc la concentration ne peut que BAISSER. Si l'on demandait $c_2>c_1$, la formule renverrait $V_1>V_2$, c'est-à-dire un volume à prélever supérieur au volume final, ce qui n'a aucun sens au laboratoire. Une fonction bien écrite refuse ce qu'elle ne sait pas faire au lieu de renvoyer un nombre absurde.

Le fil : un résultat de chimie faux d'un facteur mille vient presque toujours d'un millilitre pris pour un litre. La machine ne vérifie pas les unités, c'est le seul contrôle qui reste entièrement à la charge de l'élève.

def volume_a_prelever(c1, c2, V2):
    if c2 > c1:
        return None
    return c2*V2/c1

a) Parce que le nombre de tours n'est PAS connu à l'avance : c'est précisément la réponse cherchée. Une boucle `for` exige que l'on annonce le nombre de répétitions avant de commencer, ce qui reviendrait à connaître déjà le résultat. La boucle `while` répète tant qu'une condition est vraie et s'arrête d'elle-même dès qu'elle devient fausse.

b) Augmenter de $4\%$, c'est multiplier par $1{,}04$, donc au bout de $h$ heures la population vaut $500\times 1{,}04^{h}$. Pour $h=35$ : $1{,}04^{35}\approx 3{,}9461$ et $500\times 3{,}9461\approx 1973$ individus, ce qui est encore sous le seuil. Pour $h=36$ : $1{,}04^{36}\approx 4{,}1039$ et $500\times 4{,}1039\approx 2052$ individus, ce qui dépasse. Le programme affiche donc $36$. On retrouve le résultat par le raisonnement : il faut $1{,}04^{h}\ge 4$, et $36$ est le premier entier qui convient.

c) Il a modélisé une croissance LINÉAIRE, quatre bactéries de plus chaque heure, au lieu d'une croissance exponentielle de quatre pour cent par heure. Les deux modèles n'ont rien à voir : avec son programme il faudrait $\frac{2000-500}{4}=375$ heures, soit plus de dix fois trop. Le point de méthode est général : un pourcentage se traduit par une MULTIPLICATION, jamais par une addition, et confondre les deux est l'erreur la plus coûteuse du chapitre sur les évolutions.

d) Si le taux est nul, on multiplie par $1$, la population ne change jamais, la condition `n <= 2000` reste vraie indéfiniment et la boucle ne se termine pas : c'est une boucle infinie. Une boucle `while` n'est correcte que si quelque chose évolue à chaque tour DANS LE SENS de la condition d'arrêt. En pratique on ajoute une sécurité, par exemple `while n <= 2000 and h < 1000:`, pour garantir l'arrêt et signaler que le seuil n'a pas été atteint.

Le fil : le seuil est un motif qui revient toute l'année, en suites comme en sciences. On initialise, on répète la mise à jour, on compte les tours, et l'on vérifie toujours le résultat en calculant à la main les deux valeurs qui encadrent le seuil, ici $1973$ et $2052$.

a) Elle AFFICHE $\frac{96-80}{80}\times 100=\frac{16}{80}\times 100=20$. Le prix a augmenté de $20\%$. Attention au verbe employé : la fonction affiche, elle ne renvoie rien.

b) `print` envoie du texte à l'écran, ce que l'on voit ; `return` fournit une valeur au programme, ce que l'on peut réutiliser. Une fonction sans `return` renvoie automatiquement `None`, donc ici `t` ne contient aucun nombre et `t + 5` provoque une erreur, car on ne peut pas additionner un nombre et l'absence de valeur. On corrige en écrivant `def taux(v1, v2):` puis ` return (v2 - v1)/v1*100`, et l'on affiche à l'extérieur avec `print(taux(80, 96))`. Règle pratique : une fonction de calcul renvoie toujours, elle n'affiche jamais.

c) Le prix final vaut $80\times 1{,}2\times 0{,}8=80\times 0{,}96=76{,}8$ dollars. Le taux global est donc $\frac{76{,}8-80}{80}\times 100=-4$, soit une BAISSE de $4\%$. Le résultat surprend et il faut savoir l'expliquer : la hausse de $20\%$ porte sur $80$ dollars et ajoute $16$ dollars, tandis que la baisse de $20\%$ porte sur $96$ dollars et en retire $19{,}20$. Les taux successifs ne s'additionnent pas, ce sont les COEFFICIENTS MULTIPLICATEURS qui se multiplient.

d) `def applique(prix, t):` puis ` return prix*(1 + t/100)`. Aucun test n'est nécessaire : pour $t=20$ le coefficient vaut $1{,}2$, pour $t=-20$ il vaut $0{,}8$. Une seule formule couvre les deux cas, à condition d'écrire la baisse avec un $t$ NÉGATIF. On vérifie que `applique(applique(80, 20), -20)` renvoie bien $76{,}8$, ce qui redonne la question c) en une seule ligne : c'est tout l'intérêt d'écrire une fonction plutôt que de répéter un calcul.

Le fil : $+20\%$ suivi de $-20\%$ ne ramène pas au départ, et $1{,}2\times 0{,}8=0{,}96\ne 1$ le prouve en une ligne. C'est le résultat le plus souvent demandé en contrôle sur ce chapitre.

def taux(v1, v2):
    return (v2 - v1)/v1*100

def applique(prix, t):
    return prix*(1 + t/100)

print(applique(applique(80, 20), -20))

a) On utilise un ACCUMULATEUR, une variable initialisée à zéro à laquelle on ajoute chaque élément : `s = 0` puis `for x in T:` puis ` s = s + x` puis `print(s/len(T))`. La somme vaut $21{,}4+22{,}1+20{,}8+21{,}9+22{,}3+21{,}0+21{,}5=151{,}0$ et il y a sept mesures, donc la moyenne vaut $\frac{151}{7}\approx 21{,}57$ degré. Le point à ne pas rater : la division se fait APRÈS la boucle, une seule fois. Écrire `s = s/len(T)` à l'intérieur diviserait à chaque tour et donnerait n'importe quoi.

b) On initialise avec le premier élément, jamais avec zéro : `M = T[0]` puis `m = T[0]` puis `for x in T:` puis ` if x > M:` puis ` M = x` puis ` if x < m:` puis ` m = x`. On obtient $M=22{,}3$ et $m=20{,}8$, donc une étendue de $22{,}3-20{,}8=1{,}5$ degré. Initialiser le maximum à zéro serait ici sans conséquence, mais deviendrait faux dès que toutes les mesures seraient négatives, ce qui arrive en hiver à Montréal.

c) `moy = 151/7` puis `c = 0` puis `for x in T:` puis ` if abs(x - moy) > 0.5:` puis ` c = c + 1`. Les écarts à la moyenne $21{,}57$ valent environ $-0{,}17$, $+0{,}53$, $-0{,}77$, $+0{,}33$, $+0{,}73$, $-0{,}57$ et $-0{,}07$. Quatre d'entre eux dépassent $0{,}5$ en valeur absolue : les mesures $22{,}1$, $20{,}8$, $22{,}3$ et $21{,}0$. La valeur absolue est indispensable, car un écart de $-0{,}77$ est aussi grand qu'un écart de $+0{,}77$ : sans elle, on ne compterait que les mesures supérieures à la moyenne.

d) Elles diffèrent à cause des incertitudes de mesure, qui viennent du capteur lui-même et des micro-variations réelles de la pièce. Aucune mesure physique n'est exacte. La moyenne est retenue parce que les erreurs se compensent en partie : les écarts positifs et négatifs s'annulent partiellement, et l'étendue de $1{,}5$ degré donne une idée de la dispersion, donc de la confiance à accorder au résultat. On annonce ainsi une température d'environ $21{,}6$ degré, pas $21{,}571428$ : conserver toutes les décimales de la division reviendrait à prétendre une précision que les mesures n'ont pas.

Le fil : une liste de mesures se traite toujours de la même façon, un accumulateur pour la somme, un comparateur pour les extremums, un compteur pour les cas particuliers. Le raisonnement de sciences vient après, quand il faut décider combien de chiffres du résultat ont un sens.

s = 0
for x in T:
    s = s + x
moy = s/len(T)

c = 0
for x in T:
    if abs(x - moy) > 0.5:
        c = c + 1
print(moy, c)

a) La ligne du saut compare une valeur à la précédente : `saut = pH[i] - pH[i-1]`. Le test conserve le plus grand : `if saut > saut_max:`. Enfin le volume équivalent est situé au MILIEU de l'intervalle où le saut se produit : `Veq = (V[indice] + V[indice-1])/2`. Chacune de ces trois lignes traduit une phrase du cours, et c'est dans cet ordre qu'il faut les écrire, jamais l'inverse.

b) Les sauts successifs valent $3{,}6-3{,}1=0{,}5$, puis $7{,}4-3{,}6=3{,}8$, puis $10{,}2-7{,}4=2{,}8$, puis $10{,}7-10{,}2=0{,}5$. Le plus grand est $3{,}8$, obtenu pour `i = 2`, c'est-à-dire entre $V=9{,}0$ mL et $V=10{,}0$ mL. Le programme affiche donc $V_{\text{éq}}=\frac{9{,}0+10{,}0}{2}=9{,}5$ mL. Cette lecture correspond exactement à ce que l'on fait à la main sur la courbe de titrage : on repère le saut brutal de pH et l'on place l'équivalence en son milieu.

c) À l'équivalence, les réactifs ont été introduits dans les proportions de l'équation, donc $c_A V_A = c_B V_{\text{éq}}$, d'où $c_A=\frac{c_B V_{\text{éq}}}{V_A}=\frac{0{,}100\times 9{,}5}{20{,}0}=0{,}0475$ mol/L. Les volumes peuvent rester en millilitres des deux côtés puisqu'ils apparaissent en quotient : c'est le seul endroit du chapitre où l'on n'est pas obligé de convertir, et il faut savoir dire pourquoi.

d) Parce que la ligne `pH[i-1]` a besoin d'un élément PRÉCÉDENT. Avec `i = 0`, on écrirait `pH[-1]`, qui en Python désigne le DERNIER élément de la liste : le programme ne signalerait aucune erreur mais comparerait le premier pH au dernier, donc calculerait un saut de $3{,}1-10{,}7=-7{,}6$, sans aucun sens chimique. C'est le piège le plus dangereux du chapitre sur les listes, parce qu'il ne produit pas de message d'erreur, seulement un résultat faux. La règle : dès qu'une boucle compare un élément au précédent, elle commence à l'indice $1$.

Le fil : le programme ne fait que formaliser la lecture graphique. Savoir où est l'équivalence, c'est savoir que le saut de pH est brutal, et le milieu de l'intervalle est la meilleure estimation que l'on puisse tirer d'un relevé espacé de $1$ mL.

saut_max = 0
indice = 0
for i in range(1, len(pH)):
    saut = pH[i] - pH[i-1]
    if saut > saut_max:
        saut_max = saut
        indice = i
Veq = (V[indice] + V[indice-1])/2
print(Veq)

a) FAUX. `==` est un TEST d'égalité : il ne modifie rien et renvoie `True` ou `False`. C'est `=` qui affecte. Version correcte : « l'instruction `x = 3` range la valeur $3$ dans `x`, tandis que `x == 3` demande si `x` vaut déjà $3$ ». La confusion est d'autant plus facile qu'en mathématiques le signe $=$ sert aux deux usages.

b) FAUX. `range(1, 10)` parcourt $1, 2, \dots, 9$, la borne de droite étant exclue : cela fait $10-1=9$ tours. Version correcte : « la boucle effectue neuf tours ». Pour obtenir dix tours à partir de $1$, on écrit `range(1, 11)`.

c) FAUX. Sans `return`, une fonction exécute ses instructions puis renvoie `None`, c'est-à-dire aucune valeur exploitable. Version correcte : « une fonction ne renvoie une valeur que si elle contient explicitement une instruction `return` ». Le symptôme classique est une erreur quelques lignes plus loin, quand on essaie de calculer avec le résultat.

d) FAUX, c'est l'inverse. Puisque $1$ km/h $=\frac{1000}{3600}$ m/s $=\frac{1}{3{,}6}$ m/s, on DIVISE par $3{,}6$ pour aller des km/h vers les m/s. Version correcte : « on divise par $3{,}6$ pour passer des km/h aux m/s, et l'on multiplie par $3{,}6$ dans l'autre sens ». Le contrôle mental est immédiat : $90$ km/h vaut $25$ m/s, un nombre plus petit.

e) FAUX, cela renvoie `False`. Les nombres décimaux sont stockés en base deux, et ni $0{,}1$ ni $0{,}2$ n'y ont d'écriture finie : la somme obtenue vaut $0{,}30000000000000004$. Version correcte : « on ne teste jamais l'égalité de deux flottants, on teste si leur écart est petit », par exemple `abs(0.1 + 0.2 - 0.3) < 1e-9`. C'est la même limitation qu'avec $\frac{1}{3}=0{,}333\dots$ en base dix, à ceci près que ce sont d'autres fractions qui posent problème.

Ces cinq erreurs représentent la grande majorité des points perdus en algorithmique au niveau Seconde. Aucune ne relève des mathématiques : ce sont des règles de lecture d'un programme, et elles se vérifient à la main, sans machine.

a) `def distance(t):` puis ` return 0.5*9.8*t*t`, puis `for k in range(0, 6):` puis ` t = k/2` puis ` print(t, distance(t))`. Les valeurs sont $d(0)=0$, $d(0{,}5)=1{,}225$, $d(1)=4{,}9$, $d(1{,}5)=11{,}025$, $d(2)=19{,}6$ et $d(2{,}5)=30{,}625$ mètres. On voit immédiatement que la réponse cherchée est entre $2$ et $2{,}5$ s, et le tableau montre aussi que les écarts s'agrandissent, ce qui est la signature d'un mouvement accéléré : chaque demi-seconde fait tomber plus loin que la précédente.

b) `k = 0` puis `while 0.5*9.8*(k/10)**2 < 20:` puis ` k = k + 1` puis `print(k/10)`. Le programme s'arrête à $k=21$. En effet $d(2{,}0)=0{,}5\times 9{,}8\times 4=19{,}6$ m, encore insuffisant, alors que $d(2{,}1)=0{,}5\times 9{,}8\times 4{,}41=21{,}609$ m dépasse. L'encadrement est donc $2{,}0<t<2{,}1$ s. Un pas de $0{,}01$ s donnerait une décimale de plus, au prix de dix fois plus de tours.

c) On isole : $t^2=\frac{2\times 20}{9{,}8}=\frac{40}{9{,}8}\approx 4{,}0816$, donc $t=\sqrt{4{,}0816}\approx 2{,}02$ s, en ne gardant que la solution positive puisqu'il s'agit d'une durée. La valeur exacte tombe bien dans l'encadrement du balayage ✓. La vitesse vaut alors $v=9{,}8\times 2{,}02\approx 19{,}8$ m/s, soit $19{,}8\times 3{,}6\approx 71{,}3$ km/h : un objet lâché de six étages arrive au sol à la vitesse d'une voiture en ville.

d) Parce que $0{,}1$ n'a pas d'écriture exacte en machine. En ajoutant $0{,}1$ vingt et une fois, on n'obtient pas $2{,}1$ mais $2{,}0999999999999996$, et l'erreur s'accumule à chaque tour. Le test d'arrêt peut alors basculer un cran trop tôt ou trop tard, et un affichage brut fait apparaître des durées comme $1{,}7000000000000004$. En bouclant sur l'entier $k$ et en posant $t=\frac{k}{10}$, on ne fait qu'UNE division au lieu de vingt et une additions : l'erreur ne s'accumule plus. C'est la bonne habitude à prendre pour tous les balayages.

Le fil : le balayage n'est pas une méthode de secours, c'est la méthode générale. Elle s'applique même quand l'équation ne se résout pas, et elle fournit toujours un ENCADREMENT, dont la largeur est le pas choisi.

def distance(t):
    return 0.5*9.8*t*t

k = 0
while distance(k/10) < 20:
    k = k + 1
print((k-1)/10, k/10)

a) `c = 0.20` puis `n = 0` puis `while c >= 1e-6:` puis ` c = c/10` puis ` n = n + 1` puis `print(n)`. Le programme affiche $6$. La structure est celle de l'exercice 4, à un détail près qui change tout : la condition est un seuil à franchir VERS LE BAS, donc on continue tant que la concentration reste trop grande.

b) La concentration après $n$ étapes vaut $c_n=\frac{0{,}20}{10^{n}}$. Pour $n=5$ : $c_5=\frac{0{,}20}{100\,000}=2\times 10^{-6}$ mol/L, ce qui est encore au-dessus du seuil de $10^{-6}$. Pour $n=6$ : $c_6=\frac{0{,}20}{1\,000\,000}=2\times 10^{-7}$ mol/L, ce qui passe bien en dessous. Il faut donc six étapes, ce qui confirme l'affichage. Remarquez que le facteur $2$ du numérateur suffit à décider : sans lui, cinq étapes auraient suffi.

c) On remplace la division par $10$ par une division par $2$, et le seuil par $10^{-3}$. Il faut $\frac{0{,}20}{2^{n}}<10^{-3}$, c'est-à-dire $2^{n}>200$. Or $2^{7}=128$ donne $c_7\approx 1{,}56\times 10^{-3}$, encore trop, tandis que $2^{8}=256$ donne $c_8\approx 7{,}81\times 10^{-4}$, qui convient. Il faut donc HUIT étapes pour perdre un facteur $200$, alors que six suffisaient pour en perdre $200\,000$ dans le protocole précédent. C'est toute la différence entre diviser par deux et diviser par dix : à chaque étape, le facteur choisi se retrouve en exposant.

d) La boucle ne s'arrête jamais. Les valeurs prises par `c` sont $0{,}02$, $0{,}002$, $0{,}0002$ et ainsi de suite : elles PASSENT À CÔTÉ de $10^{-6}$ sans jamais l'égaler, donc la condition `c != 1e-6` reste vraie indéfiniment. Même si une valeur devait tomber exactement sur le seuil, la représentation approchée des décimaux en machine rendrait l'égalité douteuse. La règle est absolue et vaut bien au-delà de cet exercice : la condition d'arrêt d'une boucle numérique s'écrit toujours avec une INÉGALITÉ, jamais avec `==` ni `!=`. C'est le même principe qu'à l'exercice 8 e).

Le fil de la série entière se lit dans cet exercice : la boucle répète une opération que l'on sait poser à la main, la vérification passe par le calcul exact, et la seule difficulté réelle est la condition d'arrêt. Un programme faux ne se signale presque jamais par un message d'erreur, il se signale par un résultat que le calcul de contrôle contredit.

c = 0.20
n = 0
while c >= 1e-6:
    c = c/10
    n = n + 1
print(n)

a) Pour $i=0$, le programme calculerait `U[0]/I[0]`, soit $\frac{0}{0}$ : une division par zéro, qui arrête le programme sur une erreur. Le premier point de mesure, courant nul et tension nulle, ne donne aucune information sur $R$ : on l'écarte en commençant à $1$.

b) Les quatre rapports valent $\frac{1{,}5}{0{,}032}\approx 46{,}9$ ; $\frac{3{,}0}{0{,}063}\approx 47{,}6$ ; $\frac{4{,}5}{0{,}097}\approx 46{,}4$ ; $\frac{6{,}0}{0{,}128}\approx 46{,}9$. Leur moyenne vaut environ $46{,}9\ \Omega$. Les rapports ne sont pas rigoureusement égaux : ce sont des mesures, entachées d'incertitude, et la moyenne en atténue l'effet.

c) La somme contient $4$ rapports, un par tour de boucle, puisque l'indice $0$ a été écarté. Diviser par `len(U)`, qui vaut $5$, donnerait $\frac{187{,}8}{5}\approx 37{,}6\ \Omega$, une valeur fausse d'un cinquième. On divise toujours par le nombre de valeurs réellement additionnées.

d) $U=R\times I=47\times 0{,}20=9{,}4$ V.

e) Les intensités sont mille fois trop grandes, donc les rapports mille fois trop petits : $R\approx 0{,}0469\ \Omega$. L'erreur est d'un facteur $1\,000$, et le programme ne la signale pas. Le seul contrôle possible est l'ordre de grandeur : un conducteur ohmique courant fait des dizaines ou des centaines d'ohms, pas un centième.

Le fil : un programme de traitement de mesures ne vaut que par ses données. Le choix des indices, du diviseur et des unités est la partie scientifique du travail, la boucle n'est que l'outil.

a) Le volume d'eau déplacé est le volume de l'objet : $66{,}0-50{,}0=16{,}0$ mL, soit $16{,}0$ cm³, puisque $1$ mL $=1$ cm³.

b) $\rho=\frac{43{,}2}{16{,}0}=2{,}70$ g/cm³.

c) $1$ g/cm³ $=\frac{10^{-3}\ \text{kg}}{10^{-6}\ \text{m}^{3}}=1\,000$ kg/m³. Donc $\rho=2\,700$ kg/m³. Un mètre cube d'aluminium pèse près de trois tonnes.

d) La fonction calcule l'écart `abs(rho - valeurs[i])` pour chaque métal et garde le plus petit. Pour $2{,}70$, l'écart avec l'aluminium est nul : elle renvoie « aluminium ». Pour $8{,}9$ : écarts $6{,}2$ ; $1{,}03$ ; $0{,}06$ ; $2{,}4$. Le plus petit est celui du cuivre. Comme pour un maximum, on initialise la recherche avec le premier élément de la liste, jamais avec une valeur arbitraire.

e) Volume du cube : $5^{3}=125$ cm³. Masse : $m=\rho\times V=7{,}87\times 125=983{,}75$ g, soit environ $984$ g. Un cube de fer qui tient dans la main pèse presque un kilogramme.

Le point de méthode : la masse volumique identifie un matériau parce qu'elle ne dépend pas de la taille de l'échantillon, et la mesure du volume par déplacement d'eau évite tout calcul géométrique.

a) `range(len(t) - 1)` vaut `range(4)` : $4$ tours, donc $4$ vitesses. Cinq positions délimitent quatre intervalles de temps.

b) Chaque intervalle : $\frac{0{,}30}{0{,}2}=1{,}5$ m/s. Les quatre vitesses sont égales et le palet se déplace en ligne droite : le mouvement est rectiligne UNIFORME.

c) $\frac{0{,}10}{0{,}2}=0{,}5$ ; $\frac{0{,}30}{0{,}2}=1{,}5$ ; $\frac{0{,}50}{0{,}2}=2{,}5$ ; $\frac{0{,}70}{0{,}2}=3{,}5$ m/s. La vitesse augmente de $1{,}0$ m/s à chaque intervalle : le mouvement est rectiligne ACCÉLÉRÉ.

d) Distance totale sur durée totale : $\frac{1{,}60}{0{,}8}=2{,}0$ m/s. C'est aussi la moyenne des quatre vitesses, parce que les intervalles ont la même durée : $\frac{0{,}5+1{,}5+2{,}5+3{,}5}{4}=2{,}0$ ✓.

e) La formule utilise `x[i+1]`. Pour `i = len(t) - 1`, l'indice `i+1` vaudrait $5$, qui n'existe pas dans une liste de cinq éléments : le programme s'arrêterait sur une erreur d'indice. Quand on compare un élément au SUIVANT, la boucle s'arrête un cran avant la fin.

Le fil : une vitesse moyenne est une variation de position sur une variation de temps, et une liste de positions en donne une par intervalle. Leur régularité, ou leur croissance, révèle la nature du mouvement.

a) $\sin i_{2}=\frac{1{,}00\times\sin 30^{\circ}}{1{,}33}=\frac{0{,}5}{1{,}33}\approx 0{,}376$, donc $i_{2}\approx 22{,}08^{\circ}$.

b) $\sin i_{2}=\frac{\sin 60^{\circ}}{1{,}33}\approx\frac{0{,}866}{1{,}33}\approx 0{,}651$, donc $i_{2}\approx 40{,}63^{\circ}$. L'angle de réfraction est plus petit que l'angle d'incidence : en entrant dans un milieu plus réfringent, le rayon se RAPPROCHE de la normale.

c) $\sin i_{2}=1{,}33\times\sin 40^{\circ}\approx 0{,}855$, donc $i_{2}\approx 58{,}75^{\circ}$. En sortant de l'eau, le rayon s'éloigne de la normale.

d) $1{,}33\times\sin 60^{\circ}\approx 1{,}152$. Un sinus ne peut pas dépasser $1$ : aucun angle ne convient et la fonction renvoie `None`. Physiquement, il n'y a pas de rayon réfracté : la lumière est entièrement réfléchie dans l'eau, c'est la RÉFLEXION TOTALE. Sans le test `if s > 1`, la fonction `asin` provoquerait une erreur.

e) L'angle limite vérifie $1{,}33\times\sin i_{\ell}=1$, soit $\sin i_{\ell}=\frac{1}{1{,}33}$ et $i_{\ell}\approx 48{,}75^{\circ}$. Les fonctions `sin` et `asin` de Python travaillent en RADIANS : il faut convertir l'angle donné en degrés avant d'en prendre le sinus, puis reconvertir le résultat. Oublier `radians` ferait calculer le sinus de $30$ radians, un angle sans rapport.

Ce problème montre ce qu'un programme ajoute à une formule : il oblige à prévoir le cas où la formule n'a pas de solution, et ce cas est justement un phénomène physique réel.

a) Entre le premier et le dernier maximum, il y a $4$ périodes : $T=\frac{11{,}2-1{,}2}{5-1}=\frac{10{,}0}{4}=2{,}5$ ms. Le programme écrit `tmax[-1]` pour le dernier élément et `len(tmax) - 1` pour le nombre d'intervalles.

b) $T=2{,}5$ ms $=0{,}0025$ s, donc $f=\frac{1}{0{,}0025}=400$ Hz. Le programme écrit `1000 / T` parce que $T$ est en millisecondes : c'est la conversion d'unité, cachée dans le $1\,000$.

c) Chaque instant relevé est entaché d'une incertitude, par exemple $0{,}1$ ms. Sur un seul intervalle de $2{,}5$ ms, cette erreur pèse $4\ \%$ ; répartie sur quatre périodes, elle ne pèse plus que $1\ \%$. Mesurer plusieurs périodes d'un coup améliore la précision : c'est la méthode employée au laboratoire avec un oscilloscope.

d) Le son fait l'ALLER-RETOUR : il parcourt $340\times 0{,}35=119$ m, et la falaise est à la moitié, soit $59{,}5$ m. Oublier de diviser par deux est l'erreur classique de tous les exercices d'écho.

e) Aller-retour : $1\,500\times 0{,}080=120$ m, donc une profondeur de $60$ m. Le son va plus de quatre fois plus vite dans l'eau que dans l'air, ce qui explique qu'un écho sous-marin revienne si vite.

Le fil : la période se mesure sur plusieurs oscillations pour gagner en précision, et une distance par écho se divise toujours par deux.