Comprendre comment un ordinateur, qui ne manipule que des 0 et des 1, écrit un nombre entier, et savoir passer de l’écriture en base 10 à l’écriture en base 2 ou en base 16, à la main puis avec Python.
Q15.
Un tee-shirt porte l’inscription : « Il y a 10 sortes de personnes : celles qui comprennent le binaire et les autres. » Combien de sortes de personnes la phrase énumère-t-elle vraiment ? Que peut bien valoir « 10 » pour que la phrase soit juste ?
Réponse
La phrase énumère deux sortes de personnes. Elle n’est juste que si « 10 » vaut deux. C’est le cas lorsque 10 est écrit en base 2, comme on va le voir : (10)2=2. Le même assemblage de chiffres ne désigne pas le même nombre selon la base dans laquelle on l’écrit.
Ce que l’on fait sans y penser : la base 10
Un ordinateur est fait de circuits électroniques qui ne connaissent que deux états : le courant passe ou ne passe pas. On note ces deux états 0 et 1. Une information qui ne peut prendre que ces deux valeurs s’appelle un bit (de l’anglais binary digit, chiffre binaire). Pour écrire n’importe quel nombre avec seulement deux chiffres, l’ordinateur utilise la même idée que nous avec nos dix chiffres. Commençons donc par regarder de près ce que nous faisons tous les jours.
Dans le nombre 2026, les deux chiffres 2 n’ont pas la même valeur. Le premier compte pour deux milliers, le second pour deux unités. La valeur d’un chiffre dépend de sa position dans l’écriture :
En base 10, on dispose de dix chiffres, de 0 à 9. Chaque position vaut dix fois plus que celle qui est à sa droite. On dit que le chiffre des milliers a un poids de 103.
Q16.
Écrire 7305 sous la forme d’une somme de chiffres multipliés par des puissances de 10. Pourquoi a-t-on besoin d’un chiffre 0 dans cette écriture ?
Réponse
7305=7×103+3×102+0×101+5×100.
Le 0 indique qu’il n’y a aucune dizaine. Sans lui, on écrirait 735, qui est un autre nombre : le 0 sert à garder chaque chiffre à sa place.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Dans le nombre 4072, quel est le poids du chiffre 4 ?
Le 4 est en quatrième position en partant de la droite, dont le poids vaut 103=1000 : il compte pour quatre milliers.
Question 2 / 2
À quoi sert le chiffre 0 dans l’écriture 7305 ?
La valeur d’un chiffre dépend de sa position. Sans le 0, le 3 et le 7 perdraient une position.
La base 2 : compter avec deux chiffres
Du binaire vers le décimal
En base 2, on ne dispose que de deux chiffres, 0 et 1. Chaque position vaut deux fois plus que celle qui est à sa droite. Les poids sont donc, de droite à gauche, 20=1, 21=2, 22=4, 23=8, 24=16, etc. Pour éviter toute confusion, on note la base en indice : (1101)2 désigne l’écriture en base 2, et 1101 seul désigne le nombre mille cent un.
Exemple résolu : que vaut (1101)2 ?
On écrit les poids au-dessus de chaque chiffre, en partant de la droite :
poids
23=8
22=4
21=2
20=1
chiffre
1
1
0
1
On additionne les poids des positions où se trouve un 1 :
(1101)2=1×8+1×4+0×2+1×1=13
Les chiffres 0 ne comptent pas : ils servent seulement à garder les autres à leur place, comme en base 10.
Q17.
En utilisant la même méthode, déterminer la valeur décimale de :
(10)2 ;
(101010)2 ;
(11111111)2.
Réponse
(10)2=1×2+0×1=2 : c’est le « 10 » du tee-shirt.
(101010)2=32+8+2=42.
(11111111)2=128+64+32+16+8+4+2+1=255.
Python sait faire ce calcul. La fonction int, qui convertit une chaîne en entier, accepte un deuxième argument : la base dans laquelle la chaîne est écrite. On peut aussi écrire directement un nombre en binaire dans un programme en le faisant précéder de 0b.
Q18.
Dans la console de Thonny, vérifier les réponses de la question précédente :
Pour passer dans l’autre sens, on cherche à répondre à la question : quels poids faut-il additionner pour obtenir le nombre ? Une méthode systématique consiste à diviser le nombre par 2, encore et encore. On a déjà rencontré cette idée dans le Doc. 2,4 : n % 10 donnait le chiffre des unités de n en base 10, et n // 10 retirait ce chiffre. En base 2, on fait la même chose avec 2 à la place de 10.
Exemple résolu : écrire 13 en base 2
On effectue des divisions euclidiennes successives par 2, jusqu’à obtenir un quotient nul :
division
quotient (n // 2)
reste (n % 2)
ce que donne le reste
13=2×6+1
6
1
chiffre des unités (20)
6=2×3+0
3
0
chiffre de poids 21
3=2×1+1
1
1
chiffre de poids 22
1=2×0+1
0
1
chiffre de poids 23
Le premier reste obtenu est le chiffre de droite. On lit donc les restes de bas en haut : 13=(1101)2. On vérifie : 8+4+1=13.
Q19.
Écrire 42 puis 100 en base 2 par la méthode des divisions successives. Vérifier ensuite avec la fonction bin de Python : bin(42) et bin(100).
Réponse
Pour 42, les restes successifs sont 0, 1, 0, 1, 0, 1 (quotients 21, 10, 5, 2, 1, 0). Lus de bas en haut : 42=(101010)2.
Pour 100, les restes successifs sont 0, 0, 1, 0, 0, 1, 1 (quotients 50, 25, 12, 6, 3, 1, 0). Lus de bas en haut : 100=(1100100)2.
>>>bin(42)'0b101010'>>>bin(100)'0b1100100'
La fonction bin retourne une chaîne de caractères qui commence par '0b', pour rappeler que c’est une écriture en base 2.
Q20.
Un élève écrit 13 en base 2 et obtient (1011)2. Il a pourtant fait toutes les divisions sans erreur. Quelle erreur a-t-il commise ? Comment aurait-il pu la repérer lui-même ?
Réponse
Il a lu les restes de haut en bas, dans l’ordre où il les a obtenus. Or le premier reste est le chiffre des unités, qui s’écrit à droite. Il pouvait repérer l’erreur en vérifiant son résultat : (1011)2=8+2+1=11, et non 13. Vérifier une conversion en faisant la conversion inverse est un bon réflexe.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que vaut (1011)2 en base 10 ?
On additionne les poids des positions où se trouve un 1 : 8+2+1=11.
Question 2 / 3
Les divisions successives de 6 par 2 donnent les restes 0, puis 1, puis 1. Quelle est l’écriture de 6 en base 2 ?
Le premier reste obtenu est le chiffre des unités : on lit les restes de bas en haut. Vérification : 4+2=6.
Question 3 / 3 (plusieurs réponses possibles)
Quelles instructions Python donnent l’entier 5 ?
bin fait la conversion inverse et retourne une chaîne. int("101") lit la chaîne en base 10 et donne cent un.
La base 16 : une écriture plus courte du binaire
Les écritures binaires sont vite très longues : il faut 8 chiffres pour écrire 255, et 11 pour écrire 2026. Pour les écrire de façon plus compacte, les informaticiens utilisent la base 16, appelée hexadécimale.
En base 16, il faut seize chiffres. On utilise les chiffres de 0 à 9, puis les lettres A, B, C, D, E et F pour les valeurs de 10 à 15 :
base 16
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
base 10
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Les poids sont maintenant des puissances de 16 : 160=1, 161=16, 162=256, etc. Par exemple :
(2A)16=2×16+10×1=42
En Python, un nombre écrit en base 16 commence par 0x, et la fonction hex donne l’écriture hexadécimale d’un entier.
Q21.
Déterminer la valeur décimale de (FF)16 et de (7E3)16.
Vérifier avec Python : 0xFF, int("7E3", 16) et hex(42).
Réponse
(FF)16=15×16+15=255 et (7E3)16=7×256+14×16+3=1792+224+3=2019.
>>>0xFF255>>>int("7E3",16)2019>>>hex(42)'0x2a'
Python écrit les lettres en minuscules : 0x2a et 0x2A désignent le même nombre.
Passer du binaire à l’hexadécimal
Le grand intérêt de la base 16 vient de ce que 16=24. Un chiffre hexadécimal, qui va de 0 à 15, correspond exactement à un paquet de 4 chiffres binaires, qui vont de (0000)2=0 à (1111)2=15.
Exemple résolu : écrire (10101101)2 en base 16
On découpe l’écriture binaire en paquets de 4 bits, en partant de la droite : 10101101.
On convertit chaque paquet séparément : (1010)2=8+2=10, soit A, et (1101)2=8+4+1=13, soit D.
On obtient (10101101)2=(AD)16. Aucune division n’a été nécessaire.
Q22.
Écrire (11110000)2 en base 16.
Écrire (3C)16 en base 2.
Pour écrire (110101)2 en base 16, un élève découpe 110101 et obtient (D1)16. Que lui répondre ?
Réponse
11110000 donne F et 0 : (11110000)2=(F0)16.
3 s’écrit 0011 et C (12) s’écrit 1100 : (3C)16=(00111100)2=(111100)2. Chaque chiffre hexadécimal doit donner exactement 4 bits, en complétant à gauche par des 0.
Il faut découper en partant de la droite : 110101, ce qui donne 3 et 5, donc (35)16. Vérification : (110101)2=32+16+4+1=53 et (35)16=3×16+5=53. Son résultat (D1)16=209 est faux, car il a donné aux bits de gauche un poids trop faible.
Où rencontre-t-on la base 16 ?
En HTML, une couleur s’écrit souvent sous la forme #FF8000 : trois nombres en base 16, de 00 à FF, donnent les quantités de rouge, de vert et de bleu. Ici, rouge 255, vert 128 et bleu 0 donnent de l’orange.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que vaut (1F)16 en base 10 ?
1×16+15×1=31.
Question 2 / 3
Quelle est l’écriture hexadécimale de (11010110)2 ?
On découpe en paquets de 4 bits en partant de la droite : 1101 donne D (13) et 0110 donne 6.
Question 3 / 3
Pourquoi un chiffre hexadécimal correspond-il exactement à 4 bits ?
Un chiffre hexadécimal va de 0 à 15, comme une écriture binaire de 4 bits, de (0000)2 à (1111)2. Un octet contient 8 bits, soit deux chiffres hexadécimaux.
Programmer les conversions
Les fonctions int, bin et hex font déjà les conversions. Les programmer soi-même oblige à comprendre exactement ce qu’elles font.
Du binaire vers le décimal
Une chaîne de caractères se parcourt comme un tuple : for chiffre in "1101": donne successivement les caractères "1", "1", "0" et "1", de gauche à droite.
Plutôt que de calculer chaque puissance de 2, on peut lire les chiffres de gauche à droite en appliquant une règle simple : à chaque nouveau chiffre, on multiplie le résultat par 2 (tout ce qui a déjà été lu monte d’une position), puis on ajoute le chiffre.
Q23.
Compléter le tableau d’évolution de la variable n lorsqu’on lit la chaîne "1101" en appliquant la règle n = 2 * n + int(chiffre), avec n égal à 0 au départ.
étape
chiffre lu
n
départ
0
1
2
3
4
Réponse
étape
chiffre lu
n
départ
0
1
"1"
2×0+1=1
2
"1"
2×1+1=3
3
"0"
2×3+0=6
4
"1"
2×6+1=13
On retrouve (1101)2=13. Le premier 1 lu a été multiplié trois fois par 2 : il compte bien pour 23=8.
Q24.
Écrire la fonction recompose dont la spécification est :
defrecompose(binaire:str)->int:"""
Retourne l'entier dont binaire est l'écriture en base 2.
>>> recompose("1101")
13
>>> recompose("11111111")
255
>>> recompose("0")
0
"""
chiffre est une chaîne d’un caractère : il faut la convertir avec int avant de l’additionner. Sans cette conversion, Python signale une erreur TypeError, car on ne peut pas additionner un entier et une chaîne.
Du décimal vers le binaire
Q25.
On veut écrire la fonction decompose, qui traduit en Python la méthode des divisions successives :
defdecompose(n:int)->str:"""
Retourne l'écriture en base 2 de l'entier positif n.
>>> decompose(13)
'1101'
>>> decompose(42)
'101010'
>>> decompose(0)
'0'
"""
Le nombre de divisions n’est pas connu à l’avance. Quelle boucle faut-il utiliser ? Quelle est sa condition d’arrêt ?
Chaque reste doit être placé à gauche des chiffres déjà obtenus. Si bits est la chaîne déjà construite, quelle instruction ajoute le reste n % 2 à sa gauche ?
Écrire la fonction. Attention au cas n = 0.
Coup de pouce
Reprendre le tableau de l’exemple résolu pour 13 : on s’arrête quand le quotient devient nul.
Une chaîne se construit par concaténation avec + ; l’ordre des deux morceaux compte.
Que fait la boucle quand n vaut 0 dès le départ ?
Réponse
Une boucle while, puisqu’on ne sait pas d’avance combien de divisions seront nécessaires. On continue tant que n > 0.
bits = str(n % 2) + bits. Écrire bits + str(n % 2) placerait les restes dans l’ordre où on les obtient, c’est-à-dire à l’envers.
Lorsque n vaut 0, la condition n > 0 est fausse dès le premier test : sans le cas particulier, la fonction retournerait la chaîne vide.
Dans un ordinateur, les nombres sont rangés dans des cases de taille fixe. Une case de 8 bits s’appelle un octet. Pour écrire 13 sur un octet, on complète à gauche par des 0 : 00001101. Ces 0 ne changent pas la valeur, comme 0042 vaut toujours 42.
Q26.
Écrire la fonction octet, qui doit utiliser decompose :
defoctet(n:int)->str:"""
Retourne l'écriture en base 2 de l'entier n sur 8 bits.
Précondition : 0 <= n <= 255.
>>> octet(13)
'00001101'
>>> octet(255)
'11111111'
"""
Réponse
defoctet(n:int)->str:assert0<=n<=255,"n doit être compris entre 0 et 255"bits=decompose(n)whilelen(bits)<8:bits="0"+bitsreturnbits
On peut aussi écrire return "0" * (8 - len(bits)) + bits : l’opérateur * répète une chaîne. L’assertion vérifie la précondition ; les entiers plus grands que 255 ne tiennent pas sur un octet, comme on le verra dans le Doc. 4,2.
Vers la base 16
La méthode des divisions successives marche dans n’importe quelle base : pour la base 16, on divise par 16. Il reste une difficulté : un reste peut valoir de 0 à 15, et il faut l’écrire avec un seul chiffre. On range les seize chiffres hexadécimaux dans une chaîne, à la bonne place :
CHIFFRES="0123456789ABCDEF"
Comme pour un tuple, CHIFFRES[13] est le caractère d’indice 13, c’est-à-dire "D".
Q27.
Écrire la fonction decompose_16 en s’inspirant de decompose :
defdecompose_16(n:int)->str:"""
Retourne l'écriture en base 16 de l'entier positif n.
>>> decompose_16(42)
'2A'
>>> decompose_16(255)
'FF'
>>> decompose_16(2019)
'7E3'
"""
Seules trois choses changent par rapport à decompose : on divise par 16, et le reste devient un caractère grâce à CHIFFRES[n % 16] au lieu de str(n % 2).
Q28.
Sans écrire de nouvelle fonction, expliquer comment modifier decompose_16 pour obtenir l’écriture d’un entier en base 8. Quels caractères de CHIFFRES seraient alors utilisés ?
Réponse
Il suffit de remplacer 16 par 8 dans les deux divisions. Les restes vont alors de 0 à 7 : seuls les caractères "0" à "7" de CHIFFRES sont utilisés. On pourrait même écrire une seule fonction qui prend la base en paramètre.
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
On lit la chaîne "101" en appliquant n = 2 * n + int(chiffre), avec n égal à 0 au départ. Quelles valeurs n prend-il successivement ?
2×0+1=1, puis 2×1+0=2, puis 2×2+1=5.
Question 2 / 4
Dans decompose, quelle instruction place le reste au bon endroit dans la chaîne bits ?
Chaque nouveau reste se place à gauche des chiffres déjà obtenus. La troisième proposition provoque une erreur TypeError : on ne peut pas additionner un entier et une chaîne.
Question 3 / 4
Que retournerait decompose(0) sans le cas particulier if n == 0: return "0" ?
La condition n > 0 est fausse dès le premier test : la boucle ne s’exécute pas et bits reste vide.
Question 4 / 4
Avec CHIFFRES = "0123456789ABCDEF", que vaut CHIFFRES[11] ?
Les indices commencent à 0 : l’indice 10 donne "A" et l’indice 11 donne "B", le chiffre hexadécimal qui vaut 11.
Bilan
À l’issue de cette activité, je sais…
expliquer que la valeur d’un chiffre dépend de sa position, en base 10 comme en base 2 ou 16 ;
calculer la valeur décimale d’une écriture en base 2 ou en base 16 à l’aide des poids ;
écrire un entier en base 2 par la méthode des divisions successives, en lisant les restes dans le bon ordre ;
passer de la base 2 à la base 16, et inversement, par paquets de 4 bits ;
utiliser int(..., 2), int(..., 16), bin, hex et les préfixes 0b et 0x ;
programmer les conversions de la base 2 vers la base 10 et de la base 10 vers les bases 2 et 16.
Dans le Doc. 4,2, on se demande combien de bits il faut pour écrire un entier donné, et ce qui se passe quand un résultat ne tient plus dans la place prévue.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Représentation et manipulation des nombres par un ordinateur
Savoir combien de bits il faut pour écrire un entier, une somme ou un produit, et comprendre ce qui se passe lorsqu’un résultat ne tient plus dans la place que la machine lui a réservée.
Le 4 juin 1996, la fusée Ariane 5 explose 37 secondes après son premier décollage. L’enquête montre qu’un programme de navigation a voulu ranger une vitesse dans une case mémoire de 16 bits. La valeur était trop grande pour cette case : le calculateur a produit une erreur, et la fusée a perdu le contrôle de sa trajectoire.
Q11.
Avant toute recherche : combien de nombres entiers différents peut-on écrire avec 3 bits ? Écrire toutes les possibilités. Quel est le plus grand ?
Réponse
Avec 3 bits, on peut écrire 8 nombres : 000, 001, 010, 011, 100, 101, 110 et 111, c’est-à-dire les entiers de 0 à 7. Le plus grand est (111)2=4+2+1=7.
Ce que l’on peut écrire avec n bits
Chaque bit a deux valeurs possibles. Ajouter un bit double donc le nombre de possibilités : à chaque écriture déjà possible, on peut ajouter un 0 ou un 1 devant. Avec 1 bit, on a 2 possibilités ; avec 2 bits, 2×2=4 ; avec 3 bits, 2×2×2=8.
À retenir
Avec n bits, on peut écrire 2n nombres différents. Pour les entiers positifs, ce sont les entiers de 0 à 2n−1.
Un octet est un groupe de 8 bits : il permet d’écrire les entiers de 0 à 28−1=255.
Les processeurs manipulent les entiers dans des cases de taille fixe, le plus souvent de 8, 16, 32 ou 64 bits.
Q12.
Compléter le tableau en calculant les puissances de 2 avec Python, par exemple 2 ** 16 - 1.
taille
nombre d’octets
plus grand entier positif
8 bits
16 bits
32 bits
64 bits
Réponse
taille
nombre d’octets
plus grand entier positif
8 bits
1
28−1=255
16 bits
2
216−1=65535
32 bits
4
232−1=4294967295
64 bits
8
264−1=18446744073709551615
Chaque fois qu’on double le nombre de bits, le plus grand entier est à peu près élevé au carré : le nombre de chiffres décimaux double.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Combien d’entiers différents peut-on écrire avec 5 bits ?
Chaque bit double le nombre de possibilités : 25=32.
Question 2 / 3
Quel est le plus grand entier positif que l’on peut écrire sur 16 bits ?
Avec n bits, on écrit les 2n entiers de 0 à 2n−1.
Question 3 / 3
Combien de bits un octet contient-il ?
Un octet permet donc d’écrire les entiers de 0 à 255.
Combien de bits pour écrire un entier donné ?
Pour savoir combien de bits sont nécessaires pour écrire un entier N, on cherche la plus petite puissance de 2 strictement supérieure à N.
Exemple résolu : combien de bits pour 614 ?
On encadre 614 entre deux puissances de 2 consécutives : 29=512≤614<1024=210.
Avec 9 bits, on ne peut pas dépasser 29−1=511 : c’est trop peu. Avec 10 bits, on va jusqu’à 210−1=1023 : cela suffit. Il faut donc 10 bits pour écrire 614.
Q13.
Combien de bits faut-il pour écrire 255 ? 256 ? 1000 ? 2026 ? Vérifier avec Python : len(bin(2026)) - 2 donne le nombre de chiffres de l’écriture binaire de 2026. Pourquoi faut-il retirer 2 ?
Réponse
27=128≤255<256=28 : 8 bits.
28=256≤256<512=29 : 9 bits. Un seul de plus que 255, et il faut un bit de plus.
29=512≤1000<1024=210 : 10 bits.
210=1024≤2026<2048=211 : 11 bits.
bin(2026) retourne '0b11111101010' : les deux premiers caractères 0b ne sont pas des chiffres, il faut les retirer du compte.
Q14.
Écrire la fonction nb_bits, sans utiliser bin, en cherchant la première puissance de 2 strictement supérieure à n :
defnb_bits(n:int)->int:"""
Retourne le nombre de bits nécessaires pour écrire
l'entier n en base 2.
Précondition : n >= 1.
>>> nb_bits(614)
10
>>> nb_bits(255)
8
>>> nb_bits(256)
9
>>> nb_bits(1)
1
"""
Coup de pouce
Utiliser deux variables : le nombre de bits k et la puissance 2 ** k. Tant que la puissance n’est pas strictement supérieure à n, on ajoute un bit.
Réponse
defnb_bits(n:int)->int:assertn>=1,"n doit être supérieur ou égal à 1"k=1while2**k<=n:k+=1returnk
On part de 1 bit. Tant que 2k≤n, les k bits ne suffisent pas, et on en ajoute un. Une autre méthode consiste à compter les divisions par 2 nécessaires pour atteindre 0, comme dans la fonction decompose du Doc. 4,1.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Combien de bits faut-il pour écrire 300 ?
28=256≤300<512=29 : 8 bits ne vont que jusqu’à 255, 9 bits vont jusqu’à 511.
Question 2 / 3
Combien de bits faut-il pour écrire 128 ?
27=128 : 7 bits ne vont que jusqu’à 127. Il faut chercher la plus petite puissance de 2 strictement supérieure à l’entier.
Question 3 / 3
Pourquoi retire-t-on 2 dans len(bin(n)) - 2 ?
Les deux caractères 0b ne sont pas des chiffres binaires.
La taille d’une somme et d’un produit
Poser une addition en binaire
On additionne en base 2 comme en base 10, en posant l’opération et en propageant les retenues de droite à gauche. La seule différence est qu’en base 2, on obtient une retenue dès que la somme atteint 2 : 1+1=(10)2, on pose 0 et on retient 1.
Exemple résolu : calculer (0110)2+(0111)2
retenues
1
1
0
1
1
0
+
0
1
1
1
1
1
0
1
Colonne de droite : 0+1=1. Deuxième colonne : 1+1=(10)2, on pose 0 et on retient 1. Troisième colonne : 1+1+1=(11)2, on pose 1 et on retient 1. Dernière colonne : 0+0+1=1.
On vérifie en base 10 : 6+7=13=(1101)2.
Q15.
Poser les additions suivantes en binaire, puis vérifier en base 10 :
(1011)2+(0110)2 ;
(11111111)2+(00000001)2.
Réponse
(1011)2+(0110)2=(10001)2. En base 10 : 11+6=17=16+1.
(11111111)2+(00000001)2=(100000000)2. Toutes les colonnes produisent une retenue. En base 10 : 255+1=256=28. Le résultat compte 9 chiffres : il ne tient plus sur un octet.
Combien de bits pour le résultat ?
Q16.
On additionne puis on multiplie deux entiers qui tiennent chacun sur 8 bits.
Quel est le plus grand résultat possible pour la somme ? pour le produit ?
Combien de bits faut-il, au plus, pour écrire la somme ? pour le produit ? Utiliser la fonction nb_bits.
Reprendre les mêmes questions avec deux entiers de 4 bits.
Réponse
Le plus grand entier sur 8 bits est 255. La plus grande somme est 255+255=510, le plus grand produit 255×255=65025.
nb_bits(510) vaut 9 et nb_bits(65025) vaut 16. Il faut 9 bits pour la somme et 16 bits pour le produit.
Le plus grand entier sur 4 bits est 15. 15+15=30 s’écrit sur 5 bits et 15×15=225 sur 8 bits.
Q17.
En s’appuyant sur ces exemples, proposer une règle qui donne le nombre de bits d’une somme, puis d’un produit, de deux entiers de n bits. Justifier la règle pour la somme.
Coup de pouce
Comparer 2×(2n−1) à 2n+1.
Réponse
La somme de deux entiers de n bits tient sur n+1 bits, et leur produit sur 2n bits.
Justification pour la somme : chaque entier est au plus égal à 2n−1, donc la somme est au plus égale à 2×(2n−1)=2n+1−2, qui est inférieur à 2n+1. Elle s’écrit donc avec au plus n+1 bits. Plus généralement, la somme d’un entier de n bits et d’un entier de m bits tient sur max(n,m)+1 bits, et leur produit sur n+m bits.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que vaut (0101)2+(0011)2 ?
Les retenues se propagent : 1+1=(10)2, puis 0+1+1=(10)2, puis 1+0+1=(10)2. En base 10 : 5+3=8.
Question 2 / 3
Combien de bits faut-il, au plus, pour écrire la somme de deux entiers de 16 bits ?
La somme de deux entiers de n bits tient sur n+1 bits.
Question 3 / 3
Combien de bits faut-il, au plus, pour écrire le produit de deux entiers de 16 bits ?
Le produit de deux entiers de n bits tient sur 2n bits.
Quand le résultat ne tient plus : le dépassement de capacité
Une case mémoire de 8 bits ne peut pas contenir de neuvième bit. Lorsqu’un calcul produit un résultat trop grand, le bit en trop est perdu : seuls les 8 bits de droite sont conservés. On parle de dépassement de capacité (en anglais overflow).
Q18.
On calcule 200+100 avec des entiers rangés sur 8 bits.
Écrire 200, 100 et 300 en base 2 avec Python.
Que reste-t-il de 300 si l’on ne garde que les 8 bits de droite ? Quelle valeur la machine obtient-elle ?
Vérifier que cette valeur est égale à 300 % 256. Expliquer pourquoi.
Réponse
bin(200) donne '0b11001000', bin(100) donne '0b1100100' et bin(300) donne '0b100101100', qui compte 9 bits.
On perd le bit de gauche, qui vaut 28=256. Il reste (00101100)2=32+8+4=44. La machine affirme que 200+100=44.
300 % 256 vaut bien 44 : supprimer le bit de poids 28 revient à retirer 256, c’est-à-dire à prendre le reste de la division par 256.
C’est ce qui s’est passé sur Ariane 5 : la valeur à ranger dépassait la capacité d’une case de 16 bits. Ce type d’erreur ne se voit pas à la lecture du programme : il n’apparaît que pour certaines valeurs.
Q19.
Dans la console, calculer 2 ** 100, puis 2 ** 100 + 1. Python signale-t-il un dépassement de capacité ? Combien de bits faut-il pour écrire 2 ** 100 ?
Python ne signale aucune erreur et le calcul est exact. Il faut 101 bits pour écrire 2100, qui s’écrit 1 suivi de cent 0 en base 2.
En Python, les entiers sont de taille arbitraire : Python utilise autant de bits qu’il en faut, tant que la mémoire de l’ordinateur le permet. Ce n’est pas le cas de la plupart des langages, ni du processeur lui-même, qui travaille sur des cases de 32 ou 64 bits.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Avec des entiers rangés sur 8 bits, quel résultat la machine obtient-elle pour 250+10 ?
260 ne tient pas sur 8 bits : le bit de poids 28 est perdu, et il reste 260−256=4, c’est-à-dire 260 % 256.
Question 2 / 2
Que se passe-t-il en Python lorsqu’on calcule 2 ** 100 + 1 ?
Python utilise autant de bits qu’il en faut, tant que la mémoire le permet. Ce n’est pas le cas du processeur ni de la plupart des langages.
Ajouter ou retirer un zéro à droite
En base 10, ajouter un 0 à droite d’un nombre le multiplie par 10 : 42 devient 420.
Q20.
Que vaut (1101)2 ? Que vaut (11010)2, obtenu en ajoutant un 0 à droite ?
Prévoir ce que donne l’ajout de trois 0 à droite. Vérifier avec int("1101000", 2).
Que se passe-t-il quand on retire le chiffre de droite de (1101)2 ? Quelle opération Python donne directement ce résultat ?
Réponse
(1101)2=13 et (11010)2=16+8+2=26 : ajouter un 0 à droite multiplie par 2, car chaque chiffre monte d’une position et voit son poids doubler.
Trois 0 multiplient par 23=8 : 13×8=104, et int("1101000", 2) vaut bien 104.
On obtient (110)2=6 : retirer le chiffre de droite revient au quotient de la division par 2. En Python, 13 // 2 vaut 6. C’est exactement le calcul effectué à chaque étape de la méthode des divisions successives.
Ces opérations s’appellent des décalages : décaler vers la gauche de k positions multiplie par 2k, et décaler vers la droite divise par 2k (division entière). Les processeurs les effectuent beaucoup plus vite qu’une multiplication quelconque.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Que vaut (1010)2 suivi de deux 0, c’est-à-dire (101000)2 ?
(1010)2=10, et ajouter deux 0 à droite multiplie par 22=4 : 10×4=40.
Question 2 / 2
Retirer le chiffre de droite de l’écriture binaire d’un entier n revient à calculer :
C’est le quotient de la division entière par 2, comme à chaque étape des divisions successives. n / 2 donne un flottant.
Bilan
À l’issue de cette activité, je sais…
expliquer qu’avec n bits on écrit 2n nombres, les entiers de 0 à 2n−1 ;
citer les tailles courantes des entiers (8, 16, 32 et 64 bits) et le plus grand entier positif d’un octet ;
déterminer le nombre de bits nécessaires pour écrire un entier, à la main et avec une fonction ;
poser une addition en binaire en propageant les retenues ;
évaluer le nombre de bits d’une somme (n+1) et d’un produit (2n) de deux entiers de n bits ;
expliquer ce qu’est un dépassement de capacité et calculer le résultat obtenu par la machine ;
savoir que les entiers de Python sont de taille arbitraire ;
multiplier ou diviser par une puissance de 2 en décalant l’écriture binaire.
Dans le Doc. 4,3, on se demande comment écrire un entier négatif avec seulement des 0 et des 1. L’addition binaire et le dépassement de capacité y joueront un rôle inattendu.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Représentation et manipulation des nombres par un ordinateur
Comprendre comment un ordinateur écrit un entier négatif avec seulement des 0 et des 1, et utiliser pour cela le complément à 2.
Q13.
La mémoire d’un ordinateur ne contient que des 0 et des 1 : il n’y a pas de case pour le signe « − ». Proposer une idée pour écrire −5 sur 4 bits.
Réponse
L’idée la plus fréquente consiste à réserver un bit pour le signe : par exemple 0 pour « positif » et 1 pour « négatif », suivi de l’écriture binaire de 5. Sur 4 bits, cela donne 1101 : un bit de signe, puis 101. C’est l’idée étudiée dans la première partie. Toute autre proposition cohérente est acceptable à ce stade.
Une fausse bonne idée : le bit de signe
Essayons l’idée la plus naturelle. Sur 4 bits, on réserve le bit de gauche au signe (0 pour un nombre positif, 1 pour un nombre négatif) et les 3 autres bits à la valeur absolue. Ainsi, +3 s’écrit 0011 et −3 s’écrit 1011.
Q14.
Avec cette convention sur 4 bits :
Écrire +5 et −5.
Écrire +0 et −0. Que remarque-t-on ?
Poser l’addition binaire des écritures de +5 et de −3, en ne gardant que 4 bits. Quel nombre obtient-on ? Quel nombre devrait-on obtenir ?
Réponse
+5 s’écrit 0101 et −5 s’écrit 1101.
+0 s’écrit 0000 et −0 s’écrit 1000 : le nombre zéro a deux écritures différentes. Il faudrait que la machine sache que ces deux codes représentent le même nombre, par exemple pour tester une égalité.
0101+1011=10000 ; en gardant 4 bits, il reste 0000, c’est-à-dire 0. Or 5+(−3)=2, qui devrait s’écrire 0010. L’addition binaire que l’on sait poser ne fonctionne plus.
Cette convention aurait donc un coût : il faudrait un circuit électronique pour additionner les nombres positifs et un autre, plus compliqué, pour les nombres de signes différents. On cherche une écriture des entiers négatifs avec laquelle l’addition binaire ordinaire donne directement le bon résultat.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Avec la convention du bit de signe sur 4 bits (bit de gauche pour le signe, 3 bits pour la valeur absolue), comment s’écrit −6 ?
Le bit de signe vaut 1 pour un nombre négatif, puis on écrit 6, soit 110.
Question 2 / 2 (plusieurs réponses possibles)
Quels sont les défauts de cette convention ?
Par exemple, 0101+1011 donne 0000 sur 4 bits, alors que 5+(−3)=2.
L’idée du compteur kilométrique
Un vieux compteur kilométrique de voiture n’affiche que 4 chiffres. Lorsqu’il indique 9999 et que la voiture parcourt encore un kilomètre, il affiche 0000 : le chiffre 1 de 10000 n’a pas de place pour s’afficher. C’est le dépassement de capacité du Doc. 4,2.
Q15.
Sur ce compteur à 4 chiffres, quel nombre faut-il ajouter à 0001 pour revenir à 0000 ? Quel nombre « joue le rôle » de −1 ? Et de −2 ?
Réponse
0001+9999=10000, qui s’affiche 0000. Sur ce compteur, ajouter 9999 revient à retirer 1 : 9999 joue le rôle de −1. De même, 9998 joue le rôle de −2, puisque 0002+9998 s’affiche 0000.
Une case de 4 bits se comporte exactement comme ce compteur, mais en base 2. Après 1111 vient 0000, car (1111)2+1=(10000)2 et le cinquième bit est perdu. On peut donc décider que l’écriture de −1 est celle qui, ajoutée à 0001, donne 0000.
Q16.
Quelle écriture sur 4 bits, ajoutée à 0001, donne 0000 (en perdant la retenue finale) ? Quel entier positif représente-t-elle habituellement ?
Même question pour l’écriture de −2, qui ajoutée à 0010 doit donner 0000.
En observant ces deux exemples, quel entier positif p faut-il écrire pour représenter un entier négatif −x sur 4 bits ? Compléter le tableau.
entier
−1
−2
−3
−4
−5
−6
−7
−8
entier positif p
écriture sur 4 bits
Coup de pouce
Sur le compteur kilométrique, −1 était représenté par 10000−1. Sur 4 bits, le rôle de 10000 est joué par (10000)2=24=16.
Réponse
1111, car 0001+1111=10000, qui donne 0000 sur 4 bits. Habituellement, 1111 représente 15.
1110, car 0010+1110=10000. Habituellement, 1110 représente 14.
On écrit p=16−x, c’est-à-dire 24−x :
entier
−1
−2
−3
−4
−5
−6
−7
−8
entier positif p
15
14
13
12
11
10
9
8
écriture sur 4 bits
1111
1110
1101
1100
1011
1010
1001
1000
Q17.
Avec cette nouvelle convention, poser l’addition des écritures de 5 et de −3 sur 4 bits, en perdant la retenue finale. Le résultat est-il juste ?
Réponse
5 s’écrit 0101 et −3 s’écrit 1101. 0101+1101=10010, et il reste 0010 sur 4 bits, c’est-à-dire 2. Le résultat est juste : l’addition binaire ordinaire fonctionne, sans aucun circuit supplémentaire.
On écrit donc les entiers positifs de 0 à 7 comme d’habitude, de 0000 à 0111, et les entiers négatifs de −8 à −1 par les écritures de 1000 à 1111. On remarque que le bit de gauche, appelé bit de poids fort, vaut 0 pour les entiers positifs ou nuls et 1 pour les entiers négatifs. On retrouve l’idée du bit de signe, mais sans ses défauts : zéro n’a qu’une seule écriture, 0000.
À retenir
Sur n bits, on peut écrire les entiers relatifs compris entre −2n−1 et 2n−1−1 :
un entier x positif ou nul (0≤x≤2n−1−1) s’écrit comme d’habitude ;
un entier −x négatif (1≤x≤2n−1) s’écrit comme l’entier positif 2n−x.
Le bit de poids fort vaut 1 pour les entiers négatifs et 0 pour les autres. Sur 8 bits, on écrit les entiers de −128 à 127.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Sur 4 bits, quelle écriture représente −1, c’est-à-dire l’écriture qui, ajoutée à 0001, donne 0000 ?
0001+1111=10000, et il reste 0000 sur 4 bits : la retenue finale est perdue.
Question 2 / 3
Sur 4 bits, quel entier positif p s’écrit comme l’entier négatif −3 ?
On écrit −x comme l’entier positif 24−x=16−3=13, soit 1101.
Question 3 / 3
Quels entiers relatifs peut-on écrire sur 8 bits ?
Sur n bits, on écrit les entiers de −2n−1 à 2n−1−1.
Le complément à 2 : une méthode rapide
Calculer 2n−x puis le convertir en binaire est un peu long. On observe sur le tableau de la partie précédente une méthode plus rapide, que l’on appelle le complément à 2.
Exemple résolu : écrire −5 sur 8 bits
On écrit la valeur absolue 5 sur 8 bits : 00000101.
On inverse tous les bits (les 0 deviennent des 1 et les 1 des 0). On obtient le complément à 1 : 11111010.
On ajoute 1 : 11111010+1=11111011.
On vérifie avec la règle de la partie précédente : 28−5=251, et 251=128+64+32+16+8+2+1=(11111011)2.
Q18.
Écrire sur 8 bits, à l’aide du complément à 2 : −1, −56 et −128. Vérifier chaque résultat en calculant 28−x.
−128 : 128 s’écrit 10000000, inversé 01111111, plus 1 : 10000000. Vérification : 256−128=128. Le complément à 2 de 10000000 est lui-même : −128 n’a pas d’opposé sur 8 bits, puisque +128 ne s’y écrit pas.
Pour lire un octet qui commence par 1, on applique la même méthode : le complément à 2 d’un entier négatif donne l’écriture de sa valeur absolue.
Q19.
Quels entiers relatifs les octets suivants représentent-ils ? 01111111, 11110000 et 10000001.
Réponse
01111111 commence par 0 : c’est un entier positif, 64+32+16+8+4+2+1=127.
11110000 commence par 1 : il est négatif. Inversé : 00001111, plus 1 : 00010000=16. Il représente −16.
10000001 commence par 1. Inversé : 01111110, plus 1 : 01111111=127. Il représente −127.
Q20.
Un élève affirme que −5 s’écrit 10000101 sur 8 bits, « parce que le 1 de gauche indique le signe ». Expliquer son erreur en calculant la somme de son écriture et de celle de 5.
Réponse
Il utilise le bit de signe de la partie 1. Avec son écriture, 00000101+10000101=10001010, qui n’est pas 00000000 : la somme de 5 et de son « opposé » ne donne pas 0. Avec le complément à 2, 00000101+11111011=100000000, et il reste bien 00000000 sur 8 bits. Le bit de poids fort indique le signe, mais les autres bits ne sont pas ceux de la valeur absolue.
Q21.
Écrire −5 sur 4 bits puis sur 8 bits. Pourquoi faut-il toujours préciser le nombre de bits avant de parler de complément à 2 ?
Réponse
Sur 4 bits, −5 s’écrit 1011 ; sur 8 bits, 11111011. Le même entier n’a pas la même écriture : on calcule 24−5=11 dans un cas, 28−5=251 dans l’autre. Inversement, l’écriture 1011 représente −5 sur 4 bits, mais 11 si on la lit comme l’octet 00001011. Une écriture binaire ne veut rien dire tant qu’on n’a pas précisé le nombre de bits et la convention utilisée.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Quelle est l’écriture de −3 sur 8 bits en complément à 2 ?
3 s’écrit 00000011 ; inversé : 11111100 ; plus 1 : 11111101. Vérification : 28−3=253. La deuxième proposition est le complément à 1, la troisième utilise le bit de signe.
Question 2 / 3
Quel entier relatif l’octet 11111110 représente-t-il ?
Il commence par 1 : il est négatif. Inversé : 00000001, plus 1 : 00000010=2. Il représente −2.
Question 3 / 3
L’écriture 1011 représente-t-elle toujours le même entier ?
Une écriture binaire ne veut rien dire tant qu’on n’a pas précisé le nombre de bits et la convention utilisée.
Programmer le complément à 2
Les fonctions suivantes, écrites dans le Doc. 4,1, sont à recopier en tête du programme :
Écrire la fonction complement_a_1, qui inverse tous les bits d’une chaîne :
defcomplement_a_1(bits:str)->str:"""
Retourne la chaîne obtenue en remplaçant chaque 0 de bits
par 1 et chaque 1 par 0.
>>> complement_a_1("00000101")
'11111010'
>>> complement_a_1("1011")
'0100'
"""
On parcourt la chaîne bit par bit, et on construit le résultat dans le même ordre, en ajoutant à droite.
Ajouter 1 à une chaîne binaire demande de propager des retenues : on le programmera dans le Doc. 4,4. Pour l’instant, on utilise la règle de la partie 2 : sur 8 bits, l’entier négatif −x s’écrit comme l’entier positif 28−x.
Q23.
Écrire la fonction relatif_vers_octet, qui doit utiliser la fonction octet :
defrelatif_vers_octet(n:int)->str:"""
Retourne l'écriture sur 8 bits de l'entier relatif n,
en complément à 2.
Précondition : -128 <= n <= 127.
>>> relatif_vers_octet(5)
'00000101'
>>> relatif_vers_octet(-5)
'11111011'
>>> relatif_vers_octet(-128)
'10000000'
"""
Réponse
defrelatif_vers_octet(n:int)->str:assert-128<=n<=127,"n doit être compris entre -128 et 127"ifn>=0:returnoctet(n)else:returnoctet(2**8+n)
Si n vaut −5, alors 2 ** 8 + n vaut 256−5=251 : on écrit bien 28−x avec x=5. Erreur fréquente : écrire 2 ** 8 - n, qui donne 261 car n est déjà négatif.
Q24.
Écrire la fonction octet_vers_relatif, qui fait le travail inverse. Choisir la méthode : on peut utiliser recompose et la règle 28−x, ou complement_a_1.
defoctet_vers_relatif(bits:str)->int:"""
Retourne l'entier relatif écrit sur 8 bits par bits,
en complément à 2.
>>> octet_vers_relatif("01111111")
127
>>> octet_vers_relatif("11110000")
-16
>>> octet_vers_relatif("10000000")
-128
"""
Coup de pouce
Commencer par regarder le bit de poids fort bits[0]. S’il vaut "1", l’octet lu comme un entier positif vaut p=28−x : comment retrouver −x à partir de p ?
Si p=28−x, alors −x=p−28. Pour "11110000", p=240 et 240−256=−16. Avec le complément à 1, on écrirait -(recompose(complement_a_1(bits)) + 1) dans le cas négatif.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que retourne complement_a_1("0110") ?
Chaque 0 devient 1 et chaque 1 devient 0, dans le même ordre.
Question 2 / 3
Dans relatif_vers_octet, pour un entier n négatif, quel appel donne la bonne écriture ?
n est déjà négatif : pour n = -5, 2 ** 8 + n vaut 256−5=251. 2 ** 8 - n vaudrait 261.
Question 3 / 3
Dans octet_vers_relatif, l’octet "11110000" se lit comme l’entier positif p=240. Quel calcul donne l’entier relatif ?
Si p=28−x, alors −x=p−28.
Bilan
À l’issue de cette activité, je sais…
expliquer pourquoi un simple bit de signe ne convient pas (deux zéros, addition fausse) ;
écrire un entier négatif sur n bits comme l’entier positif 2n−x ;
utiliser le complément à 2 (inverser les bits, puis ajouter 1) pour écrire un entier négatif ou pour lire un octet qui commence par 1 ;
donner la plage des entiers relatifs écrits sur n bits, de −2n−1 à 2n−1−1, et en particulier de −128 à 127 sur 8 bits ;
expliquer pourquoi il faut toujours préciser le nombre de bits ;
programmer le complément à 1 et les conversions entre un entier relatif et son octet.
Dans le Doc. 4,4, on programme l’addition de deux octets. On pourra alors ajouter 1 à un complément à 1, et vérifier que l’addition fonctionne aussi pour les entiers négatifs.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Représentation et manipulation des nombres par un ordinateur
Dresser la table de vérité d’une expression booléenne, découvrir le ou exclusif, et s’en servir pour programmer l’addition binaire de deux octets, comme le fait un circuit du processeur.
Q12.
Un processeur additionne deux bits a et b. Combien de cas différents peut-il rencontrer ? Pour chacun, écrire le résultat de a+b en base 2. Combien de bits faut-il pour écrire ce résultat ?
Réponse
Il y a quatre cas : 0+0=0, 0+1=1, 1+0=1 et 1+1=(10)2. Le dernier résultat demande deux bits : un chiffre des unités, appelé somme, et une retenue. Un circuit d’addition doit donc produire deux bits de sortie à partir de deux bits d’entrée.
Tables de vérité
Un bit et un booléen sont deux façons de voir la même information : 1 correspond à True (vrai) et 0 à False (faux). En Python, int(True) vaut 1 et bool(0) vaut False.
Les opérateurs and, or et not ont été rencontrés dans le Doc. 2,3. Une expression booléenne qui dépend de deux variables a et b ne peut prendre que quatre combinaisons de valeurs d’entrée. On peut donc décrire complètement son comportement dans un tableau qui donne sa valeur pour chaque combinaison : sa table de vérité.
Exemple résolu : table de vérité de « a and b »
On écrit toutes les combinaisons des entrées, dans l’ordre où l’on compte en binaire (00, 01, 10, 11), puis la valeur de l’expression :
a
b
a and b
0
0
0
0
1
0
1
0
0
1
1
1
a and b n’est vrai que si les deux entrées sont vraies.
Python peut produire ces tables à l’aide de deux boucles imbriquées :
Dresser à la main la table de vérité de a or b et celle de not a.
Vérifier la table de a or b en modifiant le programme ci-dessus.
Réponse
Tables de a or b et de not a :
a
b
a or b
0
0
0
0
1
1
1
0
1
1
1
1
a
not a
0
1
1
0
a or b est vrai dès qu’au moins une des entrées est vraie.
Il suffit de remplacer a and b par a or b dans le print.
Q14.
Dresser les tables de vérité de not (a and b) et de (not a) or (not b). Que constate-t-on ? Reformuler ce résultat par une phrase en français, en partant de : « Il est faux que a et b soient tous les deux vrais… ».
Réponse
a
b
not (a and b)
(not a) or (not b)
0
0
1
1
0
1
1
1
1
0
1
1
1
1
0
0
Les deux tables sont identiques : les deux expressions sont équivalentes. « Il est faux que a et b soient tous les deux vrais » signifie « au moins l’un des deux est faux ». Cette équivalence est une des lois de De Morgan. Erreur fréquente : croire que not (a and b) équivaut à (not a) and (not b), qui ne vaut 1 que sur la première ligne.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Combien de lignes compte la table de vérité d’une expression qui dépend de deux variables booléennes ?
Chaque variable a deux valeurs possibles : 2×2=4 combinaisons, 00, 01, 10 et 11.
Question 2 / 3
Pour quelles valeurs de a et b l’expression a or b vaut-elle 0 ?
a or b est vrai dès qu’au moins une des entrées est vraie.
Question 3 / 3
Quelle expression est équivalente à not (a and b) ?
C’est une des lois de De Morgan : il est faux que a et b soient tous les deux vrais signifie qu’au moins l’un des deux est faux. (not a) and (not b) ne vaut 1 que si les deux sont faux.
Le ou exclusif
Dans la langue courante, « ou » a deux sens. « Fromage ou dessert » au restaurant signifie qu’on ne peut pas avoir les deux. L’opérateur or de Python, lui, est vrai aussi quand les deux entrées sont vraies : c’est un ou inclusif.
Le ou exclusif, noté xor (de l’anglais exclusive or), est vrai lorsqu’une seule des deux entrées est vraie, mais pas les deux.
Q15.
Dresser la table de vérité du ou exclusif.
Pour deux booléens, le ou exclusif peut s’écrire a != b. Expliquer pourquoi.
Écrire une expression qui donne le ou exclusif en n’utilisant que and, or et not. Vérifier sa table de vérité avec Python.
Coup de pouce
Traduire mot à mot : « a ou b est vrai, et il est faux que a et b soient vrais tous les deux ».
Réponse
a
b
a xor b
0
0
0
0
1
1
1
0
1
1
1
0
Le ou exclusif est vrai exactement quand les deux entrées sont différentes, c’est-à-dire quand a != b.
(a or b) and not (a and b). On peut aussi écrire (a and not b) or (not a and b). On vérifie avec :
En Python, l’opérateur ^ calcule le ou exclusif de deux entiers égaux à 0 ou 1 : 1 ^ 1 vaut 0 et 1 ^ 0 vaut 1.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Quelles lignes de la table du ou exclusif valent 1 ?
Le ou exclusif est vrai lorsqu’une seule des deux entrées est vraie. La troisième proposition est la table de or, le ou inclusif.
Question 2 / 3 (plusieurs réponses possibles)
Pour deux booléens a et b, quelles expressions donnent le ou exclusif ?
Le ou exclusif est vrai exactement quand les entrées sont différentes. a or b est aussi vrai quand les deux entrées sont vraies.
Question 3 / 3
Que vaut 1 ^ 1 en Python ?
^ calcule le ou exclusif : les deux entrées sont égales, le résultat vaut 0. Ce n’est pas une puissance.
Additionner deux bits avec des opérateurs booléens
Q16.
Compléter la table de l’addition de deux bits a et b, en séparant le résultat en deux bits : la somme (chiffre des unités) et la retenue. Comparer les deux colonnes de sortie aux tables de vérité déjà rencontrées.
a
b
somme
retenue
0
0
0
1
1
0
1
1
Réponse
a
b
somme
retenue
0
0
0
0
0
1
1
0
1
0
1
0
1
1
0
1
La colonne « somme » est la table du ou exclusif, et la colonne « retenue » est celle de and : somme =a xor b et retenue =a and b. Un circuit qui réalise ces deux opérations s’appelle un demi-additionneur.
Pour additionner deux nombres de plusieurs bits, chaque colonne reçoit en plus la retenue r venue de la colonne de droite. Il faut donc additionner trois bits. On peut démontrer que :
la somme vaut a xor b xor r ;
la retenue sortante vaut 1 lorsqu’au moins deux des trois bits valent 1.
Q17.
Vérifier ces deux règles sur la ligne a=1, b=1, r=1, puis sur la ligne a=1, b=0, r=1, en comparant avec le calcul a+b+r écrit en base 2.
Réponse
1+1+1=3=(11)2 : somme 1, retenue 1. Règles : 1 xor 1=0, puis 0 xor 1=1 ; trois bits valent 1, donc retenue 1. C’est bien le cas.
1+0+1=2=(10)2 : somme 0, retenue 1. Règles : 1 xor 0=1, puis 1 xor 1=0 ; deux bits valent 1, donc retenue 1. C’est bien le cas.
Q18.
Écrire la fonction additionne_bits, qui retourne un tuple :
defadditionne_bits(a:int,b:int,r:int)->tuple[int,int]:"""
Retourne la somme et la retenue de l'addition des trois
bits a, b et r (chacun égal à 0 ou à 1).
>>> additionne_bits(0, 1, 0)
(1, 0)
>>> additionne_bits(1, 1, 0)
(0, 1)
>>> additionne_bits(1, 1, 1)
(1, 1)
"""
On accepte aussi somme = (a + b + r) % 2 et retenue = (a + b + r) // 2 : ce sont le chiffre des unités et le quotient de la division par 2, comme dans la méthode des divisions successives.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Lorsqu’on additionne deux bits a et b, quelles opérations donnent la somme (chiffre des unités) et la retenue ?
1+1=(10)2 : la somme vaut 0 et la retenue 1. Seul le ou exclusif donne 0 pour la somme sur cette ligne.
Question 2 / 3
On additionne trois bits a=1, b=0 et r=1. Que valent la somme et la retenue ?
1+0+1=2=(10)2. Avec les règles : 1 xor 0 xor 1=0, et deux bits valent 1, donc la retenue vaut 1.
Question 3 / 3 (plusieurs réponses possibles)
Quelles expressions donnent la somme de trois bits a, b et r ?
(a + b + r) // 2 donne la retenue, pas la somme.
Additionner deux octets
On additionne deux octets comme on pose l’addition à la main (Doc. 4,2) : de la droite vers la gauche, en reportant la retenue d’une colonne sur la suivante. La retenue qui sort de la colonne de gauche est perdue, puisque le résultat est rangé sur 8 bits.
Pour parcourir les indices de droite à gauche, on utilise range avec trois arguments : range(7, -1, -1) produit 7, 6, 5, …, 0.
Q19.
Écrire la fonction addition, qui doit utiliser additionne_bits :
defaddition(bits1:str,bits2:str)->str:"""
Retourne la somme sur 8 bits des octets bits1 et bits2.
La retenue finale est perdue.
>>> addition("00000110", "00000111")
'00001101'
>>> addition("11111111", "00000001")
'00000000'
"""
Coup de pouce
Avant la boucle : un résultat vide et une retenue nulle.
Dans la boucle, pour l’indice i : convertir bits1[i] et bits2[i] en entiers, appeler additionne_bits, déballer le tuple obtenu.
Chaque nouveau chiffre se place à gauche du résultat déjà construit.
Le déballage somme, retenue = ... met à jour la retenue, qui servira à la colonne suivante. À la fin de la boucle, la dernière retenue n’est écrite nulle part : c’est le dépassement de capacité du Doc. 4,2. Erreur fréquente : écrire resultat + str(somme), qui donne le résultat à l’envers.
Q20.
Dans le Doc. 4,3, 5 s’écrit 00000101 et −5 s’écrit 11111011 sur 8 bits.
Prévoir le résultat de addition("00000101", "11111011"), puis vérifier.
Calculer addition("00000011", "11111011"). Quel entier relatif ce résultat représente-t-il ? Le calcul est-il juste ?
Réponse
Le résultat est '00000000' : la retenue finale est perdue, et 5+(−5)=0.
Le résultat est '11111110'. Il commence par 1 : complément à 1 00000001, plus 1 : 00000010, donc il représente −2. Et 3+(−5)=−2 : la même fonction additionne correctement les entiers positifs et les entiers négatifs écrits en complément à 2. C’est la raison pour laquelle les ordinateurs utilisent cette représentation.
Q21.
Recopier la fonction complement_a_1 du Doc. 4,3, puis écrire en une ligne la fonction complement_a_2 :
defcomplement_a_2(bits:str)->str:"""
Retourne le complément à 2 de l'octet bits.
>>> complement_a_2("00000101")
'11111011'
>>> complement_a_2("11111011")
'00000101'
"""
Le deuxième exemple montre que le complément à 2 du complément à 2 redonne l’octet de départ : l’opposé de −5 est bien 5.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que produit range(7, -1, -1) ?
On part de 7, on retire 1 à chaque fois, et la borne −1 est exclue.
Question 2 / 3
Que retourne addition("11111111", "00000001") ?
Toutes les colonnes produisent une retenue, et la retenue finale est perdue : c’est un dépassement de capacité.
Question 3 / 3
En complément à 2 sur 8 bits, quel entier relatif représente le résultat de addition("00000011", "11111011"), c’est-à-dire de 3+(−5) ?
Le résultat '11111110' commence par 1 : il est négatif et vaut 254−256=−2. La même fonction additionne aussi les entiers négatifs.
Un détail qui compte : l’évaluation séquentielle
Dans le Doc. 2,3, on a vu que Python évalue a and b de gauche à droite et s’arrête dès que le résultat est connu : si a est faux, b n’est même pas évalué. De même, si a est vrai, a or b est vrai sans que b soit évalué. La table de vérité ne dit rien de cet ordre, mais il change le comportement d’un programme.
Q22.
On exécute x = 0 dans la console. Prévoir le résultat de chacune des deux expressions, puis vérifier :
>>>x!=0and10/x>1>>>10/x>1andx!=0
D’après leurs tables de vérité, ces deux expressions devraient être équivalentes. Pourquoi ne le sont-elles pas dans un programme ?
Dans la première expression, x != 0 est faux : Python n’évalue pas 10 / x et retourne False. Dans la seconde, Python commence par 10 / x et la division par zéro provoque une erreur avant que la condition x != 0 soit examinée. Les tables de vérité décrivent les valeurs, pas l’ordre des calculs : on place en premier la condition qui protège la seconde.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Avec x = 0, que donne x != 0 and 10 / x > 1 ?
x != 0 est faux : Python n’évalue pas la suite, et le résultat est False.
Question 2 / 2
Avec x = 0, que donne 10 / x > 1 and x != 0 ?
Python évalue de gauche à droite : la division par zéro a lieu avant que la condition x != 0 soit examinée. On place en premier la condition qui protège la seconde.
Bilan
À l’issue de cette activité, je sais…
associer les bits 0 et 1 aux booléens False et True ;
dresser la table de vérité d’une expression booléenne, à la main et avec deux boucles imbriquées ;
reconnaître deux expressions équivalentes en comparant leurs tables de vérité ;
définir le ou exclusif et l’écrire avec !=, ^ ou les opérateurs and, or et not ;
expliquer que la somme de deux bits est un ou exclusif et la retenue un and ;
programmer l’addition de deux octets en propageant la retenue, et constater qu’elle fonctionne aussi en complément à 2 ;
expliquer pourquoi l’ordre des opérandes de and et de or peut éviter une erreur.
Dans le Doc. 4,5, on quitte les entiers pour les nombres à virgule, et on découvre pourquoi 0.1 + 0.2 n’est pas égal à 0.3.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Représentation et manipulation des nombres par un ordinateur
Comprendre pourquoi un ordinateur ne peut écrire la plupart des nombres à virgule que de façon approchée, et en tirer une règle de programmation : ne jamais tester l’égalité de deux flottants.
Q12.
Sans utiliser l’ordinateur, prévoir ce qu’affiche Python pour l’instruction 0.1 + 0.2 == 0.3. Vérifier ensuite dans la console, puis afficher 0.1 + 0.2.
Réponse
>>>0.1+0.2==0.3False>>>0.1+0.20.30000000000000004
Presque tout le monde prévoit True. Le résultat n’est pas une erreur de Python : il vient de la façon dont l’ordinateur écrit 0,1 et 0,2. Cette activité explique pourquoi.
Les nombres à virgule sont représentés en Python par le type float. Le mot vient de l’anglais floating point, « virgule flottante ». Pour comprendre ce qui se passe, il faut d’abord savoir écrire un nombre à virgule en base 2.
Des chiffres après la virgule en base 2
En base 10, les chiffres après la virgule ont pour poids 10−1=1/10, 10−2=1/100, etc. : 0,375=3/10+7/100+5/1000.
En base 2, on prolonge de la même façon les poids vers la droite de la virgule, en divisant chaque fois par 2 :
poids
21
20
,
2−1
2−2
2−3
valeur
2
1
,
1/2=0,5
1/4=0,25
1/8=0,125
Par exemple, (0,101)2=1/2+0/4+1/8=0,5+0,125=0,625.
Q13.
Calculer la valeur décimale de (0,11)2, de (0,01)2 et de (10,1)2.
Réponse
(0,11)2=0,5+0,25=0,75.
(0,01)2=0,25.
(10,1)2=2+0,5=2,5.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Quel est le poids du premier chiffre après la virgule en base 2 ?
On prolonge les poids vers la droite de la virgule en divisant chaque fois par 2.
Question 2 / 2
Que vaut (0,011)2 en base 10 ?
0×0,5+1×0,25+1×0,125=0,375.
Écrire un nombre à virgule en base 2
Pour la partie entière, on utilise la méthode des divisions successives (Doc. 4,1). Pour la partie après la virgule, on fait l’inverse : on multiplie par 2. Chaque multiplication fait passer un chiffre binaire devant la virgule.
Exemple résolu : écrire 0,625 en base 2
On multiplie par 2. La partie entière du résultat donne le chiffre suivant ; on continue avec la partie après la virgule :
calcul
chiffre obtenu
on continue avec
0,625×2=1,25
1
0,25
0,25×2=0,5
0
0,5
0,5×2=1
1
0 : on s’arrête
Les chiffres se lisent cette fois de haut en bas : 0,625=(0,101)2. On retrouve le résultat de la partie 1.
Q14.
Écrire 0,25 puis 0,75 en base 2 par la méthode des multiplications successives.
Réponse
0,25×2=0,5 (0), puis 0,5×2=1 (1) : 0,25=(0,01)2.
0,75×2=1,5 (1), puis 0,5×2=1 (1) : 0,75=(0,11)2.
Q15.
Appliquer la méthode à 0,1. Effectuer au moins six multiplications. Que remarque-t-on ?
Coup de pouce
Après quelques étapes, on retombe sur un nombre déjà rencontré. Que va-t-il se passer ensuite ?
Réponse
calcul
chiffre
on continue avec
0,1×2=0,2
0
0,2
0,2×2=0,4
0
0,4
0,4×2=0,8
0
0,8
0,8×2=1,6
1
0,6
0,6×2=1,2
1
0,2
0,2×2=0,4
0
0,4
On retombe sur 0,2, déjà rencontré à la deuxième ligne : les calculs vont se répéter sans fin. On obtient 0,1=(0,000110011001100...)2, avec le motif 0011 répété indéfiniment. L’écriture de 0,1 en base 2 est infinie, alors qu’elle est très courte en base 10.
Q16.
En base 10, on sait déjà qu’un nombre simple peut avoir une écriture infinie : 1/3=0,333...
Écrire 1/3 en base 2 en partant de 1/3×2=2/3. Travailler avec des fractions.
Proposer une explication : pourquoi 0,25 et 0,625 ont-ils une écriture finie en base 2, mais pas 0,1 ?
Réponse
1/3×2=2/3 (0), 2/3×2=4/3=1+1/3 (1), puis on retombe sur 1/3 : 1/3=(0,010101...)2, écriture infinie.
0,25=1/4 et 0,625=5/8 : ce sont des fractions dont le dénominateur est une puissance de 2. En les multipliant plusieurs fois par 2, on finit par tomber sur un entier, et l’algorithme s’arrête. 0,1=1/10 a un dénominateur qui contient le facteur 5 : multiplier par 2 ne peut pas faire disparaître ce facteur, et la partie après la virgule ne devient jamais nulle. C’est la même raison qui rend 1/3 infini en base 10 : 3 ne divise aucune puissance de 10.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Quelle est l’écriture de 0,5 en base 2 ?
0,5×2=1 : on obtient le chiffre 1, puis la partie après la virgule est nulle et on s’arrête.
Question 2 / 3 (plusieurs réponses possibles)
Quels nombres ont une écriture finie en base 2 ?
0,75=3/4 et 0,625=5/8 ont un dénominateur qui est une puissance de 2. Les dénominateurs de 0,1=1/10 et de 1/3 contiennent un autre facteur que 2.
Question 3 / 3
Dans la méthode des multiplications successives, dans quel ordre lit-on les chiffres obtenus ?
Chaque multiplication par 2 fait passer devant la virgule le chiffre suivant : le premier obtenu est le premier après la virgule.
Ce que l’ordinateur range vraiment
Un flottant Python est rangé sur 64 bits. Le nombre est écrit en base 2 sous une forme qui rappelle l’écriture scientifique : des chiffres significatifs, appelés mantisse, multipliés par une puissance de 2. Le nombre de chiffres de la mantisse est limité. Une écriture binaire infinie, comme celle de 0,1, doit donc être coupée : l’ordinateur range le nombre le plus proche de 0,1 qu’il sait écrire, mais pas 0,1 lui-même.
Q17.
Python arrondit l’affichage des flottants pour qu’il soit lisible. On peut demander davantage de chiffres avec une f-string (Doc. 2,2). Exécuter :
0,25 est rangé exactement, car son écriture binaire est finie. 0,1 et 0,2 sont rangés avec une petite erreur. Ces erreurs s’additionnent, et le résultat de l’addition n’est pas le flottant le plus proche de 0,3 : la machine compare deux nombres réellement différents.
Q18.
Prévoir, puis vérifier : 0.5 + 0.25 == 0.75. Le résultat contredit-il la règle « il ne faut pas tester l’égalité de deux flottants » ?
Réponse
Le résultat est True : 0,5, 0,25 et 0,75 s’écrivent exactement en base 2, le calcul est donc exact. Cela ne contredit pas la règle : dans un programme, on ne sait pas en général si les valeurs manipulées ont une écriture binaire finie. Un test d’égalité peut fonctionner pour certaines valeurs et échouer pour d’autres, ce qui est le pire des cas pour trouver une erreur.
Ces petites erreurs peuvent avoir des conséquences graves. Le 25 février 1991, pendant la guerre du Golfe, une batterie de missiles Patriot n’a pas intercepté un missile Scud, qui a tué 28 soldats à Dhahran, en Arabie saoudite. L’horloge du système comptait le temps en dixièmes de seconde, et la valeur 0,1 était rangée sur 24 bits, donc tronquée : à chaque dixième de seconde, l’horloge prenait un retard d’environ 0,000000095 s.
Q19.
La batterie fonctionnait sans interruption depuis 100 heures. Combien de dixièmes de seconde l’horloge avait-elle comptés ? Quel était alors son retard ? Un Scud vole à environ 1676 m/s : quelle distance parcourt-il pendant ce retard ?
Réponse
100 h correspondent à 100×3600=360000 s, soit 3600000 dixièmes de seconde.
A.N. Retard : 3600000×0,000000095≈0,34 s.
A.N. Distance : 1676×0,34≈570 m.
Le système cherchait le missile à plus d’un demi-kilomètre de sa position réelle. Une erreur minuscule, répétée des millions de fois, est devenue énorme.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Le calcul est fait correctement, mais sur des valeurs déjà arrondies : on compare deux nombres réellement différents.
Question 2 / 3
Que vaut 0.5 + 0.25 == 0.75 ?
Ces trois nombres s’écrivent exactement en base 2 : le calcul est exact. Cela ne permet pas pour autant de tester l’égalité de flottants en général.
Question 3 / 3
Pourquoi l’horloge du système Patriot avait-elle pris du retard ?
Une erreur d’environ 0,000000095 s, répétée des millions de fois en 100 heures, a donné un retard d’environ 0,34 s.
Programmer avec des flottants
Q20.
On considère le programme suivant :
x=0whilex!=1:x=x+0.1
Combien d’itérations l’auteur de ce programme pensait-il faire ?
Expliquer pourquoi la boucle ne s’arrête jamais. Ne pas l’exécuter telle quelle ; pour le vérifier, exécuter plutôt :
x=0foriinrange(10):x=x+0.1print(x,x==1)
Réponse
Il pensait faire 10 itérations : 10×0,1=1.
Le second programme affiche 0.9999999999999999 False. Après 10 additions, x n’est pas égal à 1 à cause des erreurs d’arrondi accumulées. À l’itération suivante, x dépasse 1 et ne lui sera plus jamais égal : la condition x != 1 reste vraie indéfiniment. C’est une boucle infinie.
Pour comparer deux flottants, on ne teste pas leur égalité. On vérifie que leur écart est très petit, par exemple inférieur à 10−9. La fonction abs donne la valeur absolue d’un nombre, et 10−9 s’écrit 1e-9 en Python.
Q21.
Écrire la fonction sont_proches dont la spécification est :
defsont_proches(a:float,b:float)->bool:"""
Retourne True si l'écart entre a et b est strictement
inférieur à 1e-9, False sinon.
>>> sont_proches(0.1 + 0.2, 0.3)
True
>>> sont_proches(0.3, 0.31)
False
"""
La valeur absolue rend le test indépendant de l’ordre de a et b. Erreur fréquente : écrire a - b < 1e-9, qui retourne True dès que a est plus petit que b, même de beaucoup. La bibliothèque standard propose une fonction semblable : math.isclose.
Q22.
Réécrire la boucle de la question précédente pour qu’elle effectue exactement 10 itérations et que x prenne les valeurs 0,1 ; 0,2 ; … ; 1 aussi précisément que possible. Justifier le choix.
Coup de pouce
Les entiers, eux, sont toujours exacts en Python. Quelle variable pourrait compter les itérations sans erreur ?
Réponse
foriinrange(1,11):x=i/10
Le compteur i est un entier : il est exact, et la boucle fait exactement 10 itérations. On calcule x à partir de i à chaque tour, au lieu d’ajouter 0.1 au résultat précédent : chaque valeur de x ne subit qu’un seul arrondi, et les erreurs ne s’accumulent pas. Par exemple, 3 / 10 donne 0.3, alors que trois additions de 0.1 donnent 0.30000000000000004.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Pourquoi la boucle x = 0, while x != 1: x = x + 0.1 ne s’arrête-t-elle jamais ?
Les erreurs d’arrondi s’accumulent : la condition d’arrêt x == 1 n’est jamais remplie.
Question 2 / 3
Quel test compare correctement deux flottants a et b ?
Sans la valeur absolue, a - b < 1e-9 est vrai dès que a est plus petit que b, même de beaucoup.
Question 3 / 3
Pour faire prendre à x les valeurs 0,1 ; 0,2 ; … ; 1, quelle boucle est la plus précise ?
Le compteur entier est exact, et chaque valeur de x ne subit qu’un seul arrondi : les erreurs ne s’accumulent pas.
Bilan
À l’issue de cette activité, je sais…
calculer la valeur décimale d’un nombre à virgule écrit en base 2 ;
écrire un nombre comme 0,25, 0,1 ou 1/3 en base 2 par la méthode des multiplications successives ;
expliquer pourquoi certains nombres, comme 0,1, ont une écriture binaire infinie et ne sont rangés en machine que de façon approchée ;
expliquer pourquoi 0.1 + 0.2 == 0.3 vaut False ;
éviter de tester l’égalité de deux flottants, et comparer leur écart à une petite valeur ;
préférer un compteur entier à l’accumulation de flottants pour contrôler une boucle.
Le Doc. 4,6 propose des exercices qui mêlent toutes les représentations étudiées dans ce chapitre.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Représentation et manipulation des nombres par un ordinateur
S’entraîner sur toutes les représentations des nombres étudiées dans le chapitre, en choisissant soi-même la méthode adaptée à chaque situation.
Les exercices mélangent volontairement les notions des Doc. 4,1 à 4,5. Avant de calculer, il faut chaque fois se demander : s’agit-il d’un entier positif, d’un entier relatif ou d’un nombre à virgule ? Sur combien de bits ? Les exercices 1 à 5 se font sans ordinateur ; la console sert ensuite à vérifier les réponses.
Exercice 1 : quelle méthode ?
Q9.
Pour chaque demande, indiquer la méthode utilisée, puis répondre.
Écrire 200 en base 2 sur 8 bits.
Quel entier relatif l’octet 11001000 représente-t-il en complément à 2 ?
Combien de bits faut-il pour écrire 1000 ?
Écrire (7F)16 en base 2, puis en base 10.
Écrire 0,375 en base 2.
Réponse
Divisions successives par 2 : les restes lus de bas en haut donnent 200=(11001000)2. L’écriture tient exactement sur 8 bits.
L’octet commence par 1 : il est négatif. Complément à 2 : inversé 00110111, plus 1 : 00111000=56. Il représente −56. On peut aussi calculer 200−256=−56.
Les réponses 1 et 2 montrent que le même octet 11001000 représente 200 ou −56 selon la convention choisie.
Encadrement par des puissances de 2 : 29=512≤1000<1024=210, il faut 10 bits.
Paquets de 4 bits : 7 donne 0111 et F donne 1111, donc (7F)16=(01111111)2. En base 10 : 7×16+15=127, le plus grand entier positif d’un octet en complément à 2.
Multiplications successives par 2 : 0,375×2=0,75 (0), 0,75×2=1,5 (1), 0,5×2=1 (1). Donc 0,375=(0,011)2, écriture finie car 0,375=3/8.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Quelle méthode permet d’écrire un entier positif en base 2 ?
Les multiplications successives servent pour la partie après la virgule ; le complément à 2 sert pour les entiers négatifs.
Question 2 / 3
L’octet 11001000 représente 200 lu comme un entier positif. Que représente-t-il en complément à 2 ?
Il commence par 1, il est donc négatif : 200−256=−56. Le même octet représente deux nombres différents selon la convention.
Question 3 / 3
Que vaut (7F)16 en base 10 ?
7×16+15=127, soit (01111111)2 : le plus grand entier positif d’un octet en complément à 2.
Exercice 2 : des couleurs en hexadécimal
En HTML, la couleur #2E8B57 est formée de trois nombres écrits en base 16 sur deux chiffres chacun : 2E pour le rouge, 8B pour le vert et 57 pour le bleu.
Q10.
Combien de bits occupe chacun des trois nombres ? Combien de valeurs différentes peut-il prendre ?
Convertir les trois nombres en base 10.
Combien de couleurs différentes peut-on écrire de cette façon ? Donner le résultat sous la forme d’une puissance de 2.
Réponse
Deux chiffres hexadécimaux correspondent à 2×4=8 bits, c’est-à-dire un octet : 28=256 valeurs, de 0 à 255.
(2E)16=2×16+14=46, (8B)16=8×16+11=139 et (57)16=5×16+7=87. C’est un vert assez sombre.
Une couleur occupe 3×8=24 bits : on peut écrire 224=16777216 couleurs.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Combien de bits occupent les deux chiffres hexadécimaux 8B ?
Chaque chiffre hexadécimal correspond à 4 bits : 2×4=8 bits, un octet.
Question 2 / 3
Que vaut (8B)16 en base 10 ?
8×16+11=139.
Question 3 / 3
Combien de couleurs différentes peut-on écrire sous la forme #RRGGBB ?
Une couleur occupe 3×8=24 bits, soit 224=16777216 couleurs.
Exercice 3 : vrai ou faux ?
Q11.
Dire si chaque affirmation est vraie ou fausse, et justifier en une phrase, avec un exemple ou un calcul.
La somme de deux entiers positifs écrits sur 16 bits tient toujours sur 16 bits.
Le produit de deux entiers positifs écrits sur un octet tient toujours sur deux octets.
Sur 8 bits, l’opposé de chaque entier relatif peut lui aussi s’écrire sur 8 bits.
En Python, 0.5 + 0.5 == 1 vaut True.
Ajouter un 0 à droite de l’écriture binaire d’un entier positif le multiplie par 10.
Réponse
Faux : la somme tient sur 17 bits. Par exemple, 65535+1=65536=216, qui demande 17 bits.
Vrai : le produit de deux entiers de 8 bits tient sur 8+8=16 bits. Le plus grand produit est 255×255=65025<65536=216.
Faux : sur 8 bits, on écrit les entiers de −128 à 127. L’opposé de −128 est 128, qui ne s’écrit pas sur 8 bits.
Vrai : 0,5=(0,1)2 s’écrit exactement en base 2, et le calcul est exact. Cela ne signifie pas qu’on peut tester l’égalité de deux flottants en général.
Faux : ajouter un 0 à droite multiplie par 2 en base 2. Par exemple, (101)2=5 et (1010)2=10.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2 (plusieurs réponses possibles)
Quelles affirmations sont vraies ?
255×255=65025<216 et 0,5 s’écrit exactement en base 2. En revanche, 65535+1=216 demande 17 bits, et ajouter un 0 à droite multiplie par 2.
Question 2 / 2
Sur 8 bits, en complément à 2, quel entier relatif n’a pas d’opposé ?
On écrit les entiers de −128 à 127 : +128 ne s’écrit pas sur 8 bits.
Exercice 4 : un dépassement de capacité
Un programme range des entiers relatifs sur 8 bits, en complément à 2. Il calcule 100+50.
Q12.
Écrire 100 et 50 sur 8 bits, puis poser leur addition.
Quel entier relatif l’octet obtenu représente-t-il ?
Expliquer pourquoi le résultat est faux, alors qu’aucune retenue n’a été perdue.
Coup de pouce
Quel est le plus grand entier relatif que l’on peut écrire sur 8 bits ?
Réponse
100=(01100100)2 et 50=(00110010)2. Leur somme est (10010110)2.
L’octet commence par 1 : il est négatif. 150−256=−106. La machine affirme que 100+50=−106.
Le résultat exact, 150, est plus grand que 127, le plus grand entier relatif écrit sur 8 bits. Il ne peut pas être représenté : c’est un dépassement de capacité. Il ne se manifeste pas ici par une retenue perdue, mais par un bit de poids fort qui passe à 1, ce qui change le signe du résultat. L’addition de deux nombres positifs qui donne un résultat négatif est le signe d’un dépassement.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Sur 8 bits en complément à 2, quel résultat la machine obtient-elle pour 100+50 ?
La somme binaire 10010110 commence par 1 : elle est lue comme 150−256=−106.
Question 2 / 2
À quoi reconnaît-on ici le dépassement de capacité ?
Aucune retenue n’est perdue : c’est le bit de poids fort qui passe à 1, ce qui change le signe du résultat.
Exercice 5 : tables de vérité
Q13.
Dresser la table de vérité de a and (b or c), qui dépend de trois variables. Combien de lignes faut-il ?
Dresser celle de (a and b) or (a and c). Que conclure ?
Écrire le programme Python qui affiche la première table, et vérifier la réponse.
Réponse
Avec trois variables, il y a 23=8 combinaisons, donc 8 lignes :
a
b
c
a and (b or c)
(a and b) or (a and c)
0
0
0
0
0
0
0
1
0
0
0
1
0
0
0
0
1
1
0
0
1
0
0
0
0
1
0
1
1
1
1
1
0
1
1
1
1
1
1
1
Les deux colonnes sont identiques : les expressions sont équivalentes. On peut « développer » and sur or, comme on développe a×(b+c) en calcul.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Combien de lignes compte la table de vérité d’une expression de trois variables ?
Chaque variable a deux valeurs possibles : 23=8 combinaisons.
Question 2 / 2
Quelle expression est équivalente à a and (b or c) ?
Les deux tables de vérité sont identiques : and se « développe » sur or, comme a×(b+c)=a×b+a×c.
Exercice 6 : programmer
Q14.
Le poids d’un entier positif est le nombre de chiffres 1 de son écriture binaire. Écrire la fonction poids sans utiliser bin, en s’inspirant de la méthode des divisions successives :
defpoids(n:int)->int:"""
Retourne le nombre de chiffres 1 de l'écriture en base 2
de l'entier positif n.
>>> poids(13)
3
>>> poids(255)
8
>>> poids(0)
0
"""
Chaque reste n % 2 est un chiffre de l’écriture binaire, égal à 0 ou à 1 : en les additionnant, on compte les 1. Contrairement à decompose, il n’est pas nécessaire de construire la chaîne.
Q15.
On veut convertir une écriture hexadécimale en entier, sans utiliser int(..., 16).
Écrire la fonction valeur_chiffre :
CHIFFRES="0123456789ABCDEF"defvaleur_chiffre(c:str)->int:"""
Retourne la valeur du chiffre hexadécimal c,
c'est-à-dire son indice dans CHIFFRES.
>>> valeur_chiffre("7")
7
>>> valeur_chiffre("B")
11
"""
En s’inspirant de la fonction recompose du Doc. 4,1, écrire la fonction hexa_vers_decimal :
defhexa_vers_decimal(hexa:str)->int:"""
Retourne l'entier dont hexa est l'écriture en base 16.
>>> hexa_vers_decimal("2E")
46
>>> hexa_vers_decimal("7E3")
2019
"""
Coup de pouce
Parcourir les indices de CHIFFRES et retourner l’indice dès que le caractère correspond.
Dans recompose, on multipliait par 2 à chaque nouveau chiffre. Par combien faut-il multiplier en base 16 ?
Pour "7E3" : n vaut successivement 7, puis 16×7+14=126, puis 16×126+3=2019.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Quel est le poids (nombre de chiffres 1 de l’écriture binaire) de l’entier 10 ?
10=(1010)2 contient deux chiffres 1.
Question 2 / 3
Dans hexa_vers_decimal, par combien multiplie-t-on n à chaque nouveau chiffre lu ?
C’est la même méthode que recompose, avec 16 à la place de 2 : chaque chiffre déjà lu monte d’une position en base 16.
Question 3 / 3
Pour "2E", quelles valeurs n prend-il successivement dans hexa_vers_decimal ?
16×0+2=2, puis 16×2+14=46.
Exercice 7 : une moyenne qui ne tombe pas juste
Un élève a écrit le programme suivant :
moyenne=(12.3+11.9+12.1)/3ifmoyenne==12.1:print("La moyenne vaut 12,1")else:print("La moyenne ne vaut pas 12,1")
Q16.
Calculer la moyenne à la main. Quel message l’élève attend-il ?
Exécuter le programme. Quel message s’affiche ? Expliquer.
Corriger le programme.
Réponse
12,3+11,9+12,1=36,3 et 36,3/3=12,1 : il attend « La moyenne vaut 12,1 ».
Le programme affiche « La moyenne ne vaut pas 12,1 ». moyenne vaut 12.100000000000001 : les nombres 12,3, 11,9 et 12,1 n’ont pas d’écriture binaire finie, et les erreurs d’arrondi des calculs rendent le résultat légèrement différent du flottant 12.1.
On compare l’écart à une petite valeur au lieu de tester l’égalité :
moyenne=(12.3+11.9+12.1)/3ifabs(moyenne-12.1)<1e-9:print("La moyenne vaut 12,1")else:print("La moyenne ne vaut pas 12,1")
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Que vaut la variable moyenne après moyenne = (12.3 + 11.9 + 12.1) / 3 ?
12,3, 11,9 et 12,1 n’ont pas d’écriture binaire finie : les erreurs d’arrondi s’accumulent.
Question 2 / 2
Quelle condition corrige le test moyenne == 12.1 ?
On compare l’écart à une petite valeur au lieu de tester l’égalité. round(moyenne) donne l’entier 12.
Bilan
À l’issue de cette activité, je sais…
identifier, devant une écriture binaire, la convention à utiliser (entier positif, complément à 2, nombre à virgule) et le nombre de bits ;
convertir un entier entre les bases 2, 10 et 16, et un nombre à virgule simple en base 2 ;
prévoir la taille d’une somme ou d’un produit, et reconnaître un dépassement de capacité, y compris en complément à 2 ;
dresser la table de vérité d’une expression de trois variables et comparer deux expressions ;
programmer des calculs sur l’écriture binaire ou hexadécimale d’un entier ;
corriger un programme qui teste l’égalité de deux flottants.