>>> python · niveau 1 · terminale spé PC

La boîte à outils de l'ECE

calculs · variables · numpy · listes · pyplot · erreurs

Tout ce qu'il faut savoir faire en Python le jour de l'ECE, appris pas à pas, en révisant le cours de physique-chimie au passage.

← Le parcours Python

Mode d'emploi

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

2 ** 3

10 - 4 / 2

(10 - 4) / 2

3e2

10 ** -3

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

GrandeurNomUnité
Tpériode : durée d'un motifs
ffréquence : nombre de motifs par secondeHz
\lambdalongueur d'onde : distance parcourue par l'onde pendant une périodem
ccélérité : vitesse de propagation de l'ondem·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.

  1. Calculer dans la console la célérité c de ce son.
  2. Calculer sa période T.
  3. 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.
Voir une solution
>>> 0.68 * 500
340.0
>>> 1 / 500
0.002
>>> 0.68 * 500 / 440
0.7727272727272727

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}

GrandeurNomUnité
Iintensité sonoreW·m⁻²
Ppuissance sonore reçueW
Saire de la surface qui reçoit le sonm²

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⁻².

  1. Combien de fois l'intensité sonore de la salle dépasse-t-elle le seuil d'audibilité ? Faire le calcul dans la console.
  2. 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 = 340 affecte 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 ?

  1. Exécuter le programme pour vérifier votre prédiction.
  2. 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

TP5 — Ondes sonores et effet Doppler
Rappel de cours — Effet Doppler

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}

GrandeurNomUnité
f_Efréquence émiseHz
f_Rfréquence reçueHz
\Delta fdécalage DopplerHz
vvitesse de l'émetteur par rapport au récepteurm·s⁻¹
ccélérité de l'ondem·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⁻¹.

  1. Compléter la ligne f_R = …… avec l'expression exacte, puis la ligne delta_f = …….
  2. Compléter la ligne delta_f_approx = …… avec l'expression approchée.
  3. 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.

GrandeurNomUnité
\deltadifférence de marche au point Mm
\lambdalongueur d'ondem
knombre 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.

  1. Écrire un script qui calcule et affiche le rapport δ / λ.
  2. Les interférences en M sont-elles constructives ou destructives ?
  3. En ne modifiant qu'une ligne, trouver ce qui se passe en un point où S2M = 3 000 nm.
  1. Commencez par ranger λ, S1M et S2M dans trois variables, toutes en nm. Attention : lambda est un mot réservé.
  2. Rangez la différence de marche dans une variable, par exemple delta, calculée à partir des deux distances.
  3. 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)

type('2.5')

type(6 / 3)

print('f =', 500, 'Hz')

round(3.14159, 2)

'Hz' + 500

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
  1. Chaque ligne affichée a trois morceaux : un texte, une valeur, une unité.
  2. Le texte 'f =' s'écrit entre guillemets ; la valeur est le nom de la variable, sans guillemets.
  3. Dans un texte entre guillemets, on peut écrire lambda : seul un nom de variable ne le peut pas.
Voir une solution
print('f =', f, 'Hz')
print('T =', T, 's')
print('lambda =', lam, 'm')

3.4 Le résultat Doppler, présenté

On reprend la voiture de l'exercice 2.2. On veut que le programme affiche exactement :

Décalage Doppler : 236.69 Hz
Fréquence reçue : 40236.69 Hz
Voir une solution
print('Décalage Doppler :', round(delta_f, 2), 'Hz')
print('Fréquence reçue :', round(f_R, 2), 'Hz')

Arrondir à deux décimales sert l'affichage. Le nombre de chiffres significatifs d'un résultat de mesure, lui, dépend de son incertitude.

3.5 La tache de diffraction

TP1 — Diffraction de la lumière
Rappel de cours — Diffraction par une fente

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 :

\theta \approx \dfrac{\lambda}{a} \qquad\qquad \theta \approx \dfrac{L}{2D}

GrandeurNomUnité
\thetaécart angulaire, entre le milieu de la tache centrale et la première extinctionrad
\lambdalongueur d'onde de la lumièrem
alargeur de la fente, ou diamètre du film
Llargeur de la tache centralem
Ddistance entre la fente et l'écranm

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.

  1. Écrire un script qui calcule la largeur L de la tache centrale.
  2. L'afficher en centimètres, arrondie au dixième, avec son unité.
  1. Toutes les longueurs en mètres, avec la notation e : 633 nm = 633 × 10⁻⁹ m.
  2. Calculez d'abord θ à partir de λ et a, puis isolez L dans la deuxième relation.
  3. 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)

