NSI, Première • Exercices corrigés à Montréal
Ce chapitre est celui où l'informatique cesse d'être des mathématiques. Un flottant n'est pas un réel : c'est une approximation codée sur bits, dont le pas grandit avec la valeur. Tant que l'on n'a pas admis cela, les résultats bizarres restent inexplicables.
Vous trouverez ici les huit erreurs qui coûtent des points en devoir et des heures en projet, avec la phrase exacte à écrire pour chacune, l'arbre qui décide comment comparer deux flottants, celui qui compte les octets d'un texte en UTF-8, et une boucle qui ne s'arrête jamais, traitée ligne par ligne.
Le fil du chapitre
Un flottant est une APPROXIMATION dont le pas grandit avec le nombre : on ne teste jamais l'égalité de deux flottants, et un caractère n'est pas un octet.
La question de l'exactitude ne dépend pas du nombre de bits disponibles : resterait inexact sur mille bits. C'est une propriété arithmétique, pas une limite de mémoire.
C'est ce pas variable qui explique l'ABSORPTION : ajouter à ne change rien, car le résultat exact tomberait entre deux flottants voisins et l'arrondi ramène au point de départ.
En Python, `len(s)` compte les CARACTÈRES; `len(s.encode('utf-8'))` compte les OCTETS. Les deux diffèrent dès qu'un accent apparaît, ce qui arrive dans presque tout texte français.
Les erreurs ci-dessous sont celles que je corrige le plus souvent en séance. Chacune coûte des points sur une copie, même quand le raisonnement est juste.
Ce qu'il ne faut pas écrire
« if x == 0.3 : ... »
Ce qu'il faut écrire
« On compare à une TOLÉRANCE : if abs(x - 0.3) < 1e-9 : ... Deux flottants issus de calculs différents ne sont presque jamais égaux bit à bit. »
Pourquoi : L'égalité de flottants demande que TOUS les bits coïncident. Or vaut : le test échoue alors que le calcul est correct.
Ce qu'il ne faut pas écrire
« ne fait qu'un chiffre après la virgule, il est donc exact en machine. »
Ce qu'il faut écrire
« La brièveté DÉCIMALE ne dit rien de l'écriture BINAIRE. et : le facteur interdit une écriture binaire finie, donc la machine arrondit. »
Pourquoi : Le critère est arithmétique : un nombre est exact en binaire si son dénominateur réduit est une puissance de . C'est le même phénomène que en décimal, qui donne
Ce qu'il ne faut pas écrire
« x = 0.0 puis while x != 1.0 : x = x + 0.1 »
Ce qu'il faut écrire
« Une variable de boucle doit être un ENTIER : for i in range(10) : x = i / 10. On ne compte jamais avec des flottants. »
Pourquoi : Après dix additions, vaut et non : la condition d'arrêt n'est jamais atteinte. Le compteur entier, lui, est exact par construction.
Ce qu'il ne faut pas écrire
« La chaîne compte caractères, elle occupe donc octets. »
Ce qu'il faut écrire
« En UTF-8, un caractère occupe de à octets. Ici l'accent en coûte et le symbole euro : caractères font octets. »
Pourquoi : L'égalité entre caractères et octets n'est vraie qu'en ASCII pur. Tout texte français la brise dès le premier accent, et c'est exactement ce que l'énoncé choisit.
Ce qu'il ne faut pas écrire
« Le caractère est codé en Unicode sur trois octets. »
Ce qu'il faut écrire
« UNICODE lui attribue un point de code, un numéro; UTF-8 est l'ENCODAGE qui décide combien d'octets servent à l'écrire. Le même point de code occupe octets en UTF-16 et en UTF-8. »
Pourquoi : L'un est un catalogue, l'autre une manière de l'écrire sur un disque. Les confondre rend incompréhensible l'existence de plusieurs encodages pour un seul répertoire.
Ce qu'il ne faut pas écrire
« Le caractère `7` a pour code ASCII . »
Ce qu'il faut écrire
« Le caractère `7` a pour code , car le chiffre `0` vaut . On retrouve la valeur numérique par la soustraction : . »
Pourquoi : Le code d'un caractère et la valeur qu'il représente sont deux choses différentes. La soustraction du code de `0` est le geste standard de toute conversion manuelle.
Ce qu'il ne faut pas écrire
« vaut , comme en mathématiques. »
Ce qu'il faut écrire
« Au voisinage de , l'écart entre deux flottants voisins dépasse : le résultat exact n'est pas représentable et l'arrondi renvoie . L'addition n'a rien changé. »
Pourquoi : C'est la conséquence directe du pas variable : loin de zéro, les flottants sont trop espacés pour distinguer deux entiers consécutifs. Additionner un petit terme à un grand le fait disparaître.
Ce qu'il ne faut pas écrire
« Il y a autant de flottants entre et qu'entre et . »
Ce qu'il faut écrire
« Il y en a énormément plus entre et : chaque intervalle contient le même nombre de flottants, donc plus on descend vers zéro, plus ils sont serrés. »
Pourquoi : L'exposant code l'ordre de grandeur, la mantisse la précision RELATIVE. La précision relative est constante, donc la précision absolue se dégrade quand le nombre grandit.
On regarde le TYPE des valeurs comparées, et l'origine de ces valeurs.
Si les deux valeurs sont des ENTIERS → le test d'égalité est sûr : les entiers Python sont exacts et de taille illimitée
Exemple : if n == 100 : ...
Si au moins une valeur est un FLOTTANT issu d'un calcul → comparer à une tolérance : abs(a - b) < eps, avec eps de l'ordre de
Exemple : abs(0.1 + 0.2 - 0.3) < 1e-9 est vrai, alors que l'égalité est fausse
Si les nombres comparés sont TRÈS GRANDS ou très petits → utiliser une tolérance RELATIVE : abs(a - b) < eps * abs(b)
Une tolérance absolue de n'a aucun sens sur des nombres de l'ordre de , où le pas des flottants dépasse déjà cette valeur.
Si on veut compter ou indexer → utiliser des ENTIERS, toujours : range, indices de liste, compteurs de boucle
Diviser après coup, comme x = i / 10, garde le compteur exact et ne coûte rien.
Si on manipule des sommes d'argent → compter en CENTIMES avec des entiers, jamais en euros avec des flottants
Si aucune branche ne s'applique, c'est souvent qu'il ne faut pas comparer du tout : chercher plutôt le minimum, trier, ou tester une inégalité large, qui sont robustes là où l'égalité ne l'est pas.
On classe chaque caractère selon son point de code Unicode, puis on additionne.
Si le caractère est dans la table ASCII, point de code inférieur à → octet
Exemple : les lettres non accentuées, les chiffres, l'espace, la ponctuation courante
Si le point de code est compris entre et → octets
Exemple : les lettres accentuées du français, comme accent aigu
Si le point de code est compris entre et → octets
Exemple : le symbole euro, les idéogrammes chinois courants
Si le point de code dépasse → octets
Exemple : les émojis
Si on veut la réponse en Python plutôt qu'à la main → len(s) donne les caractères, len(s.encode('utf-8')) donne les octets
Attention à l'encodage du fichier source lui-même : un fichier enregistré en Latin-1 et lu comme de l'UTF-8 produit les caractères parasites que l'on voit à la place des accents. C'est un problème d'encodage, pas de contenu.
Le correcteur coche des étapes. Les voici dans l'ordre, avec la phrase de conclusion qu'il attend mot pour mot.
Quand l'utiliser : L'énoncé donne un nombre décimal et demande s'il est représentable exactement en machine.
Phrase de conclusion
s'écrit , dont le dénominateur n'est pas une puissance de : son écriture binaire est infinie et périodique, la machine en conserve donc une valeur arrondie sur bits de mantisse.
Le piège : Invoquer le nombre de bits disponibles. Le problème n'est pas la taille de la mantisse : resterait inexact avec un million de bits, exactement comme reste infini en décimal.
Barème : 0,5 point pour la fraction, 0,5 point pour la décomposition, 1 point pour le critère cité, 1 point pour la conclusion sur l'arrondi.
Cinq minutes de vérification récupèrent plus de points qu'un exercice de plus commencé à la hâte.
Aucun test d'égalité sur un flottant
Relisez votre code : tout `==` ou `!=` dont un membre est un flottant calculé est suspect. Remplacez-le par une comparaison de la valeur absolue de la différence à une tolérance.
`while x != 1.0` sur un compteur incrémenté de : la boucle ne s'arrête jamais.
La variable de boucle est un entier
Regardez ce que parcourt votre boucle : un `range` ou une liste, jamais un flottant que l'on incrémente. Si un pas décimal est nécessaire, il se calcule à partir de l'entier.
`for i in range(10) : x = i / 10` remplace exactement une boucle sur , , jusqu'à .
Caractères ou octets, l'énoncé le dit
Relisez la question : une taille de fichier se compte en octets, une longueur de chaîne en caractères. Un texte contenant un accent donne deux nombres différents.
Répondre pour une chaîne de caractères dont un accentué : la taille en octets vaut au moins .
L'ordre de grandeur de l'erreur
Une erreur d'arrondi sur des doubles est de l'ordre de RELATIF. Une différence bien plus grande signale une erreur d'algorithme, pas un problème de flottants.
Un écart de entre deux calculs : ce n'est pas l'arrondi, c'est une formule fausse.
On veut afficher les valeurs puis et ainsi de suite jusqu'à . Un élève propose le programme ci-dessous, qui ne s'arrête jamais.
1. Expliquer pourquoi la boucle est infinie. 2. Quelle valeur exacte prend x après dix additions ? 3. Corriger le programme avec un compteur entier. 4. Proposer une correction par comparaison à une tolérance. 5. Laquelle des deux corrections est préférable, et pourquoi ?
x = 0.0
while x != 1.0:
print(x)
x = x + 0.1Étape 1
n'est pas représentable exactement en binaire. Chaque addition ajoute donc une valeur légèrement différente de , et les arrondis s'accumulent : ne vaut jamais exactement .
Pourquoi
La cause est dans la REPRÉSENTATION, pas dans la boucle. Répondre « parce que la condition n'est jamais vraie » décrit le symptôme sans nommer la cause, et ne vaut aucun point.
Étape 2
Après dix additions, vaut , soit environ de moins que . Le test `x != 1.0` reste donc vrai, et la boucle continue indéfiniment.
Pourquoi
Donner la valeur exacte, avec ses seize chiffres, montre que l'on a compris l'ordre de grandeur de l'erreur. Un « environ » ne prouve rien.
Étape 3
Correction par compteur entier : `for i in range(10):` puis `print(i / 10)`. Le compteur est exact, et la division n'est faite qu'à l'affichage.
Pourquoi
C'est la correction de fond : on supprime le flottant de la CONDITION d'arrêt. L'erreur d'arrondi subsiste sur les valeurs affichées, mais elle ne pilote plus le programme.
Étape 4
Correction par tolérance : `while abs(x - 1.0) > 1e-9:` à la place du test d'égalité. La boucle s'arrête bien après dix tours.
Pourquoi
Cette correction traite le symptôme et suffit quand la boucle doit vraiment porter sur des flottants. Le choix de la tolérance, ici , doit être bien plus grand que et bien plus petit que le pas voulu.
Étape 5
La version à compteur entier est préférable : le nombre de tours y est garanti par construction, indépendamment de toute erreur d'arrondi.
Pourquoi
La question demande un choix ARGUMENTÉ. L'argument attendu est la garantie du nombre d'itérations, pas la brièveté du code.
Étape 6
Vérification dans l'interpréteur : on repart de `x = 0.0` et on ajoute dix fois `0.1`, puis on affiche `x`. On obtient , et `abs(x - 1.0) < 1e-15` est vrai alors que `x == 1.0` est faux.
Pourquoi
Le contrôle se fait dans l'interpréteur, en trois secondes. C'est le réflexe qui distingue un élève qui a compris d'un élève qui récite le cours.
Conclusion rédigée
La boucle est infinie parce que n'est pas exact en binaire : après dix additions vaut et jamais . On corrige soit en pilotant la boucle par un compteur entier, `for i in range(10)`, ce qui est préférable, soit en remplaçant l'égalité par une comparaison à une tolérance.
L'erreur classique sur cet exercice : Corriger en écrivant `while x < 1.0:`. La boucle s'arrête, mais elle exécute ONZE tours au lieu de dix, puisque vaut encore au dixième test. L'inégalité stricte masque le problème sans le résoudre.
Parce que ni zéro virgule un ni zéro virgule deux ne s'écrivent exactement en binaire. La machine en stocke des valeurs arrondies, et la somme de deux arrondis n'est pas l'arrondi de la somme. Le résultat affiché est zéro virgule trois suivi de seize zéros puis d'un quatre. C'est normal et cela arrive dans tous les langages.
On ne teste jamais l'égalité. On calcule la valeur absolue de leur différence et on la compare à une petite tolérance, par exemple dix puissance moins neuf. Pour des nombres très grands, on utilise une tolérance relative, proportionnelle à l'ordre de grandeur des valeurs comparées.
Unicode est un répertoire : il attribue un numéro, appelé point de code, à chaque caractère existant. UTF-8 est un encodage : il décide comment écrire ce numéro sous forme d'octets, de un à quatre selon le caractère. Un même caractère Unicode s'écrit différemment en UTF-8 et en UTF-16.
Parce que UTF-8 est un encodage à longueur variable. Une lettre non accentuée occupe un octet, une lettre accentuée deux, le symbole euro trois, un émoji quatre. Les deux nombres ne coïncident que pour un texte purement ASCII, ce qui n'est presque jamais le cas d'un texte français.
Environ quinze à seize en double précision, car la mantisse ne dispose que de cinquante-deux bits. Au-delà, les chiffres affichés ne sont plus fiables. C'est aussi pourquoi ajouter un à dix puissance seize ne change rien : le résultat exact n'est plus représentable.