Nombres flottants et valeurs booléennes

Après les entiers, voici deux autres types de base.

Les nombres flottants (type float) représentent les réels de façon approximative : comprendre pourquoi $0{,}1 + 0{,}2$ n'est pas égal à $0{,}3$ évite des bugs classiques.

Les booléens (type bool) ne prennent que deux valeurs, vrai ou faux. Ils se combinent avec and, or, not et xor, et sont au cœur des conditions, des boucles, et même des circuits qui additionnent les bits.

1. Les nombres réels en machine

1.1 La partie fractionnaire en binaire

Après la virgule, les positions valent des puissances négatives de $2$ : $2^{-1} = 0{,}5$, puis $2^{-2} = 0{,}25$, $2^{-3} = 0{,}125$, $2^{-4} = 0{,}0625$, et ainsi de suite.

$\overline{110{,}101}^{\,2} = 4 + 2 + 0{,}5 + 0{,}125 = 6{,}625.$

Donc $0{,}25 = \overline{0{,}01}^{\,2}$ : l'écriture s'arrête, elle est exacte.

De même, $0{,}75 = \overline{0{,}11}^{\,2}$ et $6{,}5 = \overline{110{,}1}^{\,2}$.

$0{,}1 = \overline{0{,}0\,0011\,0011\,0011\ldots}^{\,2}$

C'est le même phénomène que $1/3 = 0{,}333\ldots$ en base $10$ : le nombre $0{,}1$ n'a pas d'écriture binaire finie. Il en va de même pour $0{,}2$, pour $0{,}3$, et pour $1/3 = \overline{0{,}010101\ldots}^{\,2}$.

Le programme applique la méthode à la fraction $\dfrac{1}{10}$, avec des entiers uniquement pour rester exact. Essaie ensuite $\dfrac{3}{8}$, puis $\dfrac{1}{3}$.

def fraction_binaire(num, den, nb_chiffres):
    """Chiffres binaires après la virgule de num/den (avec 0 <= num < den)."""
    chiffres = ""
    for i in range(nb_chiffres):
        num = num * 2            # on multiplie par 2
        chiffres = chiffres + str(num // den)   # partie entière : 0 ou 1
        num = num % den          # on garde le reste
        if num == 0:
            break
    return "0," + chiffres

print(fraction_binaire(1, 10, 24))

1.2 Le nombre flottant

Un ordinateur dispose d'un nombre fixe de bits, en général $64$.

La virgule « flotte » grâce à l'exposant : le même format code $10^{-300}$ et $10^{300}$.

Ce format est fixé par la norme IEEE 754. Il en existe une version sur $32$ bits. Aucun détail de la norme n'est à connaître.

1.3 Une représentation approximative

Si la mantisse d'un nombre est infinie, on la tronque à $52$ bits et on arrondit : le nombre stocké n'est plus exactement le nombre voulu.

Exécute ce bloc avant de lire la suite.

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(0.1 * 3)
print(1 / 3)

En mémoire, 0.1 vaut en réalité $0{,}1000000000000000055\ldots$

L'erreur est de l'ordre de $10^{-17}$ : on dispose d'environ $16$ chiffres significatifs corrects.

total = 0
for i in range(10):
    total = total + 0.1

print(total)
print(total == 1)

1.4 Règles pratiques

def presque_egaux(a, b):
    return a == b

2. Les valeurs booléennes

2.1 Deux valeurs

C'est le résultat d'une comparaison (x > 3, a == b, mot in liste), et c'est le type des conditions dans if et while.

>>> 7 > 3
True
>>> "z" in "python"
False
>>> type(7 > 3)
<class 'bool'>

2.2 Les opérateurs and, or, not, xor

En Python, le ou exclusif de deux booléens s'écrit a != b, ou a ^ b.

Python retrouve ces tables. Ajoute une colonne pour not a, ou pour a and not b.

for a in [False, True]:
    for b in [False, True]:
        print(a, b, "| and :", a and b, "| or :", a or b, "| xor :", a != b)

def xor(a, b):
    return a or b

2.3 Dresser la table d'une expression

Pour une expression à $n$ variables, la table a $2^n$ lignes. On ajoute une colonne par sous-expression.

Voici la table de $E = (a \text{ and not } b) \text{ or } c$.

Python peut dresser la table à ta place. Remplace l'expression par une autre, par exemple a or (b and c).

print("a b c   E")
for a in [False, True]:
    for b in [False, True]:
        for c in [False, True]:
            E = (a and not b) or c
            print(int(a), int(b), int(c), " ", int(E))

2.4 Le caractère séquentiel de and et or

On parle aussi d'évaluation en court-circuit. Elle sert à protéger une expression dangereuse.

t = [4, 0, 7]
i = 5

if i < len(t) and t[i] == 0:    # i est trop grand : t[i] n'est jamais évalué
    print("case nulle")
else:
    print("rien à signaler")

x, y = 10, 0
print(y != 0 and x / y > 2)     # pas de division par zéro

Inverse maintenant les deux conditions du if, en écrivant t[i] == 0 and i < len(t), puis relance : l'erreur d'index apparaît.

2.5 Application : l'addition binaire

Additionner deux bits $a$ et $b$ donne une somme et une retenue.

Ce circuit montre que les opérateurs logiques suffisent à calculer : un processeur n'est qu'un immense assemblage de portes logiques.

def demi_additionneur(a, b):
    """a et b valent 0 ou 1 ; renvoie (somme, retenue)."""
    somme = (a != b)                   # xor
    retenue = (a == 1 and b == 1)      # and
    return int(somme), int(retenue)

for a in [0, 1]:
    for b in [0, 1]:
        print(a, "+", b, "->", demi_additionneur(a, b))

3. Exemple résolu pas à pas

À retenir