Exercices corrigés — Algorithmique & programmation (Python)

Exécute les lignes une par une : à chaque affectation, calcule d'abord le membre de droite avec les valeurs actuelles, puis range le résultat sous le nom écrit à gauche.

À la ligne 4 du premier programme, x ne vaut plus $3$ : c'est la valeur rangée à la ligne 3 qui compte.

= range une valeur ; == compare deux valeurs et produit True ou False sans rien modifier.

Le signe = de Python ne dit pas que deux choses sont égales : il ordonne de ranger une valeur. L'instruction x = expression s'exécute en deux temps, toujours dans cet ordre : Python calcule d'abord le membre de droite avec les valeurs actuelles des variables, puis il range le résultat sous le nom écrit à gauche, en écrasant la valeur qui s'y trouvait. On dit qu'on affecte la valeur à x.

Un programme est donc une suite d'états : après chaque ligne, chaque variable a une valeur précise, et la ligne suivante part de cet état-là, pas de l'état initial. Rien n'est « vrai en même temps » comme dans un système d'équations.

La comparaison, elle, s'écrit ==. Elle ne modifie rien : elle produit une valeur de vérité, True ou False, qu'on peut afficher ou tester.

👉 Pour prédire un programme, tu ne lis pas ses lignes comme des équations à résoudre ensemble : tu les exécutes une par une, en tenant à jour un tableau de trace. C'est le geste de base de tout ce chapitre.

On exécute les lignes dans l'ordre et on note l'état après chacune ; un tiret signale une variable pas encore créée.

Deux lignes demandent de l'attention. À la ligne 3, x = x * y calcule $3\times5=15$ avec les valeurs du moment, puis écrase le $3$. À la ligne 4, y = x - y utilise donc le nouveau x : $15-5=10$, et non $3-5=-2$ — l'ancienne valeur $3$ n'existe plus nulle part. La dernière ligne affiche les deux valeurs finales, séparées par une espace :

x = 3
y = x + 2
x = x * y
y = x - y
x = x + 1
print(x, y)

16 10

Vérification. On fait afficher l'état après chaque ligne : les cinq lignes obtenues doivent reproduire les cinq dernières lignes du tableau.

x = 3
print(x)
y = x + 2
print(x, y)
x = x * y
print(x, y)
y = x - y
print(x, y)
x = x + 1
print(x, y)

3
3 5
15 5
15 10
16 10

Elles les reproduisent. C'est la méthode à garder pour contrôler une trace faite à la main : instrumenter le programme, c'est-à-dire insérer des print, puis comparer.

Lue comme une équation, $x=x+1$ donne $0=1$ : aucune solution. Lue comme Python la lit, la phrase est « calcule x + 1 avec la valeur actuelle de x, puis range le résultat dans x ». Le nom ne change pas, la valeur augmente de $1$ : on dit qu'on incrémente x.

Dans le programme de la question, n vaut successivement $10$, puis $10+1=11$, puis $11\times11=121$ :

n = 10
n = n + 1
n = n * n
print(n)

121

