📇 Plan
Avant-propos
1. Introduction
1.1. Programme
1.2. Définitions
1.3. Représentation d'un vecteur avec Python2. Vecteurs vitesse d’un système modélisé par un point lors d’un mouvement unidimensionnel
2.1. Mouvement horizontal uniforme
2.2. Mouvement vertical accéléré3. Vecteurs vitesse d’un système modélisé par un point lors d’un mouvement bidimensionnel
3.1. Mouvement circulaire uniforme
3.1.1. Préliminaire optionel
3.1.2. Valeurs des positions fournies
3.1.3. Valeurs des positions calculées
3.2. Mouvement paraboliqueLicence
💡 Présentation
Le but de ce document est de fournir quelques éléments pour aider à contruire des supports de cours adaptés aux parties du programme faisant référence aux capacités numériques. Vous pouvez l'utiliser tel quel, ou vous en inspirer pour créer vos propres supports de cours, exercices, devoirs (que vous pourrez ensuite partager sur ce site).
📝 Collaboration
Vous pouvez participer à ce document ici.
🏷️ Licence
Ce document peut-être partagé et adapté. Mais toute version du document doit conserver la même licence, y faire clairement référence, préciser les éventuelles modifications apportées et créditer clairement le ou les auteur(s). Utilisation commerciale non aurorisée. Plus d'information en fin de document.
📓 Extraits du programme :
Variation du vecteur vitesse Capacité numérique : représenter des vecteurs variation de vitesse d’un système modélisé par un point lors d’une évolution unidimensionnelle ou bidimensionnelle à l’aide d’un langage de programmation.
🐍 Le langage de programmation conseillé est le langage Python.
✔️ Mouvement uniforme
XXXXXXXXXXXXXXXXXXXXX
✔️ XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
✔️ XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
🌱 La bibliothèque matplotlib
# On importe les bibliothèques et les modules nécessaires
# La bibliothèque 'matplotlib' est une bibliothèque qui permet de tracer et visualiser des données sous formes de graphiques
# Voir : https://matplotlib.org/tutorials/introductory/usage.html
import matplotlib.pyplot as plt
plt.title('Positions successives d\'un système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([0, 1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
Soit un système assimilable à un point P
qui se déplace sur un plan horizontal à une vitesse constante V0
, avec T
l'intervalle de temps entre deux positions successives.
# On reprend le code précédent et on place 5 points un par un
# après avoir calculé "à la main" les différentes positions
# avec de l'intervalle de temps choisi (T = 100 ms soit 0.1 s)
# et la vitesse V0 = 2 m.s-1
# P1 en X1 = 0
# P2 en X2 = X1 + V0*T = 0 + 2*0.1 = 0.2
# P3 en X3 = X2 + V0*T = 0.2 + 0.2 = 0.4
# ...
import matplotlib.pyplot as plt
# Valeurs en abscisse
X1 = 0
X2 = 0.2
X3 = 0.4
X4 = 0.6
X5 = 0.8
# Valeurs en ordonnée (on place le plan sur l'origine)
Y1 = Y2 = Y3 = Y4 = Y5 = 0
# On place le premier point
# marker='o' pour un rond, voir https://matplotlib.org/api/markers_api.html#module-matplotlib.markers
# color='r' pour du rouge, voir https://matplotlib.org/tutorials/colors/colors.html#sphx-glr-tutorials-colors-colors-py
plt.plot(X1, Y1, marker='o', color='r')
# Puis les suivants
plt.plot(X2, Y2, marker='o', color='r')
plt.plot(X3, Y3, marker='o', color='r')
plt.plot(X4, Y4, marker='o', color='r')
plt.plot(X5, Y5, marker='o', color='r')
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([0, 1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
🌱 Les listes
# Même code que précédemment mais en écrivant les points sour forme de 'listes'
# Le code est ainsi plus court et plus souple à manipuler
import matplotlib.pyplot as plt
# On définit les valeurs avec des listes
# Voir : https://docs.python.org/fr/3/tutorial/introduction.html#lists
# Valeurs en abscisse
X = [0, 0.2, 0.4, 0.6, 0.8]
# Valeurs en ordonnée
Y = [0, 0, 0, 0, 0]
# On trace les points
# IMPORTANT
# Précédement, nous avons placé plusieurs points sur un même graphique indépendamment les uns des autres.
# Ainsi ils ne sont pas relié entre eux. Si on fait la même chose avec des listes, le module 'plot'
# va relier les points entre eux. Pour que les points ne soient pas reliés, il faut utiliser
# 'scatter' à la place de 'plot'.
plt.scatter(X, Y, marker='o', color='r')
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([0, 1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
🌱 La boucle for
# On calcule les 5 premiers points un par un à l'aide d'une boucle 'for'
# Voir : https://wiki.python.org/moin/ForLoop
# On sait que l'espace entre deux points est de 0.2 (V0*T)
import matplotlib.pyplot as plt
# On définit les constantes
V0 = 2 # vitesse en m.s-1
T = 0.1 # temps entre deux positions successives en s
# n prend les valeurs 0, 1, 2, 3 ,4
# La première valeur de 'range' est la valeur de départ, la deuxième celle de
# fin et la troisième le pas.
# Remarque 1 : par définition, la valeur de fin est exclue - on va donc jusqu'à 5
# pour afficher 0.8
# Remarque 2 : 'range' ne manipule que des entiers
for n in range(0, 5, 1):
X = n*V0*T
Y = 0
plt.plot(X, Y, marker='o', color='r')
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([0, 1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
🌱 La bibliothèque numpy
et les fonctions arange()
et scatter
# Cette version du code permet de générer automatiquement les points en fonction des constantes
# Il suffit alors de modifier les valeurs des constantes pour changer les points
# La bibliothèque 'numpy' permet de manipuler des fonctions mathématiques comme 'arange'
# Voir : https://docs.scipy.org/doc/numpy/user/quickstart.html
import matplotlib.pyplot as plt
import numpy as np
# On définit les constantes
V0 = 2 # vitesse en m.s-1
T = 0.1 # intervalle de temps en s
# Valeurs en abscisse
# On utilise la fonction 'arange' de numpy pour créer une liste de valeurs
# Voir : https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.arange.html
# La première valeur est la valeur de départ, la deuxième celle de fin et la troisième
# le pas.
# Remarque 1 : par définition, la valeur de fin est exclue - on va donc jusqu'à 1 pour
# afficher 0.8
# Remarque 2 : contrairement à 'range', 'arange' accepte des réels
X = np.arange(0, 1, V0*T)
# Valeurs en ordonnée
# On utilise la fonction 'len' de Python pour créer une liste remplie '0' de même longueur
# que la liste X (len(X))
# Voir : https://docs.python.org/3/library/functions.html?highlight=len#len
Y = [0]*len(X)
# On trace les points
plt.scatter(X, Y, marker='o', color='r')
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([0, 1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
🌱 La boucle while
et la fonction floor()
# On ajoute un paramètre : la longeur du parcours L
# On calcule alors les points jusqu'à ce que la distance parcourue soit inférieure ou égale à L
# Pour cela on utilise la boucle 'while'
# Voir : https://wiki.python.org/moin/WhileLoop
import matplotlib.pyplot as plt
import numpy as np
# On définit les constantes
L = 4 # longueur du pourcours en m
V0 = 2 # vitesse en m.s-1
T = 0.1 # intervalle de temps en s
# On calcule le nombre de distances parcourues pendant un l'intervalle de temps T dans la longueur
# du parcours L. La fonction 'floor' retourne l'entier le plus gand. Par exemple, 'floor(3,4)' donne 3.
# On obtient alors le nombre de positions moins une (problème des intervalles et des poteaux).
# Mais, en fixant le début de l'incrémentation de la boucle 'while' à 0, on ajoute de point manquant.
# Ainsi, quelques soient les valeurs choisies, il n'y a pas de position au-dela de L.
# Voir : https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.floor.html
nb_inter = np.floor(L / (V0*T))
a = 0
while a <= nb_inter:
plt.plot(a*V0*T, 0, marker='o', color='r')
a += 1 # on ajoute 1 à la variable a (a = a + 1)
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([0, L+1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
# on ajoute 1 à L pour visualiser clairement le dernier point
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
🌱 La méthode append()
# Plutot que de tracer directement les points depuis la boucle, on les place d'abord
# dans des listes puis on les trace ensuite. Cela peut paraitre inutile ici, et
# c'est vrai, mais cette étape sera très pratique plus tard lorsqu'il sera necessaire
# de manipuler les valeurs. Comme, par exemple, lors de la construction de vecteurs
# vitesse.
import matplotlib.pyplot as plt
import numpy as np
# On définit les constantes
L = 4 # longueur du pourcours en m
V0 = 2 # vitesse en m.s-1
T = 0.1 # intervalle de temps en s
nb_inter = np.floor(L / (V0*T))
X = [] # on crée une liste vide
a = 0
while a <= nb_inter:
X.append(a*V0*T) # 'append()' ajoute une valeur à la fin de la liste X
a += 1
Y = [0]*len(X) # voir 2.6
# On trace les points
plt.scatter(X, Y, marker='o', color='r')
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([0, L+1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
# on ajoute 1 à L pour visualiser clairement le dernier point
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
Soit un système assimilable à un point P
qui se deplace le long d'un cercle de rayon R
à une vitesse constante de tpm
tours par minute, avec T
l'intervalle de temps entre deux positions successives.
🌱 La fontion linspace()
# Le code ci-dessous permet de tracer un cercle de rayon `R` point par point et de choisir le nombre de points.
import matplotlib.pyplot as plt
import numpy as np # nécessaire pour 'linspace', 'pi', 'cos' et 'sin'
R = 4 # rayon en m
nb_points = 12 # nombre de points
# On crée une liste de valeurs d'angles en prenant 'nb_point' entre 0 et 2*pi grâce à la fonction 'linspace'.
# Voir : https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html
# La première valeur est la valeur de départ, la deuxième celle de fin et la troisième le nombre de valeurs.
angles = np.linspace(0, 2*np.pi, nb_points, endpoint=False) # 'endpoint=False' on ne tient pas compte de la
# dernière valeur pour ne pas tracer deux fois l'origine
# On place le centre du cercle
plt.scatter(0, 0, marker='o', color='k')
# On trace les points
plt.scatter(R*np.cos(angles), R*np.sin(angles))
plt.axis('equal') # même échelle pour les deux axes
plt.title('Points selon un cercle') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([-R-1, R+1, -R-1, R+1]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
import matplotlib.pyplot as plt
R = 4 # rayon en m
tpm = 10 # tours par minute
T = 0.5 # temps entre deux positions successives en s
# On calcule "à la main" les cinq premières positions.
# Les valeurs choisies permettent de travailler avec les
# angles 0, 30, 60, 90... et les valeurs de leurs cos et
# sin (rappels de mathématiques).
# Angle balayé en un temps T : alpha = (360 * tpm * T) / 60 = 30 degres
# Ainsi X1 = R*cos(0) = 4 et Y1 = R*sin(0) = 0
# Puis X2 = R*cos(alpha) = 3.46 et Y2 = R*sin(alpha) = 2
# Et X3 = R*cos(2*alpha) = 2 et Y3 = R*sin(2*alpha) = 3.46
# ...
# Valeurs en abscisse
X = [4, 3.46, 2, 0, -2]
# Valeurs en ordonnée
Y = [0, 2, 3.46, 4, 3.47]
# On place le centre du cercle
plt.scatter(0, 0, marker='o', color='k')
# On trace les points
plt.scatter(X, Y, marker='o', color='r')
plt.axis('equal') # même échelle pour les deux axes
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([-8, 8, -8, 8]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
import matplotlib.pyplot as plt
import numpy as np
R = 4 # rayon en m
tpm = 10 # tours par minute
T = 0.1 # temps entre deux positions successives en s
nb_pos = 50 # nombre de positions
# Angle balayé en un temps T
alpha = (2*np.pi * tpm * T) / 60
# On crée des listes à l'aide d'une boucle 'for'
X = [] # initialisation de la liste X
Y = [] # initialisation de la liste Y
for n in range(0, nb_pos, 1):
X.append(R*np.cos(n*alpha))
Y.append(R*np.sin(n*alpha))
# On trace les points
plt.scatter(X, Y, marker='o', color='r')
# On place le centre du cercle
plt.scatter(0, 0, marker='o', color='k')
plt.axis('equal') # même échelle pour les deux axes
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.axis([-8, 8, -8, 8]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
Ouverture sur les programmes de Première et de Terminale avec une trajectoire parabolique.
# Pour modéliser les lois de Newtons il suffit alors d'adapter les valeurs de X et de Y
import matplotlib.pyplot as plt
import numpy as np
nb_points = 20 # nombre de points
# On crée les listes
X = np.linspace(-1, 1, nb_points)
Y = X**2
# On trace les points
plt.scatter(X, Y, marker='o', color='g')
plt.axis('equal') # même échelle pour les deux axes
plt.title('Positions successives du système') # titre du graphique
plt.xlabel('X (en m)') # légende axe X
plt.ylabel('Y (en m)') # légende axe Y
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
import matplotlib.pyplot as plt
import numpy as np
# On définit les constantes
L = 4 # longueur du pourcours en m
V0 = 2 # vitesse en m.s-1
T = 0.1 # intervalle de temps en s
# on définit les constantes
L1 = 10.0 # longueur du plan horizontal en m
v0 = 0.5 # vitesse initiale en m.s-1
x = np.arange(0, L1, v0*2) # v0 * 1 - distance parcourue en une seconde
z = [0]*len(x)
# vecteurs
plt.quiver(0, 0, 0.5, 0, units='dots', angles='xy', scale_units='xy', scale=1, width=2)
plt.quiver(1, 0, 0.5, 0, units='dots', angles='xy', scale_units='xy', scale=1, width=2)
plt.quiver(2, 0, 0.5, 0, units='dots', angles='xy', scale_units='xy', scale=1, width=2)
# graphique
mpl.plot(x, z, "o", label="position du point au cours du temps")
plt.title('GRAPHIQUE') # titre du graphique
plt.xlabel('x (en m)') # légende axe x
plt.ylabel('y (en m)') # légende axe y
plt.axis([0, L+1, -1, 1]) # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True) # afficher une grille
plt.show() # afficher le graphique
import matplotlib.pyplot as mpl
import numpy as np
deltaT = 0.1 # intervalle de temps entre deux positions en s - 100 ms
t = np.arange(0, 10, deltaT)
g = 9.81
L1 = 10.0 # longueur du plan horizontal en m
V0 = 1.5 # vitesse initiale en m.s-1
X = V0*t
Y = -(g/2)*t**2
ax = mpl.axes()
# vecteur vitesse en position 1 (t = 0)
t1 = 0
X1 = V0*t1
Y1 = -(g/2)*t1**2
Vx1 = V0 / 10 # on divide par 10 pour une question d'echelle
Vy1 = -g*t1 / 10 # on divide par 10 pour une question d'echelle
#ax.arrow(X1, Y1, Vx1, Vy1, width=0.0001, head_width=0.03, head_length=0.01, fc='k', ec='k', length_includes_head=True)
# quiver doc : https://matplotlib.org/api/_as_gen/matplotlib.pyplot.quiver.html
mpl.quiver(X1, Y1, Vx1, Vy1, units='dots', angles='xy', scale_units='xy', scale=1, width=1.5, linestyle=':')
# vecteur vitesse en position 2 (t = 0.1)
t2 = 0.1
X2 = V0*t2 # position du point 2 selon x
Y2 = -(g/2)*t2**2 # position du point 2 selon y
Vx2 = V0 / 10
Vy2 = -g*t2 / 10
#ax.arrow(X2, Y2, Vx2, Vy2, width=0.0001, head_width=0.03, head_length=0.01, fc='k', ec='k', length_includes_head=True)
mpl.quiver(X2, Y2, Vx2, Vy2, units='dots', angles='xy', scale_units='xy', scale=1, width=1.5)
# vecteur vitesse en position 3 (t = 0.2)
t3 = 0.2
X3 = V0*t3
Y3 = -(g/2)*t3**2
Vx3 = V0 / 10
Vy3 = -g*t3 / 10
#ax.arrow(X3, Y3, Vx3, Vy3, width=0.0001, head_width=0.03, head_length=0.01, fc='k', ec='k', length_includes_head=True)
mpl.quiver(X3, Y3, Vx3, Vy3, units='dots', angles='xy', scale_units='xy', scale=1, width=1.5)
# vecteur acceleration en position 2 (X2, Y2)
t2 = 0.1
Ax2 = Vx3 - Vx1
Ay2 = Vy3 - Vy1
#mpl.arrow(X2, Y2, Ax2, Ay2, width=0.0001, head_width=0.03, head_length=0.01, fc='r', ec='r', length_includes_head=True)
mpl.quiver(X2, Y2, Vx1, Vy1, units='dots', angles='xy', scale_units='xy', scale=1, width=1.5, color='silver')
mpl.quiver(X2, Y2, Vx3, Vy3, units='dots', angles='xy', scale_units='xy', scale=1, width=1.5, color='silver')
mpl.quiver(X2+Vx1, Y2, Ax2, Ay2, units='dots', angles='xy', scale_units='xy', scale=1, width=1.5, color='silver')
mpl.quiver(X2, Y2, Ax2, Ay2,linestyle='--', units='dots', angles='xy', scale_units='xy', scale=1, width=1.5, color='red')
# graphique
mpl.xlim(-1,1)
mpl.ylim(-2, 0.1)
mpl.plot(X, Y, "o", label="position du point au cours du temps")
mpl.title("Trajectoire")
mpl.legend()
#mpl.grid()
mpl.show()
Ce document est sous Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.
Auteur : Laurent Abbal [laurent@abbal.com]