Les types de base
Écriture d’un entier positif dans une base b ≥ 2
Généralités
écriture d'un nombre en base b
Un nombre s'écrit comme une suite de symboles ; le plus à droite correspond aux unités ; c'est à dire au nombre qui est multiplié par b0 = 1
Pour écrire un nombre en base b, il faut b symboles ; jusqu'à la base 10, les symboles 0 à 9 sont utilisés, puis au delà les lettres de l'alphabet (sans tenir compte de la casse).
Les nombres s'écrivent donc sous la forme :
nombre =
symbolen-1.bn-1+
symbolen-2.bn-2+ …
symbole2.b2+
symbole1.b1+
symbole0.b0
La base 10
Les nombres écrits en base 10 utilisent en occident 10 symboles arabes ;
l'écriture naturelle des nombres se fait dans le même sens que l'écriture arabe :
de la droite vers la gauche, en considérant que le symbole de poids
faible est le premier que l'on devrait logiquement écrire. Par exemple :
le nombre 125 désigne 5 unités + 2 dizaines + 1 centaine.
Si vous
n'êtes pas convaincus cliquer ici
La base 2 : nombres binaires
Généralités
description d'un nombre binaire
Un nombre binaire s'écrit comme une suite de chiffres 0 ou 1; le plus à droite correspond aux unités ; c'est à dire au nombre qui est multiplié par 20 = 1
Pour écrire un nombre en base 2, il faut 2 symboles.
Les nombres binaires s'écrivent donc sous la forme :
nombre = symbolen-1.2n-1+
symbolen-2.2n-2+ …
symbole2.22+
symbole1.21+
symbole0.20
Par exemple :
le nombre binaire 0010110.011 est égal à la somme (de gauche à droite) :
S = 0 x 2 6 + 0 x 2 5 + 1 x 2 4 + 0 x 2 3 +
1 x 2 2 + 1 x 2 1 + 0 x 2 0 + 0 x 2 -1 +
1 x 2 -2 + 1 x 2 -3
0 + 0 + 16 + 0 + 4 + 2 + 0 + 0 + 1/4 + 1/8 = 22.375
N.B. : les zéros à gauche et à droite sont inutiles !
Le bit le plus à gauche est dit de poids
fort car il représente la composante la plus grande du
nombre.
Le bit le plus faible est à droite et correspond
aux unités.
En python !
les fonctions bin et int
La fonction bin(nombre) permet d'écrire un nombre dans sa représentation binaire sous forme de chaîne de caractère ; par exemple :
La fonction int(argument1, argument2) est souvent utilisée uniquement avec le premier argument qui est une chaîne de caractère représentant un nombre entier ; par exemple bin("125") renvoie le nombre entier 125. Le deuxième argument est par défaut le nombre 10 car il précise la base du nombre représenté de l'argument 1. Si on veut convertir un nombre écrit dans un chaîne de caractères en base N (N pouvant prendre des valeurs de 2 à 36), int le converti en nombre décimal ; par exemple int("101",2) == int("0b101",2) == int("5") == int("5", 6) égal 5 ; int("coucou", 36) renvoie le nombre 767321022 qui s'écrit "coucou" en base 36 !.
bin(128)
'0b10000000'
bin(1+2+4+8+16+64) # manque 32 donc manquera le 6ième 1 en partant du bit de poids faible
'0b1011111'
chaineBin = bin(254) # chaineBin devient '0b11111110' 255 c'est 8 1 qui se succèdent
int( chaineBin , 2 ) # converti chaineBin en décimal (254) ; 2 est la base de chaine Bin
254
bin( 0b101 - 5) # l'argument de bin peut être une combinaison de nombres dans différentes bases.
'0b0'
bin(0b111 - 7 + 0xf) # 0x est le préfixe d'un hexadécimal
15
N.B. ci-dessus sont représentées tour à tour, les instructions tapées dans la console python et leur interprétation après le retour à la ligne (entrée ou retour chariot).
Opérations bit à bit
Python fournit six opérateurs de base pour agir directement sur les bits des nombres ; pour comprendre, il vaut mieux travailler sur la représentation binaire des nombres :
& | ^ ~ » «
- & : 0b1010 & 0b1100 == 0b1000 ; correspond à la fonction logique ET (AND) ;
- | : 0b1010 | 0b1100 == 0b1110 ; correspond à la fonction logique OU (OR) ;
- ^ : 0b1010 ^ 0b1100 == 0b0110 ; correspond à la fonction logique OU exclusif (XOR) ;/li>
- ~ : ~0b000 == 0b111 correspond à la fonction logique non (NOT) ;
- » : 0b1010 » 3 == 0b1,01 décale les chiffres de 3 positions vers la droite ;
cela revient dans cet exemple à diviser par 23 = 8 le nombre; - « : 0b1010 « 4 == 0b10100000 décale les chiffres de 4 positions vers la gauche ;
cela revient dans cet exemple à multiplier par 24 = 16 le nombre ;
opérateur (et = and) &
opérateur & = et = and
Le bit du nombre obtenu est à 1 si les bits de même poids dans les deux nombres a et b sont à un.
Exemples en python : à tester !
# la fonction bin(nombre) renvoie un str du nombre en binaire
bin(0b1111 & 0b1000) # application au masquage (ou pochoir)
'0b1000'
bin(0xffff & 0xf1f4)
'0xf0f0'
bin(1+2+4+8+16+64) # manque 32 donc manquera le 6ième 1 en partant du bit de poids faible
'0b1011111'
#ça marche aussi en direct sur des nombres mais c'est moins évident !
7 & 4
4
bin(7)
'0b111'
bin(4)
'0b100'
bin(7 & 4)
'0b100' #CQFD !
'|': ou.
opérateur | = ou = or
Cet opérateur sert à comparer les bits de même poids (ou rang) dans les deux nombres comparés bit à bit et renvoie 0 si et seulement si chaque bit est nul.
Exemples en python : à tester !
a = 9
bin(a)
'0b1100'
b = 7
bin(b)
'0b111'
bin(a | b)
'0b1111'
a|b == 15
True
'^': ou exclusif.
opérateur ^ = xor = xor
L'opérateur xor effectue une comparaison logique entre les bits de même rang dans deux nombres et
applique la fonction xor qui est le ou exclusif ; si un des deux bits est à 1 et l'autre à 0, le
résultat comportera un bit à 1 à la même position, sinon 0 ;
Exemples en python : à tester !
a = 9
bin(a)
'0b1100'
b = 7
bin(b)
'0b111'
bin(a ^ b)
'0b1110'
a^b == 14
True
'~': inversion des bits .
opérateur ~ = non = not
Chaque bit d'un nombre dans sa représentation binaire est inversé, y compris le bit de poids fort qui est le bit de signe ; les 0 deviennent des 1 et vis-versa.
Exemples en python : à tester !
# l'inversion bit à bit est un complément à 1
a = 8
bin(a)
'0b1000'
b = ~a
bin(b)
'-0b1001'
b
-9
# vous remarquerez qu'ici b = -a - 1 c'est à dire que -b = a + 1 d'où a = -1 - b = -(b + 1)
b == -a-1 and -b == a+1 and a == -(b+1)
True
abs(~a+1) == a
True
# la fonction builtins abs renvoie la valeur absolue ; donc a = |~a + 1|
# ~a + 1 est une opération qui s'appelle "prendre le complément à 2 de a pour obtenir son opposé !
# devinette : que donne a + ~a + 1 ?
'»': décalage de n bit(s) à droite (correspond à une division par 2n)
opérateur >> décalage vers la droite
L'opération de s=décalage des bits vers la droite (ou la gauche) est une opération réalisée directement en langage machine dans le processeur logique et arithmétique
; c'est donc une opération très rapide pour diviser un entier par une puissance de 2 !Exemples en python : à tester !
# division par une puissance de 2 : ici 4
a = 8
bin(a)
'0b1000'
a >> 2
2
#au dela d'une certaine valeur de décalage, le nombre devient 0 ; c'est le résultat de la division entière ou euclidienne
a >> 4 == 0
True
'«': décalage de n bit(s) à gauche (correspond à une multiplication par 2n)
opérateur << décalage vers la gauche
L'opération de s=décalage des bits vers la gauche (ou la droite) est une opération réalisée directement en langage machine dans le processeur logique et arithmétique
; c'est donc une opération très rapide pour multiplier un entier par une puissance de 2 ! Mais cela peut servir aussi pour multiplier par n'importe quel nombre avec un peu de méthode !Exemples en python : à tester !
# multiplication par une puissance de 2 : ici 4
a = 8
bin(a)
'0b1000'
a << 2
32
bin(32)
'0b100000'
#multiplication par 5 = 4 + 1
b = (a << 2) + a
b == 5 * a
True
# Attention ! le décalage est moins prioritaire que l'addition !
c = a << 2 + a # va décaler les bits de a de 2 + 8 = 10 bits !
bin(c)
'0b10000000000000'
La base 16 : les nombres hexadécimaux
La base 16 est utilisée pour écrire de manière compacte des nombres utilisés en programmation, car ils sont dans un grand nombre de cas des puissances de 2 ; par exemple, les niveaux de couleur dans le système rgb sont souvent codés sur 256 niveaux, soit de 0 à 255 ou en hexadécimal de 0x0 à 0xff (en python le préfixe 0x désigne un hexadécimal).
exercices
- convertir le binaire 0b10001000 en hexadécimal
réponse
0x88
- convertir le binaire 0b1111 1010 1011 1010 en hexadécimal
réponse
0xfaba chaque groupe de 4 bits représente un nombre hexadécimal !
- Une couleur peut s'écrire sous la forme d'un nombre à 3 symboles en base 256, le premier symbole
représente le niveau de rouge (de 0 à 255), le second le niveau de vert (de 0 à 255) et le dernier le
niveau de bleu (de ...), ou bien en utilisant la fonction CSS : rgb(200,255,200) qui code ici pour un
vert clair. Coder en hexadécimal la "couleur" blanche = rgb(255,255,255) ; la "couleur" noir =
rgb(0,0,0); un gris moyen = rgb(128,128,128) ; du rouge pur = rgb(255,0,0)
réponse
- blanc = rgb(255,255,255) = #ffffff ;
- noir = rgb(0,0,0) = #000000
- gris médian = rgb(128,128,128) = #808080 ; 128 = 0b1000 0000 = 0x80 ;
- rouge = rgb(255, 0,0) = #ff0000 ;
Base : 2 16 -
Représentation des nombres entiers négatifs : complément à 2
Un choix judicieux
Il y a plusieurs solutions permettant de coder les nombres négatifs.
au moins deux possibilités existent
Le bit de poids fort (le plus à droite) servira de bit codant le signe (0 = + et 1 = -) mais il y a deux façons de l'utiliser :
- par exemple sur un octet (byte) la première position (à gauche) code le signe, il reste donc 7 positions pour coder des nombres de 0 à 127. Le problème dans ce cas, est qu'il y a deux façons d'écrire 0 : 0b0000 0000 = +0 et 0b1000 0000 = -0 ; ce codage est redondant ;
- l'autre solution en apparence plus complexe, consiste à calculer l'opposé d'un entier en prenant son complément à 2 ; cela consiste à
inverser tout ses bits avec la fonction logique NON(A) notée
A ou ¬A puis ajouter 1 au résultat ; un nombre négatif aura donc un bit de signe à 1 mais c'est l'ensemble des bits qui seront modifiés par rapport au codage de son opposé (positif). Par exemple :0000 1000 == 16 son opposé sera 1111 0111 + 1 = 1111 1000C'est cette solution qui a été conservée car elle offre plusieurs avantages :
En python : ~16 donnera -17 et donc ~16 + 1 = -16 car ~ inverse chaque bit ; ~ est la fonction Non appliquée à chaque bits du nombre- il n'y qu'un seul zéro ;
- l'addition ou la soustraction deviennent simples : une soustraction est l'addition d'un premier nombre à l'opposé du second terme : A - B = A + (-B) ; 12 - 4 = 12 + (-4) = 12 + (~4 +1)
- le plus petit nombre écrit sur un octet sera -128 car tous les nombre positifs seront noté de 0000 0000 = 0 à 0111 1111 = 127
leur complément à deux ira de -1 = 1111 1111 à -128 = 1000 0000 car -127 = ~(0111 1111) + 1 = 1000 0000 + 1 = 1000 0001 auquel on soustrait 1 pour obtenir -128 soit 1000 0000