Ce motif — une variable qui se met à jour à partir de sa propre valeur — est celui des compteurs (c = c + 1) et des accumulateurs (s = s + t) qu'on retrouve dans toutes les boucles du lot B. Python accepte l'abréviation n += 1, qui fait la même chose sur un nombre (sur une liste, t += [x] modifie la liste en place, comme append : voir l'exercice E6) ; ce chapitre garde la forme longue, qui montre l'ordre des opérations.

Vérification. Les deux mises à jour reviennent à calculer $(10+1)^2$ d'un seul coup :

print((10 + 1) ** 2)

121

Même résultat par un autre chemin.

La deuxième ligne du programme de l'élève est une comparaison : x == 5 calcule False (puisque x vaut $2$), et ce booléen, rangé nulle part, est aussitôt perdu. Rien n'a été modifié, et le programme affiche l'ancienne valeur :

x = 2
x == 5
print(x)

2

Python ne signale rien : une expression seule sur une ligne est permise, elle est simplement calculée pour rien. La correction remplace la comparaison par une affectation ; on en profite pour montrer == à sa vraie place, dans une valeur qu'on affiche :

x = 2
x = 5
print(x)
print(x == 5)

5
True

Et dans l'autre sens ? Écrire if x = 5: pour tester l'égalité est refusé par Python avant toute exécution : il signale une erreur de syntaxe (SyntaxError), et aucune ligne du programme n'est exécutée, pas même celles qui précèdent le if. Un test attend une expression qui vaut vrai ou faux ; l'instruction d'affectation = n'en est pas une. (Les versions récentes de Python suggèrent aussi := dans leur message : cette « affectation-expression » serait acceptée, mais elle range 5 dans x au lieu de le comparer, et le test est toujours vrai — ce n'est pas la correction.) Le test correct s'écrit if x == 5:.

Vérification. La dernière ligne affichée, True, confirme que la valeur rangée est bien $5$ : c'est == qui fait le contrôle, sans rien changer à x.

À la ligne 2, b = a range dans b la valeur que a possède à ce moment-là, soit $4$. À la ligne 3, on range $7$ dans a. Aucune instruction n'a demandé de modifier b : il vaut toujours $4$.

a = 4
b = a
a = 7
print(a, b)
print(b == 4)

7 4
True

En mathématiques, « posons $b=a$ » installe une égalité qui dure tout le raisonnement. En Python, b = a est une photographie : elle recopie une valeur à un instant donné, et la suite du programme peut faire évoluer a et b indépendamment.

⚠️ Réaffecter a ne modifie jamais b, quel que soit le type de la valeur. Les listes réservent une autre surprise, étudiée en E6 : quand deux noms désignent la même liste, modifier cette liste en place (a[0] = 7) se voit par les deux noms. Ce n'est pas une réaffectation, et c'est un autre mécanisme.

Vérification. La ligne True confirme que b a gardé la valeur $4$ après la réaffectation de a.

Affectation. nom = expression : on évalue l'expression avec les valeurs actuelles, puis on range le résultat sous le nom, qui est créé s'il n'existait pas et écrasé sinon. Toujours la droite d'abord, la gauche ensuite.

Comparaisons. a == b (égal), a != b (différent), <, <=, >, >= : elles ne modifient rien et produisent un booléen, True ou False.

Trace. Un tableau avec une colonne par variable et une ligne par instruction exécutée ; on n'y écrit que les valeurs réellement calculées, et on le contrôle en insérant des print.

Affichage. print(a, b) affiche les valeurs séparées par une espace, puis passe à la ligne.

⚠️ Utiliser une variable avant de l'avoir affectée. Python exécute les lignes dans l'ordre : une variable n'existe qu'à partir de la ligne qui l'affecte. Ici le programme s'arrête dès la première ligne, sans rien afficher :

y = x + 1
x = 3
print(y)

NameError: name 'x' is not defined

Il suffit d'échanger les deux premières lignes :

x = 3
y = x + 1
print(y)

4

⚠️ Écrire l'affectation à l'envers. 3 = x est refusé : à gauche du =, il faut un nom, pas un nombre ni un calcul. Le sens de lecture est « x reçoit $3$ », jamais « $3$ reçoit x ».

⚠️ Lire = comme une égalité qui dure. Après b = a, rien ne relie b à a ; toute trace qui fait « suivre » une variable par une autre est fausse.

Après a = b, que reste-t-il de l'ancienne valeur de a ? Une affectation écrase.

Avant d'écraser a, mets sa valeur à l'abri dans t ; c'est t qui la rendra à b.

Pour la méthode arithmétique, suis les valeurs avec deux lettres fixes : pars de $a=\alpha$ et $b=\beta$.

Une affectation écrase : dès que a = b est exécutée, l'ancienne valeur de a est perdue, et aucune instruction ultérieure ne peut la retrouver. Échanger deux variables est donc un problème de sauvegarde : avant d'écraser une valeur dont on aura encore besoin, il faut la mettre à l'abri.

Trois solutions, trois idées différentes :

• sauvegarder dans une troisième variable, t ;
• lire les deux valeurs avant de ranger quoi que ce soit, ce que fait a, b = b, a ;
• coder l'information dans une somme — méthode exacte sur les entiers, et fausse sur les flottants.

👉 Devant toute suite d'affectations, pose-toi la question : quelle valeur cette ligne écrase-t-elle, et en aura-t-on encore besoin ?

La ligne 3 range $8$ dans a : le $3$ disparaît. La ligne 4 recopie dans b la valeur de a, qui est déjà $8$ : elle ne change rien. Le programme affiche deux fois la même valeur :

a = 3
b = 8
a = b
b = a
print(a, b)

8 8

Vérification. Inverser l'ordre des deux dernières affectations ne répare rien : c'est alors le $8$ qui est perdu.

a = 3
b = 8
b = a
a = b
print(a, b)

3 3

Les deux ordres échouent, symétriquement : avec deux affectations seulement, l'une des deux valeurs est forcément écrasée avant d'avoir été lue.

On sauvegarde la valeur de a dans t avant de l'écraser, puis t la rend à b :

a = 3
b = 8
t = a
a = b
b = t
print(a, b)

8 3

À la ligne 4, a est bien écrasé — mais sa valeur survit dans t. C'est tout le secret.

Vérification. La méthode ne calcule rien, elle déplace des valeurs : elle marche donc pour n'importe quel type, y compris des chaînes de caractères, et même pour deux valeurs de types différents.

a = 'pile'
b = 2.5
t = a
a = b
b = t
print(a, b)

2.5 pile

Une affectation multiple s'exécute, elle aussi, droite d'abord : Python évalue tout le membre de droite, b, a, ce qui donne le couple $(8,3)$ ; ensuite seulement il range $8$ dans a et $3$ dans b. Au moment où l'on range, les deux anciennes valeurs ont déjà été lues : rien ne peut être perdu. Le couple joue le rôle de la variable t.

a = 3
b = 8
a, b = b, a
print(a, b)

8 3

Il ne faut donc pas lire a, b = b, a comme « a = b puis b = a » : ce serait exactement l'échange naïf de la question 1. Beaucoup de langages n'ont pas cette écriture ; la variable temporaire reste la méthode universelle, celle qu'on écrit en pseudo-code.

Vérification. Un échange appliqué deux fois doit ramener au point de départ :

a = 3
b = 8
a, b = b, a
a, b = b, a
print(a, b)

3 8

Notons $\alpha$ et $\beta$ les valeurs initiales de a et b, et suivons-les ligne par ligne.

• Après a = a + b : a vaut $\alpha+\beta$, b vaut $\beta$.
• Après b = a - b : b vaut $(\alpha+\beta)-\beta=\alpha$.
• Après a = a - b : a vaut $(\alpha+\beta)-\alpha=\beta$.

Les valeurs sont échangées, pour tous réels $\alpha$ et $\beta$. $\blacksquare$ L'information « perdue » à la première ligne ne l'est pas vraiment : elle est codée dans la somme.

En Python, les entiers sont exacts et n'ont pas de taille maximale : la démonstration s'y applique telle quelle, même pour de très grands nombres.

a = 10 ** 30
b = 7
a = a + b
b = a - b
a = a - b
print(a, b)

7 1000000000000000000000000000000

Vérification. Avec les valeurs de la question 1, on retrouve bien l'échange :

a = 3
b = 8
a = a + b
b = a - b
a = a - b
print(a, b)

8 3

La démonstration utilise $(\alpha+\beta)-\beta=\alpha$, vrai pour les réels. Mais 0.1 + 0.2 n'est pas calculé exactement (voir A4) : c'est le flottant 0.30000000000000004, et l'erreur d'arrondi de la somme ne s'annule pas quand on retranche.

a = 0.1
b = 0.2
a = a + b
b = a - b
a = a - b
print(a, b)
print(b == 0.1)

0.2 0.10000000000000003
False

a a bien reçu 0.2, mais b n'a pas récupéré 0.1 : l'échange est faux. Sur des nombres d'ordres de grandeur très différents, c'est pire. Au voisinage de $10^{16}$, deux flottants consécutifs sont espacés de $2$ : ajouter $1$ ne change rien, et la petite valeur est entièrement perdue.

a = 1e16
b = 1.0
print(a + b == a)
a = a + b
b = a - b
a = a - b
print(a, b)

True
0.0 1e+16

Vérification. La première ligne affichée, True, montre la cause : a + b est égal à a, le $1$ a disparu dès la première affectation. Conclusion : la méthode arithmétique est un bel exercice de raisonnement, pas une méthode à employer. On échange avec t ou avec a, b = b, a.

Écrasement. Une affectation remplace l'ancienne valeur, qui n'est plus accessible ensuite.

Échange par variable temporaire : t = a, puis a = b, puis b = t. Trois affectations, valables pour toutes les valeurs.

Affectation multiple : a, b = e1, e2 évalue e1 et e2 avec les valeurs actuelles, puis range les résultats. D'où l'échange a, b = b, a.

Entiers et flottants. Les entiers de Python sont exacts, sans taille maximale. Les flottants sont des approximations à $53$ chiffres binaires significatifs : une identité vraie sur les réels peut devenir fausse sur les flottants.

⚠️ Échanger par deux affectations. a = b puis b = a produit deux copies de la même valeur, quel que soit l'ordre.

⚠️ Tester un échange sur deux valeurs égales. Avec a et b valant tous deux $5$, l'échange naïf « marche » :

a = 5
b = 5
a = b
b = a
print(a, b)

5 5

Le test passe et le programme est faux : un cas test où les deux valeurs sont égales ne peut pas le démasquer. Pour tester un échange, prends deux valeurs différentes, et regarde les deux.

⚠️ Croire qu'une démonstration sur les réels vaut pour les flottants. La méthode arithmétique est juste sur $\mathbb{R}$ et sur les entiers de Python, fausse sur les flottants.

// donne le quotient entier, % le reste, / un flottant. Pour un dividende négatif et $b>0$, cherche le reste $r$ tel que $0\leq r<b$ ; quand le diviseur est négatif, pars de l'identité a == b * (a // b) + a % b.

Le chiffre des unités est le reste de la division par $10$ ; diviser par $10$ avec // efface ce chiffre.

Une heure fait $3600$ secondes : commence par le quotient de s par $3600$, puis travaille sur le reste.

Python a trois divisions, et les confondre est la première source d'erreurs de calcul.

• a / b est la division décimale : elle renvoie toujours un flottant, même quand la division tombe juste.
• a // b est le quotient entier.
• a % b est le reste.

Les deux dernières sont liées par l'identité de la division euclidienne, a == b * (a // b) + a % b, que Python garantit pour tous les entiers $a$ et $b\neq0$. Quand $b>0$, le reste vérifie de plus $0\leq r<b$ : c'est exactement la division euclidienne du cours, prolongée aux entiers négatifs.

👉 La conséquence à retenir : quand $b>0$, a // b arrondit $a/b$ vers le bas (vers $-\infty$), et non vers zéro. Sur les nombres positifs, tu ne verras aucune différence ; sur les négatifs, si.

print(17 // 5, 17 % 5, 17 / 5)
print(-7 // 2, -7 % 2)
print(7 // -2, 7 % -2)

3 2 3.4
-4 1
-4 -1

Ligne 1. $17=5\times3+2$ avec $0\leq2<5$ : quotient $3$, reste $2$. La division décimale donne le flottant 3.4.

Ligne 2. $-7/2=-3{,}5$. Python choisit le quotient $-4$ et le reste $1$, car $-7=2\times(-4)+1$ avec $0\leq1<2$. Le couple $(-3,-1)$ vérifierait aussi $-7=2q+r$, mais avec un reste négatif : ce n'est pas la division euclidienne.

Ligne 3. Le diviseur est négatif. Python garde l'identité et donne au reste le signe du diviseur : $7=(-2)\times(-4)+(-1)$.

Vérification. Le cas où la division tombe juste ne doit laisser aucun reste, et / doit malgré tout rendre un flottant :

print(-8 // 2, -8 % 2, 6 / 3)

-4 0 2.0

On la contrôle par des assert : une instruction assert condition ne fait rien si la condition est vraie, et arrête le programme sinon.

assert 17 == 5 * (17 // 5) + 17 % 5
assert -7 == 2 * (-7 // 2) + -7 % 2
assert 7 == -2 * (7 // -2) + 7 % -2
print('identité vérifiée')

identité vérifiée

Le programme atteint sa dernière ligne : les trois identités sont vraies.

Pourquoi c'est un arrondi vers le bas. Soit $b>0$, $q$ = a // b et $r$ = a % b, avec $a=bq+r$ et $0\leq r<b$. En divisant par $b>0$ : $\frac ab=q+\frac rb$ avec $0\leq\frac rb<1$, donc $q\leq\frac ab<q+1$, c'est-à-dire

print(-7 // 2, int(-7 / 2))

-4 -3

Vérification. Sur un couple de positifs, les deux arrondis coïncident, et sur un couple négatif le quotient et le reste redonnent bien $a$ :

a = -7
b = 2
q = a // b
r = a % b
print(q, r, b * q + r)
print(0 <= r < b)
print(17 // 5 == int(17 / 5))

-4 1 -7
True
True

Pour $n\geq0$, $n=10\times(n\ //\ 10)+(n\ \%\ 10)$ avec un reste entre $0$ et $9$ : le reste par $10$ est le chiffre des unités, et le quotient par $10$ est $n$ privé de ce chiffre. On recommence sur le quotient pour obtenir les dizaines, et ainsi de suite.

n = 4827
u = n % 10
d = (n // 10) % 10
c = (n // 100) % 10
m = n // 1000
print(m, c, d, u)
print(1000*m + 100*c + 10*d + u)

4 8 2 7
4827

Pour $4827$ : le chiffre des centaines est $8$, celui des dizaines $2$, celui des unités $7$. Par exemple n // 100 vaut $48$, dont le reste par $10$ est $8$.

Vérification. La deuxième ligne affichée reconstruit $n$ à partir de ses chiffres : on retrouve bien $4827$. Ce découpage par % et // est l'algorithme qu'on répétera dans une boucle au lot B, pour traiter un entier de longueur quelconque.

On retire d'abord les heures entières, puis on découpe le reste en minutes et secondes.

s = 10000
h = s // 3600
reste = s % 3600
m = reste // 60
sec = reste % 60
print(h, m, sec)
print(3600 * h + 60 * m + sec)

2 46 40
10000

$10000=3600\times2+2800$, puis $2800=60\times46+40$ : la durée vaut 2 h 46 min 40 s.

Vérification. La dernière ligne recalcule le nombre total de secondes à partir du résultat et retrouve $10000$. Les restes ont aussi la bonne taille : $46<60$ et $40<60$, comme il se doit pour des minutes et des secondes.

Division euclidienne. Pour $a\in\mathbb{Z}$ et $b\in\mathbb{N}^*$, il existe un unique couple d'entiers $(q,r)$ tel que $a=bq+r$ et $0\leq r<b$ ; alors $q=\lfloor a/b\rfloor$. En Python, a // b vaut $q$ et a % b vaut $r$. (Voir le chapitre d'arithmétique.)

Diviseur négatif. Python garde l'identité a == b * (a // b) + a % b et donne au reste le signe du diviseur : 7 % -2 vaut -1.

Division décimale. a / b renvoie un flottant, même quand $b$ divise $a$.

Chiffres. Pour $n\geq0$, n % 10 est le chiffre des unités de $n$, et n // 10 efface ce chiffre.

⚠️ Croire que // tronque vers zéro. -7 // 2 vaut -4, pas -3 ; la troncature, c'est int(-7 / 2). D'autres langages, comme C ou Java, tronquent vers zéro : un algorithme recopié d'un autre langage peut changer de résultat sur les nombres négatifs.

⚠️ Utiliser / là où il faut //. Le résultat de / est un flottant ; or un indice de liste, un nombre de tours de boucle ou un nombre d'objets doit être un entier. Et sur de grands nombres, passer par un flottant fait perdre des chiffres :

n = 10 ** 17
print(n // 3)
print(int(n / 3))

33333333333333333
33333333333333332

La première ligne est exacte ; la seconde est fausse au dernier chiffre, parce que n / 3 a été arrondi à un flottant, qui ne garde que $53$ chiffres binaires. Pour une division entière, on écrit //, jamais int(… / …).

⚠️ Diviser par zéro. a // 0 et a % 0 arrêtent le programme sur une ZeroDivisionError, comme a / 0.

Un nombre à écriture binaire finie s'écrit $\frac{m}{2^k}$ avec $m$ et $k$ entiers. Peut-on écrire $\frac1{10}$ ainsi ?

$0{,}5$, $0{,}25$ et $0{,}75$ sont des fractions dont le dénominateur est une puissance de $2$.

Deux flottants sont « égaux à une tolérance près » quand la valeur absolue de leur différence est petite : abs(x - y) < eps.

Un flottant est un nombre à virgule écrit en base $2$, avec un nombre fixe de chiffres. Python range un nombre comme 0.1 sous la forme $m\times2^e$, où $m$ est un entier d'au plus $53$ chiffres binaires (norme IEEE 754, dite « double précision »). Tout réel qui ne s'écrit pas exactement ainsi est arrondi au flottant le plus proche — et c'est le cas de $0{,}1$, de $0{,}2$ et de $0{,}3$. Chaque opération arrondit ensuite son résultat : les petites erreurs s'ajoutent, et parfois se compensent.

Python n'est pas en cause : la plupart des langages utilisent ces mêmes flottants et donnent les mêmes résultats.

👉 La conséquence pratique, à appliquer sans exception : on ne teste jamais l'égalité de deux flottants issus d'un calcul avec == ; on teste que leur écart est petit.

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(0.5 + 0.25 == 0.75)

0.30000000000000004
False
True

0.1 et 0.2 sont déjà des approximations ; leur somme, arrondie à son tour, tombe sur le flottant voisin de celui qui approche le mieux $0{,}3$. Les deux flottants comparés par == sont différents : le test rend False. print affiche le plus court nombre décimal qui désigne sans ambiguïté un flottant ; c'est pourquoi 0.1 s'affiche 0.1, alors que la valeur rangée n'est pas exactement $\frac1{10}$, et pourquoi la somme s'affiche avec tous ses chiffres.

Vérification. L'écart entre les deux flottants est minuscule, et c'est exactement $2^{-54}$, l'espacement des flottants entre $0{,}25$ et $0{,}5$ : ils sont consécutifs.

print(0.1 + 0.2 - 0.3)
print(0.1 + 0.2 - 0.3 == 2 ** -54)

5.551115123125783e-17
True

Une écriture binaire finie $0{,}b_1b_2\dots b_k$ représente le nombre $\frac{m}{2^k}$, où $m$ est l'entier qui s'écrit $b_1b_2\dots b_k$ en base $2$. Supposons $\frac1{10}=\frac{m}{2^k}$ avec $m$ et $k$ entiers. Alors $2^k=10m=2\times5\times m$, donc $5$ divise $2^k=2\times2\times\dots\times2$. C'est impossible : un nombre premier qui divise un produit divise l'un des facteurs (lemme d'Euclide, conséquence du théorème de Gauss, voir le chapitre d'arithmétique), et $5$ ne divise pas $2$. $\blacksquare$

C'est le même phénomène que $\frac13=0{,}333\dots$ en base $10$ : l'écriture existe, mais elle ne s'arrête jamais. Le même raisonnement, appuyé sur le théorème de Gauss, donne le critère général : un rationnel irréductible $\frac pq$ a une écriture binaire finie si et seulement si $q$ est une puissance de $2$. $0{,}5=\frac12$, $0{,}25=\frac14$ et $0{,}75=\frac34$ sont dans ce cas : ils sont rangés exactement, leur somme aussi, et 0.5 + 0.25 == 0.75 vaut True. $0{,}1=\frac1{10}$, $0{,}2=\frac15$ et $0{,}3=\frac3{10}$ ne le sont pas.

Vérification. On peut calculer les chiffres binaires de $\frac1{10}$ avec des entiers, donc sans aucune erreur d'arrondi : on double le numérateur, le chiffre est le quotient par $10$, et on garde le reste.

p = 1
q = 10
for k in range(12):
    p = 2 * p
    print(p // q, end='')
    p = p % q
print()

000110011001

On lit $\frac1{10}=0{,}000110011001\dots$ en base $2$ : après le premier chiffre, le motif $0011$ se répète. Les restes successifs valent $2, 4, 8, 6$, puis de nouveau $2$ : le calcul repasse par le même état, donc les chiffres se répètent indéfiniment, comme le prévoit la démonstration.

On déclare deux flottants égaux quand leur écart est plus petit qu'une tolérance eps choisie à l'avance :

x = 0.1 + 0.2
y = 0.3
eps = 1e-9
print(abs(x - y) < eps)
print(abs(0.3 - 0.31) < eps)

True
False

eps doit être bien plus grand que les erreurs d'arrondi (ici de l'ordre de $10^{-16}$) et bien plus petit que les écarts qui ont un sens pour le problème. La deuxième ligne sert de contre-témoin : deux nombres réellement différents ne sont pas déclarés égaux.

Une tolérance absolue comme $10^{-9}$ n'a de sens que pour des nombres de l'ordre de l'unité. Pour des nombres de tailles quelconques, on compare l'écart à la taille des nombres : c'est ce que fait math.isclose, dont la tolérance relative vaut $10^{-9}$ par défaut.

import math
print(math.isclose(0.1 + 0.2, 0.3))
d = 0.1 + 0.2 - 0.3
print(math.isclose(d, 0))

True
False

Vérification. La dernière ligne montre la limite d'une tolérance purement relative : comparé à $0$, un nombre non nul n'est jamais « proche », puisque l'écart admis est proportionnel à la taille des nombres, ici nulle. Pour tester qu'un résultat est presque nul, on revient à abs(d) < eps.

s = 0
for k in range(10):
    s = s + 0.1
print(s)
print(s == 1)

0.9999999999999999
False

(La boucle for répète dix fois l'instruction décalée ; elle est détaillée au lot B.) Chaque addition arrondit son résultat, et les erreurs s'accumulent : après dix additions, la somme est juste en dessous de $1$.

Vérification. On fait afficher la somme après chaque addition :

s = 0
for k in range(10):
    s = s + 0.1
    print(k + 1, s)

1 0.1
2 0.2
3 0.30000000000000004
4 0.4
5 0.5
6 0.6
7 0.7
8 0.7999999999999999
9 0.8999999999999999
10 0.9999999999999999

L'écart apparaît dès la troisième addition. À la quatrième, les arrondis se compensent et la somme retombe sur le flottant le plus proche de $0{,}4$ — qui n'est pas exactement $0{,}4$, mais s'affiche 0.4. À partir de la huitième, la somme s'écarte de nouveau et ne revient plus. Quand la grandeur est décimale par nature (des centimes, des dixièmes), le remède est de compter en entiers : dix fois $1$ dixième font exactement $10$ dixièmes, et 10 / 10 vaut 1.0.

Flottant. Un float Python est un nombre de la forme $m\times2^e$ avec $m$ entier d'au plus $53$ chiffres binaires ; les autres réels sont arrondis au plus proche, et chaque opération arrondit son résultat.

Rationnels représentables. Un rationnel irréductible $\frac pq$ a une écriture binaire finie si et seulement si $q$ est une puissance de $2$ : $0{,}5$, $0{,}25$, $0{,}75$ oui ; $0{,}1$, $0{,}2$, $0{,}3$ non.

Comparer. abs(x - y) < eps (tolérance absolue) ou math.isclose(x, y) (tolérance relative, $10^{-9}$ par défaut). Jamais == entre flottants calculés.

Affichage. print affiche le plus court nombre décimal qui désigne le flottant sans ambiguïté : 0.1 s'affiche 0.1, bien que la valeur rangée ne soit pas $\frac1{10}$.

⚠️ Arrêter une boucle sur une égalité de flottants. La boucle ci-dessous devait s'arrêter quand x atteint $1$ ; or x passe de 0.9999999999999999 à 1.0999999999999999 sans jamais valoir exactement $1$, et le programme ne termine pas :

x = 0
while x != 1:
    x = x + 0.1

Remplacer != par < ne suffit pas : la boucle termine, mais elle fait un tour de trop.

x = 0
n = 0
while x < 1:
    x = x + 0.1
    n = n + 1
print(n, x)

11 1.0999999999999999

Après dix tours, x vaut 0.9999999999999999, qui est encore strictement inférieur à $1$ : la boucle repart pour un onzième tour. Quand on sait combien de tours faire, on compte avec un entier — for k in range(10) — et le flottant n'intervient plus dans la décision d'arrêt.

⚠️ Choisir une tolérance sans regarder l'ordre de grandeur. $10^{-9}$ est énorme pour des nombres de l'ordre de $10^{-12}$ et dérisoire pour des nombres de l'ordre de $10^{12}$.

Du plus prioritaire au moins prioritaire : parenthèses, puissance **, signe moins, puis * et /, puis + et -.

** se regroupe de droite à gauche ; - et / se regroupent de gauche à droite.

Une barre de fraction groupe tout son numérateur et tout son dénominateur : sur une ligne, il faut des parenthèses pour chacun.

Une expression Python est une formule écrite sur une seule ligne : plus de barre de fraction, plus d'exposant surélevé. C'est l'ordre des priorités qui décide alors de la structure. Il prolonge celui des mathématiques : les parenthèses d'abord, puis la puissance **, puis le signe moins placé devant un nombre, puis *, /, //, %, puis + et -. À priorité égale, on regroupe de gauche à droite — sauf pour **, qui se regroupe de droite à gauche.

Deux conséquences surprennent : la puissance passe avant le signe moins écrit devant elle, et 2 ** 3 ** 2 se lit $2^{(3^2)}$. Ces deux règles sont d'ailleurs celles des mathématiques : $-2^2=-4$ et $2^{3^2}=2^9$.

👉 La règle pratique : dès qu'une barre de fraction ou un exposant disparaît en passant sur une ligne, tu remets les parenthèses que la barre rendait inutiles.

print(2 + 3 * 4)
print(-2 ** 2)
print(2 ** 3 ** 2)
print(7 - 3 - 2)
print(12 / 2 * 3)

14
-4
512
2
18.0

La dernière ligne rend un flottant, 18.0, parce que / rend toujours un flottant (voir A3).

Vérification. Si les priorités ont été bien lues, placer les parenthèses autrement doit changer chaque valeur :

print((-2) ** 2)
print((2 ** 3) ** 2)
print(7 - (3 - 2))
print(12 / (2 * 3))

4
64
6
2.0

Les quatre valeurs changent : les parenthèses ne sont pas décoratives.

a + b / 2 se lit $a+\frac b2=8+7$ : la division passe avant l'addition, et seul b est divisé.

a = 8
b = 14
print(a + b / 2)

15.0

La moyenne $\frac{a+b}{2}$ a un numérateur entier ; sur une ligne, il faut le parenthéser :

a = 8
b = 14
m = (a + b) / 2
print(m)
print(min(a, b) <= m <= max(a, b))

11.0
True

Vérification. Une moyenne est toujours comprise entre la plus petite et la plus grande valeur : la dernière ligne le confirme pour $11$. Le résultat fautif, $15$, dépasse $14$ : ce test de vraisemblance, d'une ligne, suffisait à le démasquer.

$\Delta=b^2-4ac=9+40=49$ : cette ligne de l'élève est juste. La suivante se lit $-b+\left(\frac{\sqrt\Delta}{2}\right)\times a$ : on divise par $2$ puis on multiplie par $a$, et $-b$ n'est pas divisé du tout. Deux erreurs de parenthèses, et un résultat de $3+3{,}5\times2=10$ :

import math
a = 2
b = -3
c = -5
d = b ** 2 - 4 * a * c
x1 = -b + math.sqrt(d) / 2 * a
print(d, x1)

49 10.0

La formule $\dfrac{-b\pm\sqrt\Delta}{2a}$ a un numérateur et un dénominateur à parenthéser :

import math
a = 2
b = -3
c = -5
d = b ** 2 - 4 * a * c
r = math.sqrt(d)
x1 = (-b + r) / (2 * a)
x2 = (-b - r) / (2 * a)
print(d, x1, x2)
print(a*x1**2 + b*x1 + c)
print(a*x2**2 + b*x2 + c)

49 2.5 -1.0
0.0
0.0

Vérification. Les deux dernières lignes réinjectent les racines dans le trinôme : $2\times2{,}5^2-3\times2{,}5-5=12{,}5-7{,}5-5=0$ et $2+3-5=0$. Dans a*x1**2, la puissance passe avant la multiplication : c'est bien $a\times x_1^2$.

Une subtilité au passage : b ** 2 vaut $9$, parce que la variable b contient $-3$ ; mais écrire directement -3 ** 2 donne $-9$, le signe moins s'appliquant après la puissance :

b = -3
print(b ** 2, -3 ** 2)

9 -9

print(9 ** 1 / 2)
print(9 ** (1 / 2))

4.5
3.0

9 ** 1 / 2 se lit $\frac{9^1}{2}=4{,}5$ : la puissance passe avant la division. 9 ** (1 / 2) calcule $9^{1/2}=\sqrt9=3$. Pour une racine carrée, le plus lisible reste math.sqrt, ou x ** 0.5 quand x est positif ou nul.

Vérification. Par deux autres chemins : la racine obtenue, élevée au carré, redonne $9$, et math.sqrt donne la même valeur.

import math
r = 9 ** (1 / 2)
print(r ** 2, math.sqrt(9))

9.0 3.0

Priorités, de la plus forte à la plus faible : parenthèses ; ** ; signe - placé devant ; *, /, //, % ; +, - ; puis les comparaisons, not, and, or (voir A6).

Regroupement. ** se regroupe de droite à gauche : 2 ** 3 ** 2 vaut $2^9$. Tous les autres opérateurs arithmétiques se regroupent de gauche à droite : 7 - 3 - 2 vaut $(7-3)-2$.

Traduire une fraction. $\frac{a+b}{c+d}$ s'écrit (a + b) / (c + d) ; $\frac{-b+\sqrt\Delta}{2a}$ s'écrit (-b + math.sqrt(d)) / (2 * a).

⚠️ Oublier les parenthèses du dénominateur. x / 2 * a divise par $2$ puis multiplie par $a$ : 12 / 2 * 3 vaut 18.0, pas 2.0. Le dénominateur $2a$ s'écrit (2 * a).

⚠️ Confondre -2 ** 2 et (-2) ** 2. Le premier vaut $-4$, le second $4$.

⚠️ Écrire ^ pour la puissance, par habitude de la calculatrice ou du tableur. En Python, ^ est une autre opération sur les entiers (le « ou exclusif » bit à bit) : le programme tourne, sans aucun message, et donne un résultat faux.

x = 2
print(x ^ 3)
print(x ** 3)

1
8

La première ligne devait afficher $2^3=8$ ; elle affiche $1$. La puissance s'écrit **.

Les comparaisons se calculent avant not, not avant and, and avant or.

A and B ne calcule pas B quand A est faux : le résultat est déjà connu.

La négation d'un « et » est un « ou » : c'est l'une des lois de Morgan.

Une condition est une expression comme une autre : elle se calcule, et sa valeur est un booléen, True ou False. Les comparaisons (<, ==, !=…) fabriquent des booléens ; and, or et not les combinent, avec les tables de vérité des connecteurs « et », « ou » (inclusif) et « non » de la logique.

Deux traits sont propres à Python. On peut enchaîner les comparaisons comme en mathématiques : 0 < x < 1 signifie 0 < x and x < 1. Et and, or sont paresseux : ils ne calculent leur second membre que si le premier ne suffit pas à conclure.

👉 En logique, « $P$ et $Q$ » et « $Q$ et $P$ » sont équivalents ; en Python, l'ordre des membres d'un and compte dès que le second peut échouer. Tu places d'abord la condition qui protège l'autre — « x non nul » avant la division par x.

x = 0.5
print(0 < x < 1)
print(0 < x and x < 1)
print(not x > 0 or x == 1)
print(x > 1 or x < 0)

True
True
False
False

Les deux premières lignes disent la même chose, l'une en notation enchaînée, l'autre avec and : $0<0{,}5<1$ est vrai. La troisième se lit, d'après les priorités, (not (x > 0)) or (x == 1) : $x>0$ est vrai, donc sa négation est fausse, et $x=1$ est faux ; le « ou » de deux faux est faux. La quatrième dit que $x$ est hors de $[0,1]$ : faux pour $0{,}5$.

Vérification. Pour s'assurer que not s'applique avant or, on choisit une valeur qui sépare les deux lectures possibles de la troisième ligne affichée — avec $x=0{,}5$, elles donnent toutes deux False, donc ce test ne prouverait rien. Avec $x=1$ :

x = 1
print(not x > 0 or x == 1)
print((not x > 0) or x == 1)
print(not (x > 0 or x == 1))

True
True
False

La ligne sans parenthèses coïncide avec la première lecture, pas avec la seconde : Python applique bien not avant or.

Avec x valant $0$, dans x != 0 and 1 / x > 2, le premier membre x != 0 est faux ; un « et » dont un membre est faux est faux, donc Python conclut False sans calculer 1 / x.

x = 0
b1 = x != 0 and 1 / x > 2
print(b1)

False

Dans l'ordre inverse, Python commence par 1 / x et s'arrête sur une division par zéro :

x = 0
b2 = 1 / x > 2 and x != 0
print(b2)

ZeroDivisionError: division by zero

Même principe pour or : dans A or B, si A est vrai, le résultat est vrai et B n'est pas calculé.

x = 0
print(x == 0 or 1 / x > 2)

True

Vérification. Quand $x\neq0$, les deux ordres doivent donner la même valeur — seul le cas $x=0$ les sépare. Avec $x=0{,}25$, on a $\frac1x=4>2$ :

x = 0.25
print(x != 0 and 1 / x > 2)
print(1 / x > 2 and x != 0)

True
True

$x\in[0,1]$ s'écrit 0 <= x <= 1, c'est-à-dire 0 <= x and x <= 1. Sa négation, par la loi de Morgan « non ($P$ et $Q$) équivaut à (non $P$) ou (non $Q$) », est « non ($0\leq x$) ou non ($x\leq1$) », soit $x<0$ ou $x>1$ :

h = x < 0 or x > 1

On la teste contre la condition initiale sur les cinq valeurs demandées ; l'assert arrêterait le programme si les deux conditions n'étaient pas contraires.

for x in [-1, 0, 0.5, 1, 2]:
    d = 0 <= x <= 1
    h = x < 0 or x > 1
    assert h == (not d)
    print(x, d, h)

-1 False True
0 True False
0.5 True False
1 True False
2 False True

Vérification. Les deux colonnes sont contraires sur toutes les lignes, y compris aux bornes $0$ et $1$ : ces bornes appartiennent à $[0,1]$, d'où les inégalités strictes dans la négation. Les lois de Morgan sont démontrées au chapitre Raisonnement, par tables de vérité ; ici on les applique, et le programme les contrôle sur des instances.

On écrit les trois inégalités strictes, reliées par and. Pour la tester sur trois triplets sans recopier la condition, on la place dans une fonction (les fonctions sont étudiées au lot E) :

def triangle(a, b, c):
    t1 = a < b + c
    t2 = b < a + c
    t3 = c < a + b
    return t1 and t2 and t3

print(triangle(3, 4, 5))
print(triangle(1, 2, 3))
print(triangle(1, 1, 5))

True
False
False

$(3,4,5)$ vérifie les trois inégalités. $(1,2,3)$ échoue sur la troisième, $3<1+2$, qui est une égalité : ces trois longueurs donnent un triangle aplati, dont les trois sommets sont alignés. $(1,1,5)$ échoue aussi sur la troisième : $5$ est plus long que $1+1$.

Vérification. Le cas aplati est le seul qui distingue les inégalités strictes des inégalités larges : avec <=, il serait accepté.

print(3 < 1 + 2, 3 <= 1 + 2)

False True

Booléens. True et False ; les comparaisons ==, !=, <, <=, >, >= en produisent.

Connecteurs. A and B est vrai si les deux le sont ; A or B est vrai si l'un au moins l'est ; not A échange vrai et faux. Priorités : les comparaisons, puis not, puis and, puis or.

Évaluation paresseuse. A and B ne calcule pas B si A est faux ; A or B ne calcule pas B si A est vrai.

Comparaisons enchaînées. a < b < c signifie a < b and b < c.

Lois de Morgan. not (A and B) équivaut à not A or not B, et not (A or B) à not A and not B.

⚠️ Écrire x == 1 or 2 pour « x vaut $1$ ou $2$ ». Python lit (x == 1) or 2. Quand x == 1 est faux, or renvoie son second membre, le nombre $2$, qu'un if considère comme vrai (tout nombre non nul compte comme vrai). Le test passe donc toujours :

x = 3
print(x == 1 or 2)
print(x == 1 or x == 2)

2
False

La bonne écriture répète la comparaison : x == 1 or x == 2.

⚠️ Nier un « et » en gardant « et ». Pour « $x$ hors de $[0,1]$ », la condition x < 0 and x > 1 n'est jamais vraie : aucun nombre n'est à la fois négatif et plus grand que $1$.

x = 2
print(x < 0 and x > 1)

False

$2$ est pourtant hors de $[0,1]$. La négation d'un « et » est un « ou ».

Un if … elif … else examine ses conditions dans l'ordre et s'arrête à la première vraie : la condition d'un elif n'est lue que si toutes les précédentes sont fausses.

Toute année divisible par $100$ l'est aussi par $4$. Dans la fonction de l'élève, quelle branche reçoit $1900$ ?

Range les tests du plus particulier au plus général : $400$, puis $100$, puis $4$. Pour la question 4, un compteur dans une boucle for suffit.

Un if … elif … else est une suite de filtres essayés dans l'ordre. Python évalue la première condition ; si elle est vraie, il exécute son bloc et saute tout le reste ; sinon il passe à l'elif suivant. Chaque branche ne reçoit donc que les cas que les branches précédentes ont laissé passer : la condition d'un elif porte, sans l'écrire, « et aucune des conditions précédentes n'était vraie ».

C'est pourquoi l'ordre des tests fait partie de l'algorithme. Quand les conditions s'emboîtent — ici, divisible par $400$ entraîne divisible par $100$, qui entraîne divisible par $4$ —, il faut tester du plus particulier au plus général. Dans l'ordre inverse, le test le plus large capture tout, et les branches suivantes ne sont jamais atteintes : ce sont des branches mortes.

👉 Ce qu'on retient : avant d'écrire une cascade de tests, se demander quelle condition en contient une autre, et mettre la plus étroite en premier. Puis vérifier avec un jeu de tests qui passe par chaque branche.

On teste $400$ d'abord, puis $100$, puis $4$ :

def bissextile(a):
    if a % 400 == 0:
        return True
    elif a % 100 == 0:
        return False
    elif a % 4 == 0:
        return True
    else:
        return False

print(bissextile(2024))
print(bissextile(2023))
print(bissextile(1900))
print(bissextile(2000))

Il affiche :

True
False
False
True

Lecture branche par branche. $2024$ n'est divisible ni par $400$ ni par $100$ : les deux premiers tests échouent, le troisième réussit ($2024=4\times506$). $2023$ est impair : il tombe dans le else. $1900=19\times100$ est arrêté par le deuxième test, puisqu'il n'est pas divisible par $400$ ($1900=4\times400+300$). $2000=5\times400$ est pris dès le premier test.

Une autre écriture. La règle est une formule booléenne ; on peut la renvoyer directement, sans if :

def bis2(a):
    b4 = a % 4 == 0
    b100 = a % 100 == 0
    b400 = a % 400 == 0
    return b4 and (not b100 or b400)

for a in [2024, 2023, 1900, 2000]:
    print(a, bis2(a))

2024 True
2023 False
1900 False
2000 True

Mêmes réponses. La cascade de tests garde un avantage pédagogique : chaque branche correspond à une ligne de la règle, et se teste isolément.

On relance la fonction de l'élève sur les deux années :

def bissextile(a):
    if a % 4 == 0:
        return True
    elif a % 100 == 0:
        return False
    elif a % 400 == 0:
        return True
    else:
        return False

print(bissextile(1900))
print(bissextile(2000))

True
True

$1900$ est déclarée bissextile : c'est faux, le 29 février 1900 n'a pas existé. $2000$ est déclarée bissextile : c'est juste, mais par hasard.

Le mécanisme. $1900$ est divisible par $4$ ($1900=4\times475$), donc le premier test est vrai et la fonction renvoie True sans jamais regarder la divisibilité par $100$. Ce n'est pas un accident propre à $1900$ : toute année divisible par $100$ est divisible par $4$ (car $100=4\times25$), donc elle est toujours capturée par le premier test. Le deuxième test n'est atteint que par une année non divisible par $4$, qui n'est jamais divisible par $100$ : il est toujours faux. Même chose pour le troisième. Les branches elif a % 100 == 0 et elif a % 400 == 0 sont mortes : on pourrait les effacer sans rien changer, et la fonction se réduit à « divisible par $4$ ».

$2000$ reçoit la bonne réponse parce que « divisible par $4$ » et la vraie règle coïncident sur les multiples de $400$ ; elles ne diffèrent que sur les multiples de $100$ qui ne sont pas multiples de $400$ : $1700$, $1800$, $1900$, $2100$…

Correction. Garder les trois tests mais inverser leur ordre ($400$, $100$, $4$) : c'est la fonction de la question 1.

Quatre branches, donc quatre années au moins, chacune choisie pour atterrir dans une branche différente de la bonne fonction :

On écrit ces attendus sous forme d'assert : assert c ne fait rien si c est vrai, et arrête le programme sinon. Un programme dont tous les assert passent n'affiche rien et se termine normalement — c'est le signe que les tests réussissent.

def bissextile(a):
    if a % 400 == 0:
        return True
    elif a % 100 == 0:
        return False
    elif a % 4 == 0:
        return True
    else:
        return False

assert bissextile(2000)
assert not bissextile(1900)
assert bissextile(2024)
assert not bissextile(2023)

Le même jeu de tests, appliqué à la fonction de l'élève, s'arrête sur l'année $1900$ :

def bissextile(a):
    if a % 4 == 0:
        return True
    elif a % 100 == 0:
        return False
    elif a % 400 == 0:
        return True
    else:
        return False

assert bissextile(2000)
assert not bissextile(1900)
assert bissextile(2024)
assert not bissextile(2023)

AssertionError

Le jeu de tests démasque l'erreur parce qu'il contient une année de la deuxième branche. Un jeu réduit à $2024$, $2023$ et $2000$ aurait reçu trois réponses justes et laissé passer la fonction fausse : tester n'est probant que si chaque branche est exercée.

On compte avec un compteur dans une boucle for :

def bissextile(a):
    if a % 400 == 0:
        return True
    elif a % 100 == 0:
        return False
    elif a % 4 == 0:
        return True
    else:
        return False

n = 0
for a in range(1601, 2001):
    if bissextile(a):
        n = n + 1
print(n)

97

Recoupement par le calcul. De $1601$ à $2000$ il y a $400$ années, dont $100$ multiples de $4$ ; on retire les $4$ multiples de $100$ ($1700$, $1800$, $1900$, $2000$) et on rend le seul multiple de $400$ ($2000$) : $100-4+1=97$. ✓ La fonction de l'élève en compterait $100$ : elle se trompe exactement sur $1700$, $1800$ et $1900$.

Durée moyenne. Quatre siècles comptent $400\times365+97=146\,097$ jours, soit une année moyenne de $146\,097/400=365{,}2425$ jours — c'était le but de la réforme grégorienne de 1582 : coller à l'année des saisons. Et $146\,097$ est divisible par $7$ : quatre siècles font un nombre entier de semaines, si bien que le calendrier grégorien se répète à l'identique, jours de la semaine compris, tous les $400$ ans.

j = 400 * 365 + 97
print(j, j / 400, j % 7, j // 7)

146097 365.2425 0 20871

Conditionnelle. if C1: … elif C2: … else: … exécute le bloc de la première condition vraie, et un seul ; le else reçoit tout ce que les conditions ont laissé passer. La branche elif C2 s'exécute si et seulement si C1 est fausse et C2 vraie.

Ordre des tests. Si une condition en entraîne une autre (ici $400\mid a\Rightarrow100\mid a\Rightarrow4\mid a$), la plus particulière doit venir en premier ; sinon les suivantes sont inatteignables.

Tester une fonction. Un jeu de tests doit faire passer le programme par chaque branche, et viser les cas limites. assert condition ne fait rien si la condition est vraie et arrête le programme sur une AssertionError sinon.

⚠️ Écrire les tests dans l'ordre où on lit la règle. La phrase « divisible par $4$, sauf les multiples de $100$, sauf les multiples de $400$ » commence par le cas le plus général ; recopiée telle quelle en cascade de elif, elle produit exactement la fonction de l'élève. Une règle à exceptions se programme en commençant par l'exception la plus rare.

⚠️ Mélanger deux styles. Avec des if indépendants qui modifient une variable, c'est le dernier test vrai qui l'emporte, et l'ordre juste s'inverse : du plus général au plus particulier.

def bis3(a):
    r = False
    if a % 4 == 0:
        r = True
    if a % 100 == 0:
        r = False
    if a % 400 == 0:
        r = True
    return r

for a in [2024, 2023, 1900, 2000]:
    print(a, bis3(a))

2024 True
2023 False
1900 False
2000 True

Écrire ces trois if dans l'ordre $400$, $100$, $4$ serait faux ; écrire la cascade d'elif dans l'ordre $4$, $100$, $400$ l'est aussi. Chaque style a son ordre : il faut savoir lequel on écrit.

⚠️ Ne tester que des années « faciles ». $2024$ et $2023$ passent avec les deux versions ; ce sont les années séculaires ($1900$, $2000$) qui départagent.

Trois cas qui s'excluent : un if, un elif, un else. Pour l'ordre croissant, demande-toi lequel des deux quotients $\frac{-b\pm\sqrt\Delta}{2a}$ est le plus petit quand $a<0$.

Reporter une racine $x$ dans le trinôme, c'est calculer a * x * x + b * x + c : attends-toi à un résultat très petit, pas forcément nul.

Avec des entiers, b * b - 4 * a * c est calculé exactement et le test d == 0 est fiable. Avec des flottants, $0{,}2^2$ n'est pas exactement $0{,}04$.

Trois cas qui s'excluent, donc un if, un elif, un else. Le signe du discriminant $\Delta$ décide de tout : $\Delta>0$ donne deux racines, $\Delta=0$ une racine double, $\Delta<0$ aucune racine réelle. La cascade de tests traduit exactement ce tableau de cas, et le else n'a pas besoin de condition : il reçoit $\Delta<0$, le seul cas restant.

Deux détails transforment la formule du cours en programme correct. D'abord une garde : la formule divise par $2a$, donc elle n'a de sens que si $a\neq0$, et le programme doit s'en occuper avant de diviser. Ensuite le test d == 0 : il n'est fiable que si $\Delta$ est calculé exactement, ce qui est le cas avec des entiers Python (ils ne sont jamais arrondis) et ne l'est pas avec des flottants.

👉 Ce qu'on retient : un programme hérite des hypothèses de la formule qu'il code ($a\neq0$, $\Delta$ exact). Il faut les écrire noir sur blanc — en garde, en assert, ou dans la description de la fonction.

On écrit les racines $\dfrac{-b\pm\sqrt\Delta}{2a}$ sous la forme $s\pm h$ avec

import math

def racines(a, b, c):
    d = b * b - 4 * a * c
    s = -b / (2 * a)
    if d > 0:
        r = math.sqrt(d)
        h = r / (2 * abs(a))
        return [s - h, s + h]
    elif d == 0:
        return [s]
    else:
        return []

print(racines(1, -3, 2))
print(racines(1, -2, 1))
print(racines(1, 1, 1))
print(racines(-1, 3, -2))

[1.0, 2.0]
[1.0]
[]
[1.0, 2.0]

Vérification des cas. $x^2-3x+2$ : $\Delta=9-8=1$, racines $\frac{3\pm1}{2}$, soit $1$ et $2$ ; on retrouve la somme $1+2=3=-\frac ba$ et le produit $1\times2=2=\frac ca$. $x^2-2x+1=(x-1)^2$ : $\Delta=0$, racine double $1$. $x^2+x+1$ : $\Delta=1-4=-3<0$, liste vide. $-x^2+3x-2=-(x^2-3x+2)$ a les mêmes racines, et elles sortent bien dans l'ordre croissant. Avec la formule $\frac{-b\pm\sqrt\Delta}{2a}$ écrite telle quelle, le dénominateur $2a=-2$ est négatif et l'ordre s'inverse :

x1 = (-3 - 1) / (-2)
x2 = (-3 + 1) / (-2)
print(x1, x2)

2.0 1.0

$x^2-2$ a pour racines $\pm\sqrt2$, qui ne sont pas des décimaux : le programme en donne des valeurs approchées. On les affiche une par une, chacune suivie de son report dans le trinôme.

import math

def racines(a, b, c):
    d = b * b - 4 * a * c
    s = -b / (2 * a)
    if d > 0:
        r = math.sqrt(d)
        h = r / (2 * abs(a))
        return [s - h, s + h]
    elif d == 0:
        return [s]
    else:
        return []

for x in racines(1, 0, -2):
    print(x)
    print(x * x - 2)

-1.4142135623730951
4.440892098500626e-16
1.4142135623730951
4.440892098500626e-16

Le report ne donne pas $0$ mais environ $4{,}4\times10^{-16}$. La valeur affichée de $\sqrt2$ est le flottant le plus proche de $\sqrt2$, pas $\sqrt2$ lui-même, et son carré dépasse $2$ d'une quantité minuscule, de l'ordre de la précision des flottants. Ce n'est pas une erreur du programme : c'est la raison pour laquelle on compare des flottants avec une tolérance, jamais avec == (A4). Le contrôle sûr s'écrit ainsi :

x = 1.4142135623730951
print(abs(x * x - 2) < 1e-12)

True

Le seuil $10^{-12}$ est très au-dessus de l'erreur d'arrondi ($4{,}4\times10^{-16}$) et très au-dessous de l'écart que donnerait une racine fausse.

Pour racines(0, 2, -4), le calcul de s divise par 2 * a, qui vaut $0$ :

import math

def racines(a, b, c):
    d = b * b - 4 * a * c
    s = -b / (2 * a)
    if d > 0:
        r = math.sqrt(d)
        h = r / (2 * abs(a))
        return [s - h, s + h]
    elif d == 0:
        return [s]
    else:
        return []

print(racines(0, 2, -4))

ZeroDivisionError: division by zero

Le programme s'arrête sur une exception : le print n'est jamais exécuté. Pourtant la question a un sens : $0x^2+2x-4=0$ est l'équation du premier degré $2x-4=0$, de solution $x=2$. La formule des trinômes ne s'applique pas, et c'est au programme de le voir avant de diviser.

On ajoute une garde en tête de fonction : si $a=0$, l'équation est $bx+c=0$, de solution $-\frac cb$ pourvu que $b\neq0$. Le cas $a=b=0$ n'est plus une équation du premier degré (elle est vraie pour tout $x$ si $c=0$, fausse pour tout $x$ sinon) : on le refuse par un assert, qui arrête le programme sur une AssertionError désignant la précondition violée, au lieu d'une division par zéro qui n'en est qu'un symptôme.

import math

def racines(a, b, c):
    if a == 0:
        assert b != 0
        return [-c / b]
    d = b * b - 4 * a * c
    s = -b / (2 * a)
    if d > 0:
        r = math.sqrt(d)
        h = r / (2 * abs(a))
        return [s - h, s + h]
    elif d == 0:
        return [s]
    else:
        return []

print(racines(0, 2, -4))
print(racines(1, -3, 2))

[2.0]
[1.0, 2.0]

La garde est placée avant le calcul de s : placée après, elle arriverait trop tard. Et le comportement pour $a\neq0$ est inchangé (deuxième ligne).

Le trinôme $(x-0{,}1)^2=x^2-0{,}2x+0{,}01$ a une racine double, $0{,}1$. Saisi avec des flottants, son discriminant vaut :

b = -0.2
c = 0.01
d = b * b - 4 * c
print(d)
print(d == 0)

6.938893903907228e-18
False

Mathématiquement $\Delta=0{,}04-0{,}04=0$ ; en machine, ni $0{,}2$ ni $0{,}01$ n'ont d'écriture binaire finie, les deux produits sont arrondis différemment, et il reste un résidu d'environ $7\times10^{-18}$. Le test d == 0 échoue, et la fonction voit deux racines distinctes là où il n'y en a qu'une. Multiplier le trinôme par $100$ ne change pas ses racines et rend les coefficients entiers : $100x^2-20x+1$ a pour discriminant $400-400=0$, calculé exactement.

import math

def racines(a, b, c):
    d = b * b - 4 * a * c
    s = -b / (2 * a)
    if d > 0:
        r = math.sqrt(d)
        h = r / (2 * abs(a))
        return [s - h, s + h]
    elif d == 0:
        return [s]
    else:
        return []

for x in racines(1, -0.2, 0.01):
    print(x)
print(racines(100, -20, 1))

0.09999999868291098
0.10000000131708903
[0.1]

Avec les flottants, deux « racines » écartées d'environ $2{,}6\times10^{-9}$ ; avec les entiers, la racine double $0{,}1$.

👉 Avec des entiers, le test d == 0 est exact ; avec des flottants, un « zéro » peut sortir positif ou négatif selon les arrondis. Si les coefficients sont décimaux, on les multiplie par une puissance de $10$ pour les rendre entiers — ou l'on remplace d == 0 par abs(d) < eps, en choisissant eps en connaissance de cause.

Trinôme. Pour $a\neq0$, $\Delta=b^2-4ac$. Si $\Delta>0$ : deux racines $\dfrac{-b\pm\sqrt\Delta}{2a}$ ; si $\Delta=0$ : une racine double $-\dfrac b{2a}$ ; si $\Delta<0$ : aucune racine réelle. Somme des racines $-\dfrac ba$, produit $\dfrac ca$.

En Python. math.sqrt(x) exige x >= 0 (sinon ValueError) : raison de plus pour ne l'appeler que dans la branche $\Delta>0$. Les entiers (int) sont exacts et sans limite de taille ; les flottants (float) sont arrondis, et 0.1 n'est pas exactement $0{,}1$.

Garde. Tester les cas où la formule n'a pas de sens avant de l'appliquer ; refuser par assert ce que la fonction ne sait pas traiter.

⚠️ Mettre la garde après le calcul. Si l'on calcule s = -b / (2 * a) en première ligne et qu'on teste a == 0 ensuite, la division a déjà eu lieu : le programme s'arrête avant d'atteindre la garde. L'ordre des instructions compte autant que l'ordre des tests.

⚠️ Tester d >= 0 avant d == 0. Dans une cascade, le premier test vrai l'emporte : avec if d >= 0: en tête, le cas $\Delta=0$ tombe dans la branche des deux racines et renvoie deux fois la même valeur. Les conditions s'écrivent d > 0, puis d == 0, puis else.

⚠️ Appeler math.sqrt(d) avant de connaître le signe de d. Pour $\Delta<0$, math.sqrt lève une ValueError : la racine carrée ne se calcule que dans la branche où elle existe.

range(a, b) commence à a et s'arrête avant b ; le troisième argument est le pas, qui peut être négatif.

Pour un produit, l'accumulateur part de $1$, pas de $0$. Dans le tableau de trace, écris l'état des variables après chaque tour.

Compare le dernier terme ajouté par la boucle de l'élève au dernier terme de la somme voulue.

range(a, b) parcourt les entiers de $a$ à $b-1$ : le début est inclus, la fin est exclue. Donc range(n), qui abrège range(0, n), donne les $n$ entiers $0,1,\dots,n-1$ — exactement ce qu'il faut pour parcourir les indices d'une liste de longueur $n$. Mais pour parcourir $1,2,\dots,n$, il faut écrire range(1, n + 1), et c'est là que se glisse l'erreur la plus fréquente des boucles : oublier le dernier terme.

La convention a une vertu : range(a, b) fait exactement $b-a$ tours (quand $a\leq b$), sans « $+1$ » à retenir, et deux plages consécutives range(a, b) et range(b, c) se recollent sans chevauchement en range(a, c).

👉 Ce qu'on retient : avant d'écrire un range, se demander quel est le dernier entier voulu, et mettre son successeur comme borne de fin. Puis vérifier sur un petit $n$, en traçant la boucle.

On fait afficher chaque range converti en liste par list :

print(list(range(5)))
print(list(range(2, 6)))
print(list(range(1, 10, 3)))
print(list(range(10, 0, -2)))
print(list(range(5, 2)))
print(list(range(1, 11, 3)))

[0, 1, 2, 3, 4]
[2, 3, 4, 5]
[1, 4, 7]
[10, 8, 6, 4, 2]
[]
[1, 4, 7, 10]