Changements de base en python

Ecrire un nombre dans une base entière $n \geq 2$, c'est l'écrire sous la forme $a_k a_{k-1} \dots a_1 a_0$ où tous les coefficients sont des nombres compris entre $0$ et $n-1$

En base $10$ les coefficients sont donc des entiers entre $0$ et $9$.

Connaissant l'écriture en base $n$ on peut retrouver l'écriture en base $10$ :

$$a_k a_{k-1} \dots a_1 a_0 = a_n \times n^k + a_{k-1} \times n^{k-1} + \dots + a_1 \times n + a_0 \times 1$$

En effet $n^1 = n$ et $n^0=1$

Comment convertir un nombre d'une base donnée vers la base $10$ ?

Et de la base $10$ vers la base $2$ ?

Et vers une base quelconque ?

I. Vers la base 10

C'est le cas le plus facile.

Imaginons que l'on ait le nombre $1101_2$ écrit en binaire (base $2$).

On utilise le tableau suivant :

Exposant $n$ $3$ $2$ $1$ $0$
$2^n$ $8$ $4$ $2$ $1$
Coefficient $1$ $1$ $0$ $1$
Coeff * Puissance $8$ $4$ $0$ $1$

Le nombre en décimal vaut donc : $1101_2 = 1 \times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0 = 8 + 4 + 0 + 1 = 13$

L'algorithme est simple : on parcourt tous les coefficients de l'écriture et on multiplie chaque valeur par la puissance correspondante

In [10]:
def bin_dec(nombre) :
    # nombre est à convertir. C'est une chaîne de caractères
    # Renvoie le nombre convertit en base 10
    resultat = 0
    
    taille = len(nombre)
    
    for i in range(taille) :
        resultat += int(nombre[i]) * 2**(taille - 1 - i)
        # nombre est une chaîne de caractère. Son i-ième caractère est convertit en entier (int) avant les calculs
        # Les valeurs de i vont de 0 à taille - 1
        # On lit donc en premier le premier coefficient
        # Il correspond à la puissance taille - 1 (taille - 1 - i avec i = 0) 
    
    return resultat
In [11]:
bin_dec('1101')
Out[11]:
13

Et si on utilise une autre base $n$ ? Il suffit de changer la puissance.

In [13]:
def n_dec(nombre, base) :
    # nombre est à convertir. C'est un chaîne de caractères
    # base est un entier
    # Renvoie le nombre convertit en base 10
    resultat = 0
    
    taille = len(nombre)
    
    for i in range(taille) :
        resultat += int(nombre[i]) * base**(taille - 1 - i)

    
    return resultat
In [14]:
n_dec('321', 4)
Out[14]:
57

On vient de vérifier que $321_4 = 57$

Remarques :

II. Vers le binaire :

La méthode de conversion est expliquée dans le notebook Codage d'entiers.

Voici le code python :

In [19]:
def dec_bin(nombre) :
    # nombre est à convertir. C'est un entier
    # Renvoie le nombre convertit en base 2
    
    resultat = ""
    while nombre > 0 :
        resultat = str(nombre % 2) + resultat
        nombre = nombre // 2
        
    return resultat
In [20]:
dec_bin(13)
Out[20]:
'1101'
In [22]:
# Vérification à l'aide de la fonction bin de python
# Le '0b' devant le résultat signifie que l'on est en binaire
bin(13)
Out[22]:
'0b1101'

III. Vers l'hexadécimal :

La méthode de conversion est analogue à celle du binaire. On doit toutefois prendre soin de gérer les coefficients $a$ à $f$.

Voici le code python :

In [24]:
def dec_hex(nombre) :
    # nombre est à convertir. C'est un entier
    # Renvoie le nombre convertit en base 16
    
    coefficients = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'] 
    
    resultat = ""
    while nombre > 0 :
        resultat = coefficients[nombre % 16] + resultat
        nombre = nombre // 16
        
    return resultat
In [25]:
dec_hex(13)
Out[25]:
'd'
In [26]:
dec_hex(255)
Out[26]:
'ff'
In [28]:
# Vérification à l'aide de la fonction hex de python
# Le '0x' devant le résultat signifie que l'on est en héxadécimal
hex(255)
Out[28]:
'0xff'