Fiche n°1 : Premiers graphes

Cette activité a pour but d’exploiter une chronophotographie de chute d’une bille.

Capacité numérique mise en œuvre : représenter les positions successives d’un système modélisé par un point lors d’une évolution unidimensionnelle ou bidimensionnelle à l’aide d’un langage de programmation.

1. Premiers tableaux

  • Sur la chronophotographie (photo imprimée ou vidéo avec logiciel de pointage sur l’écran), pointer les positions successives de la balle et relever les positions successives dans un tableau.
  • Dans l’éditeur (spyder ou jupyter), les positions successives de la bille vont être saisies au format python. Les manipulations ultérieures de ce tableau utilisent une bibliothèque de calcul numérique appelée numpy, une bibliothèque graphique appelée matplotlib, dont nous utiliserons la fonction pyplot. La première chose à faire est d’importer ces deux outils pour les rendre actives lors de notre programme. La pratique répandue est de les renommer à l’aide de noms plus courts. Cela donne :
In [0]:
# Précision : tout ce qui suit le signe # ne participe pas au script, il s'agit simplement de commentaires 
# ayant pour but d'éclairer le script ou la physique mise en jeu.
# pour plus de lisibilité, quand les lignes de script ou de commentaire sont trop longues pour être affichées 
# dans un écran, il arrivera que l'on passe à la ligne suivante dans le commentaire. 

import numpy as np # on importe le module numpy et on le renomme np, pour pouvoir l'appeler plus simplement dans la suite
import matplotlib.pyplot as plt # on importe le module matplotlib.pyplot et là aussi, on le renomme
  • Le tableau des positions mesurées sur la chronophotographie est alors créé à l’aide de la fonction np.array() en entrant les ordonnées successives de la balle comme suit :
In [0]:
# on définit un tableau du type array (ce qui permet de faire des opérations sur les tableaux) 
# le np. signifie qu'un tableau du type array est géré par le module numpy
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]) 

Remarque : Au passage, on voit qu’en langage Python, les virgules sont des séparateurs d’objets et les points sont les séparateurs des décimales. Il est possible de vérifier la construction du tableau via la commande print :

In [0]:
# on fait afficher le tableau ymes pour vérifier qu'il correspond bien
print('ymes:',ymes)
ymes: [  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]
  • La suite consiste à générer une base de temps, c’est-à-dire un tableau des valeurs de t. Ce tableau peut être construit de manière automatique, à l’aide de la fonction np.linspace. Les trois arguments principaux sont le début, la fin, le nombre de pas. Ici, l’expérience dure 0,6s et correspond à 16 points de mesure : il faut donc engendrer 16 instants entre de 0 à 0.25s (durée de l’expérience). On peut commander une impression dans la même cellule, pour vérifier, ce qui donne :
In [0]:
# on définit un tableau de 16 valeurs régulièrement espacées allant de 0 à 1/4
t=np.linspace(0,1/4,16)

 # on le fait afficher pour vérifier
print('t:',t)
t: [0.         0.01666667 0.03333333 0.05       0.06666667 0.08333333
 0.1        0.11666667 0.13333333 0.15       0.16666667 0.18333333
 0.2        0.21666667 0.23333333 0.25      ]

2. Premier graphe

Le tracé des positions mesurées en fonction du temps est généré grâce à matplotlib.pyplot :

In [0]:
# on fait tracer ymes en fonction de t, sans aucune option de tracé
plt.plot(t,ymes)
Out[0]:
[<matplotlib.lines.Line2D at 0x7f9b7d264080>]

Tout est ici automatique : Python gère les échelles, les couleurs, les axes.

3. Manipulation de tableau et tracé de la position calculée

Il faut maintenant calculer la position réelle à partir de l’ordonnée mesurée sur la chronophotographie. L’échelle de la photo étant de 2/100, numpy permet de multiplier directement toutes valeurs du tableau ymes par l’échelle et d’automatiser la conversion. Les nouvelles valeurs sont rassemblées dans le tableau yreelle. Les fonctions utilisées ensuite servent à « habiller » davantage le graphe : étiquette pour l’abscisse et l’ordonnée, graduations, légende et titre.

In [0]:
yreelle=ymes*2/100                       # on convertit ymes en yreelle
plt.plot(t,yreelle,'ro',label="y=f(t)")  # on fait tracer yreelle en fonction du temps, 
                                         # le tracé étant des ronds (o) rouges (r), avec un label pour y
plt.xlabel("temps")        # on place un label sous l'axe des abscisses
plt.ylabel("yreelle")      # on place un label à côté l'axe des ordonnées
plt.grid()                 # on place une grille
plt.legend()               # on fait tracer toutes les légendes et les options de tracé
plt.title("chute libre")   # on place un titre au dessus du graphe
plt.show()                 # on montre l'ensemble

Remarque : la commande plt.plot peut être enrichie de divers arguments (comme ici avec ro = cercle rouge) :

  • Couleur : r (red), k (black), b (blue), y (yellow), g (green)
  • Marqueur : o (gros point), - (ligne), . (pointillé), x (croix), s (square), v (triangle)