Objectifs

• Lire et compléter un court programme Python : variables, listes, boucle for, fonction.
• Faire calculer une grandeur physique (vitesse, masse volumique…) pour toute une série de mesures.
• Tracer un graphique avec matplotlib et modéliser des mesures par une droite.
• Comprendre le principe d'une acquisition de mesures avec un capteur et une carte programmable.

1. Les briques de base de Python

Variables et calculs

Une variable reçoit une valeur avec le signe = (affectation). Les opérations s'écrivent + - * / et la puissance **.

m = 27.0        # masse en g
V = 10.0        # volume en mL
rho = m / V     # masse volumique en g/mL
print("masse volumique :", rho, "g/mL")

Le programme affiche masse volumique : 2.7 g/mL. On reconnaît la relation \( \rho = \dfrac{m}{V} \) : ici \( \rho = \dfrac{27{,}0}{10{,}0} = 2{,}7 \ \text{g/mL} \) (valeur de l'aluminium). Le texte après # est un commentaire, ignoré par Python.

Listes et boucles

Une liste range plusieurs valeurs : t = [0, 0.5, 1.0, 1.5]. On accède à un élément par son indice, qui commence à 0 : t[0] vaut 0, t[2] vaut 1.0. La fonction len(t) donne le nombre d'éléments (ici 4).

La boucle for répète des instructions. range(n) produit les entiers de 0 à \( n - 1 \).

for i in range(3):
    print(i)

Ce programme affiche 0, puis 1, puis 2. Les instructions répétées sont décalées (indentation) : c'est ce décalage qui indique à Python ce qui est dans la boucle.

Fonctions

def vitesse(d, t):
    return d / t

print(vitesse(100, 12.5))   # affiche 8.0

Une fonction regroupe un calcul qu'on réutilise. Ici \( v = \dfrac{d}{t} = \dfrac{100}{12{,}5} = 8{,}0 \ \text{m/s} \) pour un coureur qui parcourt 100 m en 12,5 s.

2. Faire des calculs sur une série de mesures

Exemple résolu

Mesures : t = [0, 0.5, 1.0, 1.5] (en s) et x = [0, 1.2, 2.4, 3.6] (en m). On veut la vitesse moyenne entre deux relevés successifs : \[ v_i = \frac{x_{i+1} - x_i}{t_{i+1} - t_i}. \] Cherche d'abord ce que le programme va afficher.

t = [0, 0.5, 1.0, 1.5]
x = [0, 1.2, 2.4, 3.6]
for i in range(len(t) - 1):
    v = (x[i+1] - x[i]) / (t[i+1] - t[i])
    print("v =", round(v, 2), "m/s")

3. Tracer un graphique et modéliser

Modéliser, c'est trouver une relation mathématique simple (ici une droite) qui décrit au mieux les points de mesure. Pour une droite \( U = aI + b \), Python calcule \( a \) et \( b \) avec la fonction polyfit de la bibliothèque numpy (le « 1 » signifie : polynôme de degré 1, une droite).

Exemple résolu

import numpy as np
import matplotlib.pyplot as plt

I = [0, 0.01, 0.02, 0.03, 0.04]   # intensité en A
U = [0, 1.0, 2.0, 3.1, 4.0]       # tension en V

a, b = np.polyfit(I, U, 1)        # modèle U = a*I + b
print("a =", round(a), "b =", round(b, 2))

plt.plot(I, U, "o", label="mesures")
plt.plot(I, [a*i + b for i in I], label="modèle")
plt.xlabel("I (A)")
plt.ylabel("U (V)")
plt.legend()
plt.show()

Cherche d'abord : à quoi ressemble le graphique et que représente \( a \) ?

Joue avec le modèle : fais varier \( R \) et observe la pente de la droite \( U = R \times I \) (ici \( I \) en ampères sur l'axe horizontal).

4. L'acquisition de mesures

Une chaîne d'acquisition comprend :

• un capteur (température, lumière, tension…) qui transforme une grandeur physique en signal électrique ;
• une carte programmable (microcontrôleur) qui lit ce signal à intervalles réguliers et le convertit en nombre ;
• un programme qui enregistre les valeurs dans des listes, puis les affiche ou les trace.

flowchart LR
  A[Grandeur physique] --> B[Capteur]
  B --> C[Carte programmable]
  C --> D[Programme Python]
  D --> E[Listes de mesures]
  E --> F[Graphique et modele]

Exemple résolu

Voici la structure d'une boucle d'acquisition. La fonction lire_capteur() est un nom choisi pour l'exemple : elle dépend de la carte utilisée et renvoie la mesure du capteur.

import time

temps = []
temperatures = []
for k in range(60):                  # 60 mesures
    temps.append(k * 10)             # une mesure toutes les 10 s
    temperatures.append(lire_capteur())
    time.sleep(10)                   # attendre 10 s

Erreurs fréquentes

• Écrire une virgule décimale (2,7) au lieu d'un point (2.7).
• Oublier que les indices d'une liste commencent à 0.
• Oublier l'indentation dans une boucle ou une fonction.
• Sortir de la liste dans une boucle (IndexError).
• Tracer un graphique sans noms d'axes ni unités.

Récapitulatif

• Variables, listes, boucles for et fonctions suffisent pour faire tous les calculs répétitifs d'un TP.
• matplotlib trace les mesures ; np.polyfit(x, y, 1) donne la droite modèle \( y = ax + b \).
• Le coefficient du modèle a un sens physique (résistance, vitesse…) et une unité.
• Une acquisition associe capteur, carte programmable et programme qui range les mesures dans des listes.