Ce niveau se travaille seul, à votre rythme, dans l'ordre. Chaque cadre de code est un vrai Python : on y tape du code, on l'exécute avec ▶ Exécuter (ou Ctrl + Entrée sur un clavier), le résultat s'affiche juste en dessous.
Rien à installer : Python se télécharge dans la tablette à la première ouverture. Comptez une minute la première fois, quelques secondes ensuite.
On ne peut rien casser : ↺ Code de départ remet le programme d'origine.
Une erreur n'est pas une faute. Python indique la ligne et la raison : apprendre à lire ce message fait partie du travail.
Bloqué ? Le bouton 💡 Aide donne un indice à la fois. La solution complète s'ouvre après un premier essai.
Chaque exercice révise une notion du cours : le bouton ⓘ Rappel de cours la rappelle.
Python, une calculatrice
Avant d'écrire des programmes, on utilise Python comme une calculatrice. La console attend une instruction après l'invite >>>, l'exécute et affiche aussitôt le résultat.
À retenir
Les opérations : +-* (multiplier) / (diviser) et ** (puissance) : 2³ s'écrit 2 ** 3.
La division / donne toujours un nombre à virgule : 8 / 2 donne 4.0.
Le séparateur décimal est le point : 0,68 s'écrit 0.68.
L'écriture scientifique utilise e, qui se lit « fois 10 puissance » : 3,00 × 10⁸ s'écrit 3.00e8, et 1,0 × 10⁻¹² s'écrit 1.0e-12.
Comme sur la calculatrice, la multiplication passe avant l'addition, et les parenthèses fixent l'ordre des calculs :
>>> 2 + 3 * 4
14
>>> (2 + 3) * 4
20
1.1 Premier contact
Tapez des calculs dans la console, validez avec Entrée. Essayez les opérations de l'encadré, puis répondez au quiz : vous pouvez vérifier chaque réponse dans la console.
Que répond Python ?
7 / 2
Python affiche 3.5, avec un point : c'est la seule notation qu'il comprenne.
2 ** 3
** est la puissance : 2³ = 2 × 2 × 2 = 8. Le résultat est un entier, car aucun des deux nombres n'a de virgule.
10 - 4 / 2
La division passe avant la soustraction : 4 / 2 = 2.0, puis 10 − 2.0 = 8.0. Il y a une virgule, car la division donne toujours un nombre à virgule.
(10 - 4) / 2
Les parenthèses passent en premier : 10 − 4 = 6, puis 6 / 2 = 3.0.
3e2
3e2 se lit « 3 fois 10 puissance 2 », soit 300. Une valeur écrite avec e est toujours un nombre à virgule : 300.0.
10 ** -3
10⁻³ = 1 / 1000 = 0,001. Une puissance négative ne rend pas le nombre négatif : elle le rend petit.
1.2 La célérité d'un son
Rappel de cours — Onde périodique
Une onde périodique se reproduit identique à elle-même à intervalles de temps réguliers.
f = \dfrac{1}{T} \qquad\qquad c = \dfrac{\lambda}{T} = \lambda \times f
Grandeur
Nom
Unité
T
période : durée d'un motif
s
f
fréquence : nombre de motifs par seconde
Hz
\lambda
longueur d'onde : distance parcourue par l'onde pendant une période
m
c
célérité : vitesse de propagation de l'onde
m·s⁻¹
Dans l'air à 20 °C, un son se propage à environ 340 m·s⁻¹.
Au laboratoire, on mesure la longueur d'onde d'un son de fréquence 500 Hz : λ = 0,68 m.
Calculer dans la console la célérité c de ce son.
Calculer sa période T.
Un son de 440 Hz se propage à la même célérité. Calculer sa longueur d'onde en une seule ligne, sans recopier le résultat de la question 1.
c = 340 m·s⁻¹ et T = 0,002 s = 2 ms. Pour la question 3, Python enchaîne les opérations de gauche à droite : 0.68 * 500, puis la division par 440. λ ≈ 0,77 m.
1.3 Des nombres minuscules
Rappel de cours — Intensité sonore
L'intensité sonore est la puissance sonore reçue par unité de surface :
I = \dfrac{P}{S}
Grandeur
Nom
Unité
I
intensité sonore
W·m⁻²
P
puissance sonore reçue
W
S
aire de la surface qui reçoit le son
m²
L'oreille perçoit des sons à partir de I_0 = 1{,}0 \times 10^{-12}\ \mathrm{W\cdot m^{-2}}, le seuil d'audibilité.
Dans une salle de classe bruyante, l'intensité sonore vaut I = 1,0 × 10⁻⁵ W·m⁻².
Combien de fois l'intensité sonore de la salle dépasse-t-elle le seuil d'audibilité ? Faire le calcul dans la console.
Le résultat affiché est-il exactement celui que vous attendiez ? Proposer une explication.
Voir une solution
>>> 1.0e-5 / 1.0e-12
10000000.000000002
L'intensité vaut dix millions de fois le seuil d'audibilité (10⁷). Le 2 tout au bout ne vient pas de vous : Python stocke les nombres en binaire, avec environ 16 chiffres significatifs, et le dernier peut être légèrement faux. En physique, on arrondit de toute façon bien avant.
Piège à éviter : 10e-12 ne vaut pas 10⁻¹², mais 10 × 10⁻¹² = 10⁻¹¹.
Ranger des valeurs dans des variables
Retaper 340 à chaque calcul est fastidieux et source d'erreurs. Une variable garde une valeur sous un nom. On passe aussi de la console au script : plusieurs lignes, exécutées de haut en bas, d'un seul coup.
À retenir
c = 340affecte la valeur 340 à la variable c. Le signe = n'est pas une égalité mathématique : il signifie « ranger dans ».
Python calcule d'abord ce qui est à droite du =, puis range le résultat dans la variable de gauche.
Un nom de variable commence par une lettre, sans espace ni accent : f_E, delta_f, lam. Python distingue majuscules et minuscules : c et C sont deux variables différentes.
Une trentaine de mots réservés du langage ne peuvent pas servir de nom : lambda, if, for, in, def, import… C'est pourquoi on écrit lam pour λ.
Dans un script, rien ne s'affiche sans print(...).
Tout ce qui suit # est un commentaire, ignoré par Python : on y note les unités.
c = 340 # célérité du son dans l'air, en m/s
f = 500 # fréquence, en Hz
lam = c / f # longueur d'onde, en m
print(lam)
2.1 Prédire, puis modifier
Une corde de guitare vibre à la fréquence fondamentale f = 500 Hz. Ses harmoniques ont pour fréquences 2f, 3f, 4f…
f = 500
f = f * 2
print(f)
Qu'affiche ce programme ?
La deuxième ligne se lit de droite à gauche : Python calcule f * 2 avec l'ancienne valeur (500 × 2 = 1000), puis range 1000 dans f. L'ancienne valeur est perdue. En mathématiques, « f = 2f » n'aurait de solution que f = 0 ; en Python, c'est une instruction parfaitement normale. Un seul print, donc un seul affichage.
Exécuter le programme pour vérifier votre prédiction.
Le modifier pour qu'il affiche la fréquence de l'harmonique de rang 3, en ne changeant qu'un seul caractère.
2.2 Le décalage Doppler, avec et sans approximation
L'effet Doppler est la modification de la fréquence perçue lorsque l'émetteur et le récepteur sont en mouvement l'un par rapport à l'autre. Le décalage Doppler est l'écart entre la fréquence reçue et la fréquence émise :
\Delta f = f_R - f_E
Pour un émetteur qui s'approche, à la vitesse v, d'un récepteur fixe :
f_R = f_E \times \dfrac{c}{c - v}
Si la vitesse v est faible devant la célérité c, on retient l'expression approchée :
\Delta f \approx f_E \times \dfrac{v}{c}
Grandeur
Nom
Unité
f_E
fréquence émise
Hz
f_R
fréquence reçue
Hz
\Delta f
décalage Doppler
Hz
v
vitesse de l'émetteur par rapport au récepteur
m·s⁻¹
c
célérité de l'onde
m·s⁻¹
Comme au TP5, un émetteur d'ultrasons de fréquence fE = 40 000 Hz, fixé sur une petite voiture, roule vers le récepteur à v = 2,0 m·s⁻¹. Les ultrasons se propagent dans l'air à c = 340 m·s⁻¹.
Compléter la ligne f_R = …… avec l'expression exacte, puis la ligne delta_f = …….
Compléter la ligne delta_f_approx = …… avec l'expression approchée.
Exécuter. L'approximation est-elle justifiée ici ? Remplacer v par 100 m·s⁻¹ et conclure.
Voir une solution
f_R = f_E * c / (c - v)
delta_f = f_R - f_E
delta_f_approx = f_E * v / c
Pour v = 2,0 m·s⁻¹ : 236,7 Hz (exact) et 235,3 Hz (approché), moins de 1 % d'écart : l'approximation est justifiée. Pour v = 100 m·s⁻¹ : 16 667 Hz contre 11 765 Hz, près de 30 % d'écart : v n'est plus faible devant c. Intérêt des variables : pour une autre vitesse, on ne change qu'une ligne.
2.3 Constructives ou destructives ?
Rappel de cours — Interférences
Deux sources S1 et S2 émettent des ondes de même fréquence. En un point M, la différence de marche est l'écart entre les distances parcourues par les deux ondes :
\delta = S_2M - S_1M
Interférences constructives
Ondes en phase, amplitude maximale : \delta = k \times \lambda, avec k entier.
Interférences destructives
Ondes en opposition de phase, amplitude minimale : \delta = \left(k + \tfrac{1}{2}\right) \times \lambda.
Grandeur
Nom
Unité
\delta
différence de marche au point M
m
\lambda
longueur d'onde
m
k
nombre entier (positif, négatif ou nul)
sans unité
Méthode
On calcule \dfrac{\delta}{\lambda}. Un nombre entier : constructives. Un entier plus un demi : destructives.
Deux ondes lumineuses de longueur d'onde λ = 500 nm arrivent en un point M. Les distances parcourues sont S1M = 2 000 nm et S2M = 3 250 nm.
Écrire un script qui calcule et affiche le rapport δ / λ.
Les interférences en M sont-elles constructives ou destructives ?
En ne modifiant qu'une ligne, trouver ce qui se passe en un point où S2M = 3 000 nm.
Commencez par ranger λ, S1M et S2M dans trois variables, toutes en nm. Attention : lambda est un mot réservé.
Rangez la différence de marche dans une variable, par exemple delta, calculée à partir des deux distances.
Le rapport s'obtient en divisant delta par la variable qui contient λ. Rangez-le, par exemple dans rapport, puis affichez-le.
Voir une solution
# toutes les longueurs en nm
lam = 500
S1M = 2000
S2M = 3250
delta = S2M - S1M
rapport = delta / lam
print(rapport)
Python affiche 2.5 : destructives. Avec S2M = 3000, le rapport vaut 2.0 : constructives. Toutes les longueurs sont dans la même unité, le nm, donc le rapport est juste ; mélanger des m et des nm donnerait un résultat faux, sans aucun message d'erreur.
Types de valeurs et affichage
Un nombre seul, c'est peu lisible. Un résultat de physique s'affiche avec son nom, sa valeur arrondie et son unité. Pour y arriver, il faut d'abord distinguer les nombres des textes.
À retenir
Chaque valeur a un type : int (entier : 340), float (nombre à virgule : 340.0), str (texte : '340'). type(x) donne le type de x.
Un texte s'écrit entre guillemets, simples ou doubles : 'Hz' ou "Hz". Sans guillemets, Python cherche une variable de ce nom.
Deux textes s'ajoutent bout à bout : '40' + '00' donne '4000'. Un texte et un nombre ne s'ajoutent pas : erreur.
print affiche plusieurs morceaux séparés par des virgules, en mettant une espace entre eux.
round(x, 2) arrondit x à 2 chiffres après la virgule. Comme print et type, c'est une fonction intégrée à Python : pas besoin de bibliothèque.
c = 340
T = 1 / 440
print('c =', c, 'm/s') # affiche : c = 340 m/s
print('T =', round(T, 5), 's') # affiche : T = 0.00227 s
3.1 Les types dans la console
Tapez ces instructions une à une dans la console et observez : type(340), type(340.0), type('340'), 340 + 1, '340' + '1', puis '340' + 1. La dernière provoque une erreur : lisez la première ligne du message, c'est celui de Python.
Voir une solution
340 est un int, 340.0 un float, '340' un str : ce n'est pas un nombre, mais trois caractères. '340' + '1' colle les deux textes : '3401'. '340' + 1 mélange un texte et un nombre : Python répond par une TypeError.
3.2 Prédire l'affichage
Pour chaque instruction, prédire ce qu'affiche Python. Vérifiez dans la console de l'exercice 3.1 si vous hésitez.
Qu'affiche Python ?
type(2.5)
2.5 a une virgule (un point, en Python) : c'est un float. Python l'écrit <class 'float'>.
type('2.5')
Les guillemets en font un texte, un str, même s'il ressemble à un nombre.
type(6 / 3)
La division / donne toujours un nombre à virgule : 6 / 3 vaut 2.0, un float.
print('f =', 500, 'Hz')
print affiche chaque morceau, sans les guillemets, en plaçant une espace entre deux morceaux.
round(3.14159, 2)
2 chiffres après la virgule : 3.14. Le chiffre suivant, 1, est inférieur à 5 : on arrondit vers le bas.
'Hz' + 500
Un texte et un nombre ne s'ajoutent pas : TypeError. Pour afficher les deux, on les sépare par une virgule dans print.
3.3 S'entraîner à afficher
Le programme calcule la période et la longueur d'onde d'un son de 500 Hz. Ajouter trois lignes print pour qu'il affiche exactement :
f = 500 Hz
T = 0.002 s
lambda = 0.68 m
Chaque ligne affichée a trois morceaux : un texte, une valeur, une unité.
Le texte 'f =' s'écrit entre guillemets ; la valeur est le nom de la variable, sans guillemets.
Dans un texte entre guillemets, on peut écrire lambda : seul un nom de variable ne le peut pas.
Une fente de largeur a (ou un fil de diamètre a), éclairée par une lumière de longueur d'onde λ, diffracte la lumière. Pour de petits angles, l'écart angulaire θ vérifie :
écart angulaire, entre le milieu de la tache centrale et la première extinction
rad
\lambda
longueur d'onde de la lumière
m
a
largeur de la fente, ou diamètre du fil
m
L
largeur de la tache centrale
m
D
distance entre la fente et l'écran
m
Toutes les longueurs s'expriment dans la même unité, le mètre.
Comme au TP1, un laser rouge (λ = 633 nm) éclaire une fente de largeur a = 100 µm ; l'écran est à D = 1,50 m de la fente.
Écrire un script qui calcule la largeur L de la tache centrale.
L'afficher en centimètres, arrondie au dixième, avec son unité.
Toutes les longueurs en mètres, avec la notation e : 633 nm = 633 × 10⁻⁹ m.
Calculez d'abord θ à partir de λ et a, puis isolez L dans la deuxième relation.
Python n'accepte pas 2D : la multiplication s'écrit toujours 2 * D.
Voir une solution
D = 1.50
lam = 633e-9
a = 100e-6
theta = lam / a
L = 2 * D * theta
print('L =', round(L * 100, 1), 'cm')
θ = 6,33 × 10⁻³ rad et la tache centrale mesure 1,9 cm.
La bibliothèque numpy
Python de base ne connaît ni le logarithme ni la racine carrée. Ces fonctions sont rangées dans des bibliothèques, qu'on charge en début de programme. En physique-chimie, la plus utilisée s'appelle numpy (numerical Python).
Derrière le rideau
Une bibliothèque n'a rien de magique : c'est du code écrit par d'autres programmeurs, rangé et partagé pour qu'on n'ait pas à le réécrire. Calculer un logarithme, par exemple, n'est pas une opération que le processeur sait faire directement : il ne connaît que les additions, les multiplications et quelques opérations simples. La fonction log10 est donc un petit programme qui approche le résultat par une suite de calculs élémentaires, assez pour obtenir les 16 chiffres significatifs, et assez vite pour traiter des millions de valeurs. Écrire un tel programme juste, rapide et fiable demande beaucoup de travail.
Python a été créé en 1991 par Guido van Rossum. numpy est né en 2005-2006, quand Travis Oliphant a réuni deux bibliothèques scientifiques plus anciennes ; matplotlib, celle des graphiques, a été lancée en 2003 par John Hunter, un neurobiologiste qui voulait tracer ses mesures. Les trois sont libres (open source) : leur code est public et gratuit, et des centaines de bénévoles, de chercheurs et d'ingénieurs du monde entier le corrigent et l'améliorent encore aujourd'hui. Les grands laboratoires de recherche s'en servent, tout comme vous.
À retenir
import numpy as np, en première ligne, charge numpy sous le nom court np.
On appelle ensuite ses fonctions avec np. devant : np.log10(x) (logarithme décimal, le « log » du cours), np.sqrt(x) (racine carrée), np.pi (le nombre π).
Piège : np.log(x) calcule le logarithme népérien ln, pas le log décimal.
Dix puissance x s'écrit 10 ** x ; pour une puissance négative, des parenthèses évitent les surprises : 10 ** (-pH).
À quoi ça sert : np.log10 calcule un pH ou un niveau d'intensité sonore, 10 ** (-pH) revient à la concentration, np.sqrt donne une incertitude-type.
Chaque fonction a sa page dans la documentation officielle (en anglais), avec des exemples : np.log10 ↗ · np.sqrt ↗. Y aller voir est un réflexe de programmeur.
4.1 Le niveau d'intensité sonore
Rappel de cours — Niveau d'intensité sonore
Le niveau d'intensité sonore se calcule à partir de l'intensité sonore, avec le logarithme décimal :
L = 10 \times \log\left(\dfrac{I}{I_0}\right)
Grandeur
Nom
Unité
L
niveau d'intensité sonore
dB (décibel)
I
intensité sonore
W·m⁻²
I_0
seuil d'audibilité : 1,0 × 10⁻¹²
W·m⁻²
On reprend la salle de classe de l'exercice 1.3 : I = 1,0 × 10⁻⁵ W·m⁻².
Compléter le programme pour calculer le niveau d'intensité sonore L de la salle.
Remplacer np.log10 par np.log et exécuter de nouveau. Le résultat est-il plausible pour une salle de classe ?
Voir une solution
L = 10 * np.log10(I / I0)
Python affiche L = 70.0 dB. Avec np.log, on obtient 161,2 dB : un niveau qui détruirait l'oreille, signe d'une erreur. Python ne signale rien, car le calcul est valide, simplement ce n'est pas le bon. C'est l'une des erreurs les plus fréquentes à l'ECE.
4.2 Du pH à la concentration, et retour
Rappel de cours — pH
Le pH d'une solution aqueuse se calcule à partir de la concentration en ions oxonium :
np.log est le logarithme népérien : ln(100) ≈ 4,605. C'est np.log10(100) qui vaut 2.
Une solution a une concentration en ions oxonium de 1,0 × 10⁻² mol·L⁻¹. Compléter la ligne pH = …….
Le jus de citron a un pH de 2,4. Compléter la ligne qui calcule sa concentration h_citron en ions oxonium.
Voir une solution
pH = -np.log10(h)
h_citron = 10 ** (-pH_citron)
Python affiche pH = 2.0 puis 0.003981071705534973, soit [H3O+] ≈ 4,0 × 10⁻³ mol·L⁻¹. Ici c0 = 1 mol·L⁻¹ : diviser par c0 ne change pas la valeur, on peut l'omettre.
4.3 L'incertitude-type d'une moyenne
Rappel de cours — Incertitude de type A
Pour une série de n mesures répétées de la même grandeur x, l'incertitude-type de la moyenne vaut :
u(\bar{x}) = \dfrac{s(x)}{\sqrt{n}}
Grandeur
Nom
Unité
n
nombre de mesures
sans unité
\bar{x}
moyenne des mesures
celle de x
s(x)
écart-type expérimental de la série
celle de x
u(\bar{x})
incertitude-type de la moyenne
celle de x
L'incertitude-type s'écrit avec un seul chiffre significatif, arrondi à l'excès ; la moyenne s'arrondit au même rang.
La classe a mesuré 15 fois la masse du même cylindre d'aluminium. La calculatrice donne une moyenne de 55,45 g et un écart-type s = 0,02 g.
Écrire un script qui calcule l'incertitude-type u de la moyenne, avec np.sqrt, et l'affiche.
Combien de mesures faudrait-il pour diviser cette incertitude par deux ? Le vérifier en modifiant une seule ligne.
Il faut trois variables : le nombre de mesures, l'écart-type, et l'incertitude.
N'oubliez pas import numpy as np en première ligne.
Pour la question 2 : u est divisée par √n. Pour diviser u par 2, par combien faut-il multiplier n ?
Voir une solution
import numpy as np
n = 15 # nombre de mesures
s = 0.02 # écart-type expérimental, en g
u = s / np.sqrt(n)
print('u =', u, 'g')
u ≈ 0,0052 g, soit 0,006 g arrondi à l'excès. Pour diviser u par 2, il faut multiplier √n par 2, donc n par 4 : 60 mesures. Mesurer plus améliore la précision, mais de moins en moins vite.
Listes de mesures et tableaux numpy
En TP, on ne mesure jamais une seule valeur. Une liste range toute une série de mesures sous un seul nom ; un tableau numpy permet de faire le même calcul sur toutes, d'un coup. C'est ce que demande l'ECE dans la plupart des sujets.
À retenir
Une liste regroupe des valeurs entre crochets, séparées par des virgules : pH = [2.4, 2.5, 2.9]. C'est là que sert la virgule, jamais comme séparateur décimal.
len(pH) donne le nombre d'éléments.
pH[0] est le premier élément : Python compte à partir de 0. pH[2] est donc le troisième.
Une liste ne se prête pas au calcul : pH * 2 la recopie deux fois. On la convertit en tableau numpy : pH = np.array(pH) (doc ↗).
Un calcul sur un tableau agit sur chaque valeur et donne un nouveau tableau, de même longueur : une valeur calculée par mesure. Deux tableaux de même longueur se combinent valeur par valeur : pH - pH_th donne l'écart pour chaque solution.
À quoi ça sert : dès qu'on exploite une série de mesures. Les pH théoriques de toute une gamme de solutions (pH_th = -np.log10(c), TP6), les concentrations qui correspondent à des pH (h = 10 ** (-pH)), des largeurs converties en mètres (a = a * 1e-6, TP1), l'écart entre les mesures et le modèle.
import numpy as np
pH = np.array([2.4, 2.5, 2.9]) # liste convertie en tableau
h = 10 ** (-pH) # trois calculs d'un coup
print(h)
c = np.array([0.100, 0.010, 0.001]) # concentrations, en mol/L
pH_th = -np.log10(c) # trois pH théoriques d'un coup
print(pH_th) # affiche [1. 2. 3.]
Dans la console, rangez dans pH la liste des pH mesurés au TP6 : 1,03 ; 1,41 ; 1,68 ; 2,08 ; 2,25. Testez ensuite len(pH), pH[0], pH[4], pH[5] et pH * 2. Importez enfin numpy, convertissez la liste en tableau et testez de nouveau pH * 2.
Cinq valeurs : la dernière est pH[4], et pH[5] n'existe pas (IndexError). Une liste multipliée par 2 est recopiée deux fois ; un tableau numpy est multiplié valeur par valeur.
5.2 Prédire
import numpy as np
d = [1000, 1250, 1500]
lam = 500
Après ces trois lignes, que vaut…
len(d)
len compte les éléments : trois.
d[1]
On compte à partir de 0 : d[0] vaut 1000, d[1] vaut 1250.
d[3]
La liste a trois éléments, numérotés 0, 1 et 2 : d[3] n'existe pas, Python répond IndexError.
np.array(d) / lam
Le tableau est divisé valeur par valeur : 2, 2,5 et 3. Python l'affiche avec le mot array, et des points après les entiers puisque la division donne des nombres à virgule.
d / lam
Sans np.array, d est une simple liste, qu'on ne peut pas diviser : TypeError. C'est pour cela qu'on convertit les listes avant de calculer.
5.3 Le pH de liquides courants
Rappel de cours — pH
Le pH d'une solution aqueuse se calcule à partir de la concentration en ions oxonium :
Au TP6, cinq solutions d'acide chlorhydrique ont été préparées par dilution. La réaction du chlorure d'hydrogène avec l'eau est totale : la concentration en ions oxonium est égale à la concentration apportée c. Les pH mesurés sont ceux de l'exercice 5.1. C'est la partie 1 du programme du TP6.
Compléter la ligne pH_th = …… qui calcule, en une seule ligne, les cinq pH théoriques.
Compléter la ligne ecart = …… qui calcule, pour chaque solution, l'écart entre le pH mesuré et le pH théorique.
Les mesures sont-elles en accord avec la définition du pH ?
La concentration standard vaut 1 mol·L⁻¹ : diviser par c0 ne change pas la valeur.
Le log du cours est le logarithme décimal : np.log10, pas np.log.
Deux tableaux de même longueur se soustraient valeur par valeur.
Voir une solution
pH_th = -np.log10(c)
ecart = pH - pH_th
Un calcul sur un tableau donne un tableau de même longueur : cinq pH théoriques, puis cinq écarts. Les écarts restent inférieurs à 0,1 en valeur absolue : les mesures sont en accord avec la définition du pH. C'est la ligne pH_th du programme du TP6.
Moyenne, écart-type, incertitude
Plus besoin du mode statistique de la calculatrice : numpy calcule la moyenne et l'écart-type d'une série en une ligne. C'est le cœur de nombreux sujets d'ECE.
À retenir
np.mean(x) : la moyenne de la série x.
np.std(x, ddof=1) : l'écart-type expérimental, celui qui divise par n − 1, comme dans le cours. Sans ddof=1, numpy divise par n : ce n'est pas celui qu'on utilise.
len(x) donne n, et l'incertitude-type de la moyenne s'écrit np.std(x, ddof=1) / np.sqrt(len(x)).
À quoi ça sert : exploiter une série de mesures répétées (les passages de la voiture au TP5, les pH de l'eau du robinet relevés par toute la classe au TP6) et écrire le résultat avec son incertitude.
Il mesure la dispersion des mesures autour de la moyenne. On divise par n − 1 : touche σn−1 ou Sx de la calculatrice, ECARTYPE du tableur, np.std(x, ddof=1) en Python.
3. L'incertitude-type de la moyenne
u(\bar{x}) = \dfrac{s(x)}{\sqrt{n}}
Elle évalue la fiabilité de la moyenne : plus on fait de mesures, plus elle est petite.
Grandeur
Nom
Unité
n
nombre de mesures
sans unité
x_i
la mesure numéro i, de x1 à xn
celle de x
\sum_{i=1}^{n}
somme des n termes, pour i allant de 1 à n
—
\bar{x}
moyenne
celle de x
s(x)
écart-type expérimental
celle de x
u(\bar{x})
incertitude-type de la moyenne
celle de x
Écrire le résultat
x = \bar{x} \pm u(\bar{x}), suivi de l'unité. L'incertitude-type garde un seul chiffre significatif, arrondi à l'excès ; la moyenne s'arrondit au même rang. Pour un niveau de confiance de 95 %, on élargit l'incertitude : U(\bar{x}) = 2 \times u(\bar{x}) (TP6).
Voici les 15 masses du cylindre d'aluminium de l'exercice 4.3, cette fois mesure par mesure (valeurs construites d'après la fiche de cours).
Compléter les lignes qui calculent la moyenne m_moy et l'incertitude-type u.
Exécuter, puis retirer ddof=1. L'écart-type change-t-il ? Lequel faut-il utiliser ?
Ajouter une ligne print qui écrit le résultat de la mesure sous la forme m = (moyenne ± u) g, en respectant les chiffres significatifs (voir le rappel de cours).
Voir une solution
m_moy = np.mean(m)
u = s / np.sqrt(n)
print('m = (55.449 ± 0.005) g')
Moyenne 55,449 g, s ≈ 0,018 g, u ≈ 0,0048 g, arrondie à l'excès : 0,005 g. Sans ddof=1, l'écart-type vaut 0,0178 g : un peu plus petit, car numpy divise par n. En physique, on utilise l'écart-type expérimental, avec ddof=1.
Écriture du résultat : u = 0,0048 g garde un seul chiffre significatif, arrondi à l'excès : 0,005 g. Ce chiffre est celui des millièmes : la moyenne s'arrondit donc au millième, 55,449 g. On écrit m = (55,449 ± 0,005) g.
Tracer un graphique avec pyplot
Tracer des mesures, comparer à un modèle, lire une valeur : c'est la partie graphique de presque tous les sujets d'ECE. On utilise pyplot, une partie de la bibliothèque matplotlib.
À retenir
import matplotlib.pyplot as plt charge pyplot sous le nom court plt. Toutes ses fonctions sont dans la documentation officielle (en anglais) : pyplot ↗. Un réglage à faire (couleur, taille des points, échelle) ? On va le chercher dans la page de la fonction : c'est un réflexe à prendre.
plt.plot(x, y, 'b+') place des points (croix bleues) ; plt.plot(x, y, 'r-') trace une ligne rouge. Les deux tableaux x et y doivent avoir la même longueur. doc ↗
label='mesures' donne un nom à la série ; plt.legend() affiche ces noms. doc ↗
plt.xlabel('…'), plt.ylabel('…') et plt.title('…') légendent le graphique ; plt.grid() ajoute un quadrillage. xlabel ↗ · ylabel ↗ · title ↗ · grid ↗
np.linspace(0, 11, 100) crée 100 valeurs régulièrement espacées de 0 à 11 : idéal pour tracer une courbe de modèle bien lisse. doc ↗
plt.hist(x, bins=5, edgecolor='black') trace l'histogramme d'une série, en 5 classes. doc ↗
À quoi ça sert : tracer une courbe d'étalonnage (TP3, TP4), vérifier une loi en comparant mesures et modèle (TP1, TP6), représenter la dispersion d'une série par un histogramme (TP6).
Pour une solution diluée (concentration inférieure à 1,0 × 10⁻² mol·L⁻¹) ne contenant qu'un seul soluté ionique, la conductivité est proportionnelle à la concentration :
\sigma = k \times c \qquad\qquad \text{soit} \qquad c = \dfrac{\sigma}{k}
Grandeur
Nom
Unité
\sigma
conductivité de la solution
S·m⁻¹ (au TP4 : mS·cm⁻¹)
c
concentration du soluté
mol·L⁻¹ (au TP4 : mmol·L⁻¹)
k
coefficient de proportionnalité, pente de la droite d'étalonnage
celle de σ divisée par celle de c
Une concentration inconnue se lit sur la droite d'étalonnage, ou se calcule avec la seconde relation.
Au TP4, la gamme étalon de chlorure de sodium a donné les mesures ci-dessous. Le modèle de Kohlrausch s'écrit σ = k × c, avec k = 0,1172 mS·cm⁻¹ par mmol·L⁻¹.
Exécuter : les mesures s'affichent. Ajouter les légendes des axes et un titre. La touche αβ de la barre sous l'éditeur donne la lettre σ.
Compléter sigma_mod = ……, puis ajouter la ligne qui trace le modèle en ligne rouge, avec label='modèle'.
Le modèle est-il en accord avec les mesures ?
Voir une solution
sigma_mod = k * c_mod
plt.plot(c, sigma, 'b+', markersize=12, label='mesures')
plt.plot(c_mod, sigma_mod, 'r-', label='modèle')
plt.xlabel('c (mmol/L)')
plt.ylabel('σ (mS/cm)')
plt.title("Courbe d'étalonnage du chlorure de sodium")
Les points sont proches de la droite : le modèle est en accord avec les mesures. Attention : on trace le modèle avec c_mod, pas avec c, sinon les deux tableaux n'ont pas la même longueur. Le titre contient une apostrophe : on l'écrit donc entre guillemets doubles.
7.2 Lire une concentration
Le sérum physiologique dilué du TP4 a une conductivité σ = 0,869 mS·cm⁻¹.
Calculer sa concentration c_serum à l'aide du modèle, et l'afficher arrondie au centième avec son unité.
Placer ce point sur le graphique, avec une autre couleur et un autre marqueur.
Isolez c dans σ = k × c.
Un seul point se trace comme une série : plt.plot(c_serum, sigma_serum, 'go') trace un rond vert.
Le tracé doit être placé avant plt.show().
Voir une solution
c_serum = sigma_serum / k
print('c =', round(c_serum, 2), 'mmol/L')
plt.plot(c_serum, sigma_serum, 'go', label='sérum dilué') # avant plt.show()
c ≈ 7,41 mmol·L⁻¹ : le point tombe sur la droite, entre les étalons à 5 et 8 mmol·L⁻¹.
7.3 L'histogramme des masses
On reprend les 15 masses du cylindre d'aluminium (exercice 6.1).
Compléter le programme pour tracer l'histogramme des masses en 5 classes, avec des axes légendés.
Autour de quelle valeur les mesures se regroupent-elles ? Le comparer à la moyenne calculée en 6.1.
Les mesures se regroupent autour de 55,45 g, la moyenne calculée en 6.1, et s'étalent de 55,42 à 55,48 g. La largeur de cet étalement, c'est la dispersion que mesure l'écart-type.
Lire un message d'erreur
Tout programmeur fait des erreurs, tous les jours. Ce qui compte, c'est de savoir lire ce que Python répond. Le message de Python s'affiche en premier, en rouge ; dessous, une explication courte en français.
À retenir
Python indique le numéro de la ligne et le type d'erreur. L'erreur est sur cette ligne, ou juste au-dessus.
SyntaxError : la ligne n'est pas du Python (parenthèse ou guillemet oublié, virgule décimale, mot réservé utilisé comme nom…).
NameError : nom inconnu (faute de frappe, majuscule, variable pas encore définie, texte sans guillemets).
TypeError : opération impossible sur ce type de valeur (texte + nombre, calcul sur une liste…).
ValueError : valeur qui ne convient pas, par exemple deux tableaux de longueurs différentes dans plt.plot.
Certaines erreurs ne déclenchent aucun message : le programme tourne, le résultat est faux. Seul un regard critique sur le résultat les révèle.
Rappel de cours — Loi de Beer-Lambert
L'absorbance d'une solution est proportionnelle à la concentration de l'espèce colorée qu'elle contient :
A = \varepsilon \times \ell \times c \qquad\qquad \text{soit} \qquad A = k \times c
Grandeur
Nom
Unité
A
absorbance de la solution
sans unité
\varepsilon
coefficient d'absorption molaire de l'espèce colorée
L·mol⁻¹·cm⁻¹
\ell
épaisseur de solution traversée (largeur de la cuve)
cm
c
concentration de l'espèce colorée
mol·L⁻¹ (ici, en masse : mg·L⁻¹)
k
coefficient lu sur la droite d'étalonnage
ici L·mg⁻¹
On en déduit la concentration d'une solution inconnue : c = \dfrac{A}{k}.
Les programmes de cette étape cherchent la concentration en colorant bleu d'un sirop de menthe dilué, comme au TP3. L'absorbance vaut A = 0,47 ; la droite d'étalonnage donne k = 0,124 L·mg⁻¹ (valeurs construites pour l'exercice). Chaque programme contient une erreur : exécuter, lire le message, corriger.
SyntaxError ligne 4 : la parenthèse ouverte par print( n'est jamais fermée. Ligne corrigée : print('c =', round(c, 2), 'mg/L'). Réflexe : compter les parenthèses ouvrantes et fermantes.
8.2 Deuxième erreur
Voir une solution
NameError: name 'C' is not defined : la variable s'appelle c en minuscule, C n'existe pas.
8.3 Troisième erreur
Voir une solution
L'erreur est signalée ligne 3 (TypeError), mais elle est née ligne 2 : 0,124 n'est pas un nombre pour Python, c'est une paire de deux nombres, 0 et 124, et on ne divise pas par une paire. Ligne corrigée : k = 0.124. La ligne signalée n'est pas toujours celle à corriger : remontez.
8.4 Quatrième erreur
Voir une solution
SyntaxError ligne 1 : lambda est un mot réservé du langage. Ligne corrigée : lam = 630e-9.
8.5 L'erreur silencieuse
On dilue dix fois une solution mère de concentration 10⁻² mol·L⁻¹. Ce programme s'exécute sans aucun message. Pourtant, il est faux.
Exécuter. Le résultat est-il possible pour une concentration ?
Trouver et corriger l'erreur.
Voir une solution
Le programme affiche −1,2 mol·L⁻¹ : une concentration négative, impossible. En Python, ^ n'est pas la puissance mais une opération sur les chiffres binaires des nombres entiers, qui donne ici −12. Aucun message, puisque l'opération existe. Ligne corrigée : c_mere = 1e-2 ou c_mere = 10 ** -2.
8.6 L'erreur de l'ECE
Un élève a saisi ses mesures d'absorbance pour tracer la courbe d'étalonnage.
Voir une solution
ValueError: x and y must have same first dimension, but have shapes (6,) and (5,) : six concentrations, mais seulement cinq absorbances. Une mesure a été oubliée à la saisie. À l'ECE, il faut compléter la mesure manquante ; ici, on peut retirer la dernière concentration, 6.0.
Pas de panique : on ne vous demande jamais d'écrire un programme entier.
Le programme est fourni, presque entièrement écrit et commenté. Votre travail tient en trois gestes : saisir vos mesures, exécuter, exploiter ce qui s'affiche.
Exemple 1 · d'après ECE PC, banque 2026, sujet n° 38 (loi de Boyle-Mariotte)
V = np.array([1, 1, 1, 1, 1]) # A MODIFIER Volume (cm³)
P = np.array([1, 1, 1, 1, 1]) # A MODIFIER Pression (hPa)
n = len(V)
k_moy = np.mean(P * V)
u_k_moy = np.std(P * V, ddof=1) / np.sqrt(n)
print("Valeur moyenne de k : ", k_moy, " hPa·cm³")
Seules les deux premières lignes sont à modifier : on remplace les 1 par ses mesures. Tout le reste a été vu dans ce niveau : np.array et len à l'étape 5 ; np.mean, np.std(…, ddof=1) et np.sqrt à l'étape 6.
Exemple 2 · d'après ECE PC, banque 2026, sujet n° 59 (diffraction par des fils calibrés)
##### À COMPLÉTER PAR LE CANDIDAT #####
L = []
a = []
##### FIN DE LA PARTIE À COMPLÉTER #####
def round_up_sig(x, sig=1):
... # une trentaine de lignes suivent
Le programme complet contient des instructions jamais vues ici (def, raise, .format…). Ce n'est pas grave : on ne vous demande que de remplir les deux listes entre les lignes À COMPLÉTER, avec des points décimaux et autant de valeurs dans chacune.
Où se perdent les points
Une virgule décimale. Deux listes de longueurs différentes. Des unités mélangées. Un graphique tracé mais pas exploité : la question qui suit l'exécution compte autant que le programme.
Bilan du niveau 1
Ce que je sais faire
Utiliser la console comme une calculatrice, avec le point décimal et la notation e.
Ranger des valeurs dans des variables, sans utiliser de mot réservé comme nom.
Distinguer un nombre d'un texte, et afficher un résultat avec son nom, sa valeur arrondie et son unité.
Importer numpy et utiliser np.log10, np.sqrt — sans confondre avec np.log.
Saisir des mesures dans une liste, la convertir en tableau numpy et calculer sur toutes les valeurs d'un coup.
Calculer une moyenne, un écart-type expérimental et une incertitude-type.
Tracer des points, un modèle et un histogramme, avec des axes légendés.
Lire un message d'erreur, trouver la ligne fautive, et douter d'un résultat aberrant.
Avec ces outils, vous pouvez traiter la partie Python de n'importe quel sujet d'ECE. Le niveau 2 les rassemble dans des mini-projets complets, comme le jour de l'épreuve.