GrandeurNomUnité
Lniveau d'intensité sonoredB (décibel)
Iintensité sonoreW·m⁻²
I_0seuil d'audibilité : 1,0 × 10⁻¹²W·m⁻²

On reprend la salle de classe de l'exercice 1.3 : I = 1,0 × 10⁻⁵ W·m⁻².

  1. Compléter le programme pour calculer le niveau d'intensité sonore L de la salle.
  2. 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 :

\mathrm{pH} = -\log\left(\dfrac{[\mathrm{H_3O^+}]}{c^0}\right) \qquad\qquad [\mathrm{H_3O^+}] = c^0 \times 10^{-\mathrm{pH}}

GrandeurNomUnité
\mathrm{pH}pH de la solutionsans unité
[\mathrm{H_3O^+}]concentration en ions oxoniummol·L⁻¹
c^0concentration standard : 1 mol·L⁻¹mol·L⁻¹

Que renvoie np.log(100) ?

  1. Une solution a une concentration en ions oxonium de 1,0 × 10⁻² mol·L⁻¹. Compléter la ligne pH = …….
  2. 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}}

GrandeurNomUnité
nnombre de mesuressans unité
\bar{x}moyenne des mesurescelle de x
s(x)écart-type expérimental de la sériecelle de x
u(\bar{x})incertitude-type de la moyennecelle 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.

  1. Écrire un script qui calcule l'incertitude-type u de la moyenne, avec np.sqrt, et l'affiche.
  2. Combien de mesures faudrait-il pour diviser cette incertitude par deux ? Le vérifier en modifiant une seule ligne.
  1. Il faut trois variables : le nombre de mesures, l'écart-type, et l'incertitude.
  2. N'oubliez pas import numpy as np en première ligne.
  3. 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.]

5.1 Manipuler une liste

TP6 — pH d'une solution aqueuse

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.

Voir une solution
>>> pH = [1.03, 1.41, 1.68, 2.08, 2.25]
>>> len(pH)
5
>>> pH[0]
1.03
>>> pH[4]
2.25
>>> pH * 2
[1.03, 1.41, 1.68, 2.08, 2.25, 1.03, 1.41, 1.68, 2.08, 2.25]
>>> import numpy as np
>>> pH = np.array(pH)
>>> pH * 2
array([2.06, 2.82, 3.36, 4.16, 4.5 ])

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)

d[1]

d[3]

np.array(d) / lam

d / lam

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 :

\mathrm{pH} = -\log\left(\dfrac{[\mathrm{H_3O^+}]}{c^0}\right) \qquad\qquad [\mathrm{H_3O^+}] = c^0 \times 10^{-\mathrm{pH}}

GrandeurNomUnité
\mathrm{pH}pH de la solutionsans unité
[\mathrm{H_3O^+}]concentration en ions oxoniummol·L⁻¹
c^0concentration standard : 1 mol·L⁻¹mol·L⁻¹

pH mesurés : jus de citron 2,4 ; soda au cola 2,5 ; vinaigre blanc 2,9 ; café 5,0 ; eau du robinet 7,6 ; eau de mer 8,2.

  1. Compléter la liste pH, puis la ligne qui calcule le tableau h des concentrations en ions oxonium.
  2. Afficher la concentration du café seul, en utilisant son rang dans la liste.
Voir une solution
pH = [2.4, 2.5, 2.9, 5.0, 7.6, 8.2]
h = 10 ** (-pH)
print(h[3])

Le café est le quatrième liquide, de rang 3 : h[3] vaut 1,0 × 10⁻⁵ mol·L⁻¹. Python affiche les très petites valeurs en notation scientifique : 1e-05.

5.4 Le pH théorique du TP6

TP6 — pH d'une solution aqueuse
Rappel de cours — pH

Le pH d'une solution aqueuse se calcule à partir de la concentration en ions oxonium :

