Mouvement de chute libre d'une balle (Python)

On souhaite modéliser et étudier à l'aide du langage Python les positions successives, les vecteurs vitesse et les variations de vitesse d'une balle lancée verticalement vers le haut.

Modélisation physique et chute libre

Définition : chute libre

Un système est en chute libre s'il n'est soumis qu'à son poids (l'action mécanique exercée par l'air est alors négligée).

Question 1

Une fois que la balle a quitté la main du lanceur, faire un diagramme objet-interaction (DOI) des différents objets interagissant avec la balle, puis représenter les forces s'exerçant sur la balle (assimilée à un point matériel situé en son centre).

RéponseVoir le bilan des actions mécaniques

Terre : interaction à distance (gravitationnelle), modélisée par le poids $\vec{P}$ (direction verticale, sens vers le bas).
Air : interaction de contact avec l'air environnant, modélisée par la force de frottement fluide $\vec{f}$ (opposée au mouvement) et la poussée d'Archimède (très faible ici).

Attention : la main n'interagit plus avec la balle dès que celle-ci est lâchée ! Il n'y a pas de « force de lancer » qui accompagnerait la balle pendant son vol.

À partir de maintenant, on néglige les frottements de l'air devant le poids de la balle.

Question 2

Sous cette hypothèse, la balle est-elle en chute libre pendant sa phase de montée ?

RéponseVoir la réponse

Oui, tout à fait. En physique, le terme « chute libre » ne signifie pas nécessairement que l'objet descend : dès que la balle a quitté la main et que l'action de l'air est négligée, la seule force qui s'exerce sur elle est son poids $\vec{P}$, aussi bien pendant la montée, au sommet de la trajectoire, que pendant la descente.

Listes de données et boucles en Python

Création et affichage des listes `T` et `Y`

Le programme ci-dessous calcule une liste T contenant $N = 12$ instants $t_i$ régulièrement espacés d'une durée $\Delta t$ (notée Dt), ainsi qu'une liste Y contenant les $N$ altitudes $y(t_i)$ correspondantes de la balle (lancée à $t = 0$ depuis une hauteur de $1\text{ m}$ avec une vitesse initiale $v_0 = \pu{5 m*s-1}$).

Cliquez sur le bouton ▶ Exécuter pour afficher le contenu des deux listes :

Récupérer un élément dans une liste

Indice d'une liste en Python

En Python, une liste est une série d'éléments séparés par des virgules et placés entre crochets [ ]. Les éléments sont repérés par leur position, appelée indice, mais la numérotation commence à 0 (et non à 1) :

pour récupérer le 1^er élément d'une liste T, on écrit T[0] ;
pour récupérer le 3^e élément de la liste Y (l'altitude du 3^e point), on écrit Y[2] ;
plus généralement, le $i$^e élément d'une liste L s'écrit L[i-1] ;
astuce : pour récupérer directement le dernier élément d'une liste L, on écrit L[-1].

Position courante	1^er élément	2^e élément	3^e élément	…	$i$^e élément	Dernier ($N$^e)
Indice en Python	`0`	`1`	`2`	…	`i - 1`	`N - 1` ou `-1`
Syntaxe pour la liste `Y`	`Y[0]`	`Y[1]`	`Y[2]`	…	`Y[i-1]`	`Y[N-1]` ou `Y[-1]`

Question 3

Dans la fenêtre de code ci-dessous, complétez la fin du programme pour afficher le 7^e élément de la liste Y ainsi que son dernier élément.

RéponseVoir les instructions à écrire

Le 7^e élément porte l'indice 6 (car $7 - 1 = 6$) :

print("7e élément de Y :", Y[6])
print("Dernier élément de Y :", Y[-1])

On trouve $Y[6] \approx \pu{2,22 m}$ et $Y[-1] \approx \pu{0,44 m}$.

Parcourir une liste avec `for` et tester avec `if / else`

Boucle for et conditions if / else

La boucle for : l'instruction for i in range(N): fait varier la variable i (qui sert d'indice) sur tous les entiers de 0 jusqu'à N - 1 inclus. Tout le bloc de code indenté (décalé vers la droite de 4 espaces) est répété pour chaque valeur de i.
La structure conditionnelle if / else : permet d'exécuter un bloc d'instructions uniquement si une condition est vraie (if), et un autre bloc sinon (else).

Exécutez les deux petits exemples ci-dessous pour observer le fonctionnement d'une boucle for qui parcourt la liste Y, puis d'un test de parité avec if / else :

ComparaisonPourquoi le test automatique est bien plus élégant que la « version candide »

Sans utiliser l'opérateur reste % et le bloc if / else, il aurait fallu tester chaque valeur à la main :

for i in range(20):
    if i == 0: print(f"{i} est pair")
    if i == 1: print(f"{i} est impair")
    if i == 2: print(f"{i} est pair")
    # ... et ainsi de suite jusqu'à 19 (ou 10 000 !)

