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

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$.

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.

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.

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.

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.

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é.

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é.

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.

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$.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

À 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.

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$.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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$.

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.

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.

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

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 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³.

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

$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.

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.

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.

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

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.

$\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É.

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$ ✓.

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.

$\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}$.

$\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.

$\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.

$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.

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.

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.

$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$.

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.

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.

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.