Écrire un entier naturel en base b ≥ 2

Pourquoi le binaire ?

Vus de l'extérieur, les ordinateurs manipulent des nombres, du texte, des images, du son. Mais à l'intérieur, chaque circuit électronique n'a que deux états possibles : le courant passe, ou il ne passe pas.

Pour représenter des nombres, du texte ou des images avec seulement deux états, il faut donc les écrire comme des suites de 0 et de 1 : c'est la base 2, ou système binaire.

Bit, octet, mot

Exemple : le mot 100 représente l'état d'un circuit composé de 3 circuits mémoire un bit, dont les états sont 1, 0 et 0.

Le même principe qu'en base 10

Quand un rang est plein, on passe au rang suivant — exactement comme en base 10, sauf qu'un rang binaire n'accepte que 0 ou 1.

Convertir un binaire en décimal

Comme en base 10 où 352 = 3×10² + 5×10¹ + 2×10⁰, en base 2 chaque position vaut une puissance de 2.

Exemple guidé

64 + 8 + 4 + 1 = 77, donc (01001101)₂ = (77)₁₀.

En Python — prédis, puis exécute

print(int('1101', 2))
print(int('01001101', 2))

À toi, convertis à la main : 1₂, 10₂, 100₂, 1110₂, 101010₂.

→ Fiche d'exercices : exercices 4 à 7.

Convertir un décimal en binaire

On effectue une succession de divisions euclidiennes par 2, jusqu'à obtenir un quotient nul. Le résultat est la juxtaposition des restes, lus du dernier au premier.

Restes lus de bas en haut : 1001101, donc (77)₁₀ = (1001101)₂.

n = 10
n = n - 1   # n vaut maintenant 9

if n == 0:
    print("zero")
elif n > 0:
    print("positif")
else:
    print("negatif")

n = 13
while n > 0:
    print(n)
    n = n - 1   # affiche 13, 12, 11, ... jusqu'a 1

for i in range(5):
    print(i)   # affiche 0, 1, 2, 3, 4

13 % 2    # reste de 13 / 2  ->  1
13 // 2   # quotient de 13 / 2  ->  6

chiffres = []
chiffres.append('1')
chiffres.append('0')
print(chiffres)      # ['1', '0']
chiffres.reverse()
print(chiffres)      # ['0', '1']

''.join(['1', '0', '1'])   # '101'

def double(x):
    return x * 2

print(double(5))   # 10

Trace d'exécution — suis la boucle pas à pas

Avant d'écrire la fonction, vérifie que tu comprends bien ce que fait la boucle while : trace son exécution pour n = 13 (une ligne du tableau = un tour de boucle).

À toi de coder — complète la fonction

def entier_vers_binaire(n):
    if n == 0:
        return '0'
    chiffres = []
    while n > 0:
        chiffres.append(str(n % 2))
        n = n // 2
    chiffres.reverse()
    return ''.join(chiffres)

Le système hexadécimal (base 16)

La base 16 a besoin de 16 symboles : les 10 chiffres 0 à 9, puis A, B, C, D, E, F pour 10 à 15.

Même principe que pour le binaire, avec des divisions successives par 16 :

Donc (335)₁₀ = (14F)₁₆.

À toi : convertis 965 en base 16.

→ Fiche d'exercices : exercices 12 et 13.

Généraliser à une base b quelconque

En base b, on a besoin de b symboles. Un nombre écrit (aₙ₋₁ ... a₁ a₀) en base b se lit comme une somme de puissances de b :

7.1 — De la base 10 vers la base b

On effectue une succession de divisions euclidiennes par b, jusqu'à un quotient nul. Le résultat est la juxtaposition des restes, lus du dernier au premier (même méthode qu'en base 2 ou en base 16, avec b au lieu de 2 ou 16).

Donc (50)₁₀ = (1212)₃.

7.2 — De la base b vers la base 10

On applique directement la formule ci-dessus : chaque chiffre est multiplié par la puissance de b correspondant à sa position, puis on additionne.

7×256 + 2×16 + 12×1 = 1792 + 32 + 12 = 1836, donc (72C)₁₆ = (1836)₁₀ (rappel : C₁₆ = 12₁₀).

→ Fiche d'exercices : exercice 14.

Coder la généralisation

Tout ce qu'on a vu se code aussi : divisions successives par b.

⭐ NIVEAU FACILE — base b ≤ 10

def entier_vers_base(n, b):
    if n == 0:
        return '0'
    chiffres = []
    while n > 0:
        chiffres.append(str(n % b))
        n = n // b
    chiffres.reverse()
    return ''.join(chiffres)

⭐⭐ NIVEAU INTERMÉDIAIRE — gérer la base 16

Pour b = 16, un reste peut valoir jusqu'à 15 : il faut le traduire en symbole. La chaîne "0123456789ABCDEF" indexée par le reste donne directement le bon caractère.

def entier_vers_base(n, b):
    symboles = "0123456789ABCDEF"
    if n == 0:
        return '0'
    chiffres = []
    while n > 0:
        chiffres.append(symboles[n % b])
        n = n // b
    chiffres.reverse()
    return ''.join(chiffres)

⭐⭐⭐ NIVEAU AVANCÉ — vérifier avec les outils natifs

print(hex(335))
print(format(335, 'X'))
print(int('14F', 16))

La méthode courte : paquets de 4 bits

Sur 4 bits, on représente exactement 2⁴ = 16 valeurs : chaque chiffre hexadécimal correspond donc exactement à un groupe de 4 bits.

Tableau de référence (à connaître par cœur, à terme)

Donc (0100 1101)₂ = (4D)₁₆.

n = 0b01001101
print(format(n, 'X'))
print(format(0xB931, 'b'))

→ Fiche d'exercices : exercices 15 et 16.

Exercices progressifs

3 exercices de difficulté croissante. Réfléchis avant de consulter la correction !

def poids_binaire(n):
    return entier_vers_binaire(n).count('1')

def est_puissance_de_deux(n):
    return n > 0 and poids_binaire(n) == 1

Convertisseur interactif

Entre un nombre dans une base, il se convertit automatiquement dans les autres — utile pour vérifier tes calculs à la main.

Quiz interactif — Entiers naturels en base b

Banque de 52 questions. Choisissez le nombre de questions et lancez le tirage.