Un bon programme exprime une règle générale valable quel que soit le nombre de points $N$.

Évolution de l’altitude au cours du temps

On trace maintenant le graphique représentant l'altitude $y$ de la balle en fonction du temps $t$. Les points sont colorés en bleu lors de la montée et en orange lors de la descente.

Exécutez le programme ci-dessous (le premier lancement de matplotlib prend quelques secondes) :

Attention à ne pas confondre

La courbe en cloche ci-dessus représente l'évolution de l'altitude $y$ en fonction du temps $t$ ($y(t)$), et non la trajectoire de la balle dans l'espace ! Dans la réalité, la balle monte et redescend sur une même droite verticale ($x = 0$).

Questions 4

Décrire précisément le mouvement de la balle (nature de la trajectoire et évolution de la vitesse lors des deux phases).

Questions 5

Expliquer comment le programme choisit automatiquement la couleur bleue ou orange pour chaque point $M_i$.

RéponseVoir les réponses aux questions 4 et 5

La trajectoire est un segment de droite vertical : le mouvement est rectiligne.
• Phase de montée (points bleus) : l'écart vertical parcouru pendant une même durée $\Delta t$ diminue au fur et à mesure que la balle monte. Le mouvement est rectiligne ralenti (ou décéléré).
• Phase de descente (points oranges) : l'écart vertical parcouru pendant $\Delta t$ augmente de plus en plus. Le mouvement est rectiligne accéléré.
Pour chaque indice i allant de 1 à N-1, le test if Y[i-1] < Y[i]: compare l'altitude du point précédent $M_{i-1}$ à celle du point actuel $M_i$ : si l'altitude a augmenté ($y_{i-1} < y_i$), la balle monte et on choisit le bleu (#4c72b0) ; sinon ($y_{i-1} \geqslant y_i$), elle redescend et on choisit l'orange (#dd8452).

Vecteurs déplacement

On s'intéresse maintenant aux vecteurs déplacement $\overrightarrow{M_i M_{i+1}}$ reliant deux positions consécutives $M_i$ et $M_{i+1}$. Pour un mouvement vertical selon l'axe $(Oy)$, la coordonnée verticale du vecteur $\overrightarrow{M_i M_{i+1}}$ vaut simplement $y_{i+1} - y_i$.

Question 6

Observez le bloc de calcul des vecteurs déplacement dans le programme ci-dessous, puis exécutez-le. Pourquoi a-t-on écrit for i in range(N-1): (soit $N-1$ éléments) plutôt que for i in range(N): ?

RéponseVoir l'explication sur range(N-1)

Entre $N$ points ($M_0, M_1, \dots, M_{N-1}$), il n'y a que $N - 1$ intervalles : le dernier vecteur déplacement est $\overrightarrow{M_{N-2} M_{N-1}}$.
D'un point de vue informatique, la formule utilise Y[i+1] : si i atteignait la valeur N-1, le programme chercherait à lire Y[N] qui n'existe pas, ce qui déclencherait une erreur (IndexError: list index out of range).

Vecteurs vitesse

On souhaite maintenant calculer et représenter le vecteur vitesse $\vec{v}_i$ en chaque point à partir du vecteur déplacement $\overrightarrow{M_i M_{i+1}}$ et de la durée $\Delta t$ entre deux positions consécutives.

Vecteur vitesse en un point $M_i$

$$\vec{v}_i = \dfrac{\overrightarrow{M_i M_{i+1}}}{\Delta t}$$

$v_i$ en $\pu{m*s-1}$$M_i M_{i+1}$ en m$\Delta t$ en s (variable Dt dans le code)

Questions 7

Dans la fenêtre ci-dessous, complétez la ligne V[i] = ... permettant de calculer la coordonnée verticale de chaque vecteur vitesse à partir de MMprime[i] et de Dt, puis exécutez le programme pour tracer les vecteurs vitesse.

Questions 8

Que remarquez-vous concernant la direction, le sens et la norme des vecteurs vitesse au cours du mouvement ?

RéponseVoir le code de la question 7 et les observations (question 8)

Ligne à écrire :
```
for i in range(N-1):
    V[i] = MMprime[i] / Dt
```
Dans ce programme orienté vers le haut, V[i] est positif à la montée ($\vec{v}_i$ vers le haut) et négatif à la descente ($\vec{v}_i$ vers le bas).
Observations :
• Lors de la montée, les vecteurs vitesse sont verticaux, dirigés vers le haut, et leur norme diminue régulièrement (de $\pu{4,5 m*s-1}$ jusqu'à $\pu{0,5 m*s-1}$ avant le sommet).
• Lors de la descente, les vecteurs vitesse sont verticaux, dirigés vers le bas, et leur norme augmente régulièrement.
• Symétrie : à une même altitude, la balle possède exactement la même valeur de vitesse à la montée et à la descente (seul le sens du vecteur change).

Vecteurs variation de vitesse et lien avec les forces

On étudie enfin le vecteur variation de vitesse entre deux positions successives :

Vecteur variation de vitesse

$$\overrightarrow{\Delta v}_i = \vec{v}_{i+1} - \vec{v}_i$$

$\Delta v_i$ en $\pu{m*s-1}$Il y a $N-1$ vecteurs vitesse, donc $N-2$ vecteurs variation de vitesse

Questions 9

Dans le code ci-dessous, complétez la ligne DV[i] = ... en vous inspirant du calcul fait précédemment pour les déplacements, puis exécutez la cellule.

Questions 10

En utilisant la contraposée du principe d'inertie (et le lien entre variation de vitesse et forces), que pouvez-vous déduire de l'allure des vecteurs $\overrightarrow{\Delta v}_i$ tracés sur le graphique ?

RéponseVoir le code de la question 9 et la déduction physique (question 10)

Ligne à écrire :

for i in range(N-2):
    DV[i] = V[i+1] - V[i]

Déduction à partir du principe d'inertie :
• On observe que le vecteur vitesse varie ($\overrightarrow{\Delta v}_i \neq \vec{0}$) : d'après le principe d'inertie, les forces qui s'exercent sur la balle ne se compensent pas.
• De plus, aussi bien pendant la montée que pendant la descente, tous les vecteurs $\overrightarrow{\Delta v}_i$ ont la même direction (verticale), le même sens (vers le bas) et la même norme : la somme des forces qui s'exercent sur la balle est donc une force constante, verticale et dirigée vers le bas. On retrouve bien les caractéristiques du seul poids $\vec{P}$ de la balle !

Vérification numérique des valeurs

Questions 11

Dans la fenêtre ci-dessous, écrivez les instructions print(...) permettant d'afficher les listes T, Y, MMprime, V et DV.

Questions 12

Que constatez-vous en observant les valeurs numériques de la liste DV ?

Questions 13

Vérifiez à la main le calcul de la norme $\|\overrightarrow{\Delta v}_2\|$ à partir des valeurs de la liste V.

RéponseVoir le code d'affichage et les réponses aux questions 12 et 13

Code d'affichage :

print("T =", T)
print("Y =", Y)
print("MMprime =", MMprime)
print("V =", V)
print("DV =", DV)

Question 11 : Toutes les valeurs de la liste DV sont constantes et égales à $\pu{-1,0 m*s-1}$ (aux minuscules arrondis numériques près de Python, par exemple -0.9999999999999996). Le signe « $-$ » indique que le vecteur $\overrightarrow{\Delta v}_i$ est toujours orienté vers le bas, et sa norme vaut $\|\overrightarrow{\Delta v}_i\| = \pu{1,0 m*s-1}$.
Question 12 : Par définition, $\overrightarrow{\Delta v}_2 = \vec{v}_3 - \vec{v}_2$ (soit DV[2] = V[3] - V[2] en Python).
En lisant les 3^e et 4^e éléments de la liste V : $v_2 = \pu{2,5 m*s-1}$ et $v_3 = \pu{1,5 m*s-1}$ (tous deux dirigés vers le haut).
Sur l'axe vertical orienté vers le haut : $\Delta v_2 = v_3 - v_2 = 1{,}5 - 2{,}5 = \pu{-1,0 m*s-1}$, d'où $\|\overrightarrow{\Delta v}_2\| = \pu{1,0 m*s-1}$.

À retenir

Lors d'une chute libre, le système n'est soumis qu'à son poids $\vec{P}$ (vertical, vers le bas, de valeur constante $P = m \times g$).
Quelle que soit la phase du mouvement (montée ou descente), le vecteur variation de vitesse $\overrightarrow{\Delta v}$ entre deux instants séparés de $\Delta t$ a la même direction et le même sens que la somme des forces extérieures : il est donc toujours vertical, dirigé vers le bas et de norme constante.

Pour aller plus loinPourquoi trouve-t-on exactement $\|\overrightarrow{\Delta v}\| = \pu{1,0 m*s-1}$ dans ce programme ?

En classe de Première et de Terminale, la deuxième loi de Newton montre que pour une chute libre pendant une durée $\Delta t$, le vecteur variation de vitesse vérifie :

$$m\,\overrightarrow{\Delta v} = \vec{P}\times \Delta t = m\,\vec{g}\times \Delta t \quad\Longleftrightarrow\quad \overrightarrow{\Delta v} = \vec{g}\times \Delta t$$

Dans notre programme, l'intervalle de temps vaut $\Delta t = \dfrac{t_\text{max}}{N - 2} = \dfrac{2\,v_0 / g}{10} = \dfrac{2 \times 5}{10 \times g} = \dfrac{1}{g} \approx \pu{0,102 s}$.
La norme de $\overrightarrow{\Delta v}$ vaut donc $g \times \Delta t = g \times \dfrac{1}{g} = \pu{1,0 m*s-1}$ !