\mathrm{pH} = -\log\left(\dfrac{[\mathrm{H_3O^+}]}{c^0}\right) \qquad\qquad [\mathrm{H_3O^+}] = c^0 \times 10^{-\mathrm{pH}}

GrandeurNomUnité
\mathrm{pH}pH de la solutionsans unité
[\mathrm{H_3O^+}]concentration en ions oxoniummol·L⁻¹
c^0concentration standard : 1 mol·L⁻¹mol·L⁻¹

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.

  1. Compléter la ligne pH_th = …… qui calcule, en une seule ligne, les cinq pH théoriques.
  2. Compléter la ligne ecart = …… qui calcule, pour chaque solution, l'écart entre le pH mesuré et le pH théorique.
  3. Les mesures sont-elles en accord avec la définition du pH ?
  1. La concentration standard vaut 1 mol·L⁻¹ : diviser par c0 ne change pas la valeur.
  2. Le log du cours est le logarithme décimal : np.log10, pas np.log.
  3. 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.
  • Documentation : np.mean ↗ · np.std ↗.

6.1 Le cylindre d'aluminium

Rappel de cours — Moyenne, écart-type, incertitude-type

Une grandeur x est mesurée n fois : on obtient les valeurs x1, x2, …, xn.

1. La moyenne

\bar{x} = \dfrac{1}{n}\sum_{i=1}^{n} x_i = \dfrac{x_1 + x_2 + \dots + x_n}{n}

C'est la meilleure estimation de la valeur de la grandeur.

2. L'écart-type expérimental

s(x) = \sqrt{\dfrac{1}{n-1}\sum_{i=1}^{n}\left(x_i - \bar{x}\right)^2}

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.

GrandeurNomUnité
nnombre de mesuressans unité
x_ila mesure numéro i, de x1 à xncelle de x
\sum_{i=1}^{n}somme des n termes, pour i allant de 1 à n—
\bar{x}moyennecelle de x
s(x)écart-type expérimentalcelle de x
u(\bar{x})incertitude-type de la moyennecelle 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).

  1. Compléter les lignes qui calculent la moyenne m_moy et l'incertitude-type u.
  2. Exécuter, puis retirer ddof=1. L'écart-type change-t-il ? Lequel faut-il utiliser ?
  3. 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 ↗
  • plt.show() affiche le graphique. 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).

7.1 La courbe d'étalonnage du TP4

TP4 — Dosage par conductimétrie
Rappel de cours — Loi de Kohlrausch

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}

GrandeurNomUnité
\sigmaconductivité de la solutionS·m⁻¹ (au TP4 : mS·cm⁻¹)
cconcentration du solutémol·L⁻¹ (au TP4 : mmol·L⁻¹)
kcoefficient de proportionnalité, pente de la droite d'étalonnagecelle 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⁻¹.

  1. 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 σ.
  2. Compléter sigma_mod = ……, puis ajouter la ligne qui trace le modèle en ligne rouge, avec label='modèle'.
  3. 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⁻¹.

  1. Calculer sa concentration c_serum à l'aide du modèle, et l'afficher arrondie au centième avec son unité.
  2. Placer ce point sur le graphique, avec une autre couleur et un autre marqueur.
  1. Isolez c dans σ = k × c.
  2. Un seul point se trace comme une série : plt.plot(c_serum, sigma_serum, 'go') trace un rond vert.
  3. 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).

  1. Compléter le programme pour tracer l'histogramme des masses en 5 classes, avec des axes légendés.
  2. Autour de quelle valeur les mesures se regroupent-elles ? Le comparer à la moyenne calculée en 6.1.
Voir une solution
plt.hist(m, bins=5, edgecolor='black')
plt.xlabel('masse (g)')
plt.ylabel('effectif')

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

GrandeurNomUnité
Aabsorbance de la solutionsans unité
\varepsiloncoefficient d'absorption molaire de l'espèce coloréeL·mol⁻¹·cm⁻¹
\ellépaisseur de solution traversée (largeur de la cuve)cm
cconcentration de l'espèce coloréemol·L⁻¹ (ici, en masse : mg·L⁻¹)
kcoefficient lu sur la droite d'étalonnageici 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.

TP3 — Dosage spectrophotométrique

8.1 Première erreur

Voir une solution

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.

  1. Exécuter. Le résultat est-il possible pour une concentration ?
  2. 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.