Objectif de la fiche : représenter les vecteurs vitesse (ou plus exactement, vecteurs déplacement) d'un système modélisé par un point lors d'un mouvement, en utilisant une boucle for pour automatiser le tracé.
Cette fiche est autonome : tu n'as besoin d'aucun autre document, tout ce qu'il faut est ci-dessous, y compris le rappel du script des fiches précédentes. Chaque étape contient un script incomplet à compléter, puis à copier-coller dans Thonny (ou dans la console Basthon tout en bas de la page si tu n'as pas Thonny sous la main).
On reprend là où on s'était arrêté
- Cette fiche prolonge les fiches n°1 et n°2 : on repart des mêmes mesures de chute d'une bille, obtenues par chronophotographie.
- Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer, tu n'as rien à deviner ici.
- Garde cette fenêtre Thonny ouverte : tu vas ajouter du code à la suite à chaque étape.
Rappel des mesures
Les 16 positions y ont été pointées sur la chronophotographie de la chute, à intervalles de temps égaux. Le point n°0, en haut, sert d'origine.
| point n° | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| y mesuré | 0 | −0,7 | −1,5 | −2,3 | −3,5 | −4,5 | −5,9 | −7,7 | −8,8 | −10,6 | −12,3 | −14,2 | −16,4 | −18,5 | −21 | −23,5 |
On va cette fois s'intéresser à ce qui se passe entre deux points consécutifs : le vecteur déplacement, qui relie la position n°i à la position n°i+1.
import numpy as np
import matplotlib.pyplot as plt
# Ordonnées pointées sur la chronophotographie (unités de la photo)
ymes = np.array([-0, -0.7, -1.5, -2.3, -3.5, -4.5, -5.9, -7.7,
-8.8, -10.6, -12.3, -14.2, -16.4, -18.5, -21, -23.5])
# Passage à l'échelle réelle (facteur 2/100)
yreelle = ymes * 2 / 100
# Base de temps : 16 instants entre 0 s et 0,25 s
t = np.linspace(0, 1/4, 16)
print('yreelle :', yreelle)
print('t :', t)Deux lignes s'affichent dans la console : la liste des 16 positions réelles (en mètres, négatives), puis la liste des 16 instants de 0 à 0,25 seconde.
Compter les déplacements avec une boucle for
yreellecontient 16 valeurs (indices 0 à 15), mais il n'existe que 15 déplacements possibles entre deux points consécutifs :yreelle[1]-yreelle[0],yreelle[2]-yreelle[1], … jusqu'àyreelle[15]-yreelle[14].- Utilise
np.arange(len(t)-1)pour engendrer la liste des indices0, 1, 2, …, 14: nomme ce tableaun. - Vérifie avec
printquencontient bien 15 valeurs, de 0 à 14.
# TODO : engendre la liste des indices 0 à 14 (15 valeurs)
n = np.arange(len(____) - __)
print('n :', n)Indice
len(t) vaut 16, le nombre total de points. Comme il n'y a qu'une différence possible entre chaque paire de points consécutifs, il faut soustraire 1 : len(t)-1 donne bien 15.
n : [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14] — 15 valeurs, de 0 à 14. Si tu obtiens 16 valeurs (jusqu'à 15), relis bien la consigne : l'indice ne doit pas dépasser 14, sinon yreelle[i+1] chercherait une valeur qui n'existe pas.
Fixer l'abscisse des vecteurs
- Comme dans la fiche précédente, on veut que tous les vecteurs partent de la même abscisse,
x = 0. - Écris
x = 0*t: cela engendre un tableau de 16 zéros, de la même longueur quet.
# TODO : abscisse constante et nulle, de même longueur que t
x = ____ * tIndice
Cette ligne ne produit aucun affichage par elle-même : elle prépare simplement le tableau x qui sera utilisé dans l'étape suivante pour tracer les flèches.
Tracer tous les vecteurs, automatiquement
- La fonction
plt.arrow(x_départ, y_départ, longueur_horizontale, longueur_verticale)trace une flèche. Ici : abscisse de départ0, ordonnée de départyreelle[i], longueur horizontale0, longueur verticaleyreelle[i+1]-yreelle[i]. - Place cet appel à
plt.arrowà l'intérieur d'une bouclefor i in n :, indentée (décalée vers la droite), pour qu'elle se répète automatiquement pour chaque valeur dei. - N'oublie pas les deux-points
:aprèsfor i in n, sinon Python renvoie une erreur. - Ajoute les paramètres de style
fc="k", ec="k", head_width=0.005, head_length=0.01pour des flèches noires bien visibles, puis fixe les limites des axes avecplt.ylim(-0.5, 0.1)etplt.xlim(-0.1, 0.1).
# TODO : boucle for qui trace un vecteur déplacement par tour de boucle
for i in ____ :
plt.arrow(__, yreelle[__], __, yreelle[____]-yreelle[__], fc="k", ec="k", head_width=0.005, head_length=0.01)
# TODO : fixe les limites des axes pour bien voir toutes les flèches
plt.ylim(____, ____)
plt.xlim(____, ____)
plt.show()Indice
Toute ligne indentée sous for i in n : fait partie de la boucle et se répète 15 fois, une pour chaque valeur de i allant de 0 à 14. La ligne plt.arrow(...) doit être décalée d'une tabulation (ou 4 espaces) par rapport au for.
Une colonne de 15 petites flèches noires empilées verticalement sur l'axe x = 0, chacune pointant vers le bas et de plus en plus longue à mesure que la bille accélère : ce sont les vecteurs déplacement successifs de la bille.
Pense-bête — boucle for et plt.arrow
| for i in n : | répète le bloc indenté pour chaque valeur de i dans n |
| yreelle[i] | le i-ème élément de la liste yreelle |
| yreelle[i+1] | l'élément suivant, juste après |
| arg 1, 2 | x et y de départ de la flèche |
| arg 3, 4 | longueur horizontale et verticale |
| fc, ec | couleur de fond et du contour |
Pas de Thonny sous la main ? Utilise Basthon
Ouvrir dans un nouvel onglet ↗Ctrl+V ou Cmd+V) le code copié avec les boutons « Copier le code » ci-dessus, puis appuie sur Entrée pour l'exécuter.