Participer au site avec un Tip
Rechercher
 

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Base binaire et opérations bit à bit

Manipulation de valeurs entières Manipulation de valeurs flottantes


Accès rapide :
Préambule
Introduction au système binaire
Généralité
Les opérateurs binaires
L'opérateur binaire AND
L'opérateur binaire OR (le ou inclusif)
L'opérateur binaire XOR (le ou exclusif)
L'opérateur binaire NOT
Représentation des nombres négatifs
Les opérateurs Python relatifs aux opérations binaires de base
Les opérateurs de décalage de bits
Les opérateurs d'affectation

ce chapitre traite des opérateurs de manipulation d'entiers bit à bit. Il n'est pas obligatoire pour la compréhension du reste de ce tutoriel Python. Si vous n'êtes pas sensibilisé à l'utilisation du binaire et si vous ne comptez pas utiliser ces possibilités, alors vous pouvez passer ce chapitre.

Préambule

Les operateurs bit à bit ne fonctionnent que et uniquement que sur des valeurs entières. Si vous tentez de les utiliser sur des valeurs flottantes, des erreurs seront déclenchées : voici, à titre d'information, le type d'erreur qui vous sera retourné.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
>>> 15.5 & 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for &: 'float' and 'int'
>>> 15.5 & 4.0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for &: 'float' and 'float'
>>> 15 & 4
4
>>>

De plus, vous pouvez obtenir la représentation binaire d'une valeur grâce à la fonction bin. Cette fonction renvoie une chaîne de caractères qui correspond à la représentation binaire de votre valeur. Voici un exemple d'utilisation.

 1 
 2 
 3 
 4 
 5 
 6 
>>> value = 15
>>> bin(value)
'0b1111'
>>> type(bin(value))
<class 'str'>
>>>
Récupération de la représentation binaire d'une valeur

Introduction au système binaire

Généralité

Nous l'avons vu dans un chapitre précédent, Python permet d'exprimer la valeur de vos entiers via différentes bases numériques (le binaire, le décimal et l'hexadécimal). Nous allons, dans ce chapitre, porter notre attention sur la base numérique binaire : on parle aussi de système binaire.

En base binaire, on utilise uniquement deux chiffres : le 0 et le 1. Le tableau suivant vous présente quelques valeurs exprimées en binaire, mais aussi en décimal et en hexadécimal.

Valeur en binaire Valeur en décimal Valeur en hexadécimal
00000000 0 0
00000001 1 1
00000010 2 2
00000011 3 3
00000100 4 4
00000101 5 5
00000110 6 6
00000111 7 7
00001000 8 8
00001001 9 9
00001010 10 A
00001011 11 B
00001100 12 C
00001101 13 D
00001110 14 E
00001111 15 F
00010000 16 10
00100000 32 20
01000000 64 40
10000000 128 80
11111111 255 FF

Dans le système de numération binaire, un chiffre est appelé un bit. En électronique cette notion de bit est très importante, car elle correspond à l'état électrique d'un fil électrique (en caricaturant) : 0 correspond à l'absence de courant sur ce fil et 1 correspond à la présence du courant sur ce fil. Il faut aussi noter que sur l'électronique actuellement utilisée dans nos ordinateurs, on utilise des transistors qui ne savent gérer que deux états : 0 ou 1.

Ce dernier point est en passe de changer avec l'avènement des ordinateurs quantiques, mais c'est une autre histoire.

Il est aussi à noter, qu'on a pris l'habitude, en électronique et donc en informatique, de regrouper les bits par blocs de 8. On appelle un tel ensemble un octet. Comme un octet est constitué de 8 bits et comme chacun de ces bits ne peut valoir que 0 ou 1 (2 états), cet octet peut donc avoir 256 (soit 2 ** 8) états distincts, de 0 à 255.

En analysant ce tableau on peut constater que chaque position de bit, si le bit est fixé à 1, correspond à une puissance de 2. Un décalage de tous les bits d'un cran vers la gauche, en ajoutant un 0 en première position, correspond donc à une multiplication par 2. De même, un décalage de tous les bits d'un cran vers la droite, en ajoutant un 0 en dernière position, correspond donc à une division entière par 2.
On constate aussi que l'hexadécimal permet de représenter n'importe quelle valeur d'un octet sur deux digits hexadécimaux (de 00 à FF), ce qui est relativement pratique en informatique. Le chiffre hexadécimal de gauche correspond aux quatre bits de gauche (en représentation binaire) et le chiffre de droite correspond aux quatre bits de droite (en représentation binaire). 24 = 16 et 16*16 = 256.

Les opérateurs binaires

Outre les opérations arithmétiques classiques (addition, soustraction, multiplication, division), le système binaire propose des opérateurs de manipulation de bits. Ces opérateurs sont appelés AND (le « et » binaire), OR (le « ou » binaire, aussi appelé « ou inclusif »), le XOR (le « ou exclusif » binaire) et le NOT (le « non » binaire, autrement dit la négation binaire). Ces opérateurs travaillent sur une paire de bits, à l'exception du NOT qui travaille sur un unique bit.

L'opérateur binaire AND

Le tableau suivant précise le fonctionnement de l'opérateur AND.

AND 0 1
0 0 0
1 0 1

On peut appliquer cet opérateur sur deux valeurs complexes : pour chaque pair de bits, on calculera 1 si les deux bits de même position dans les deux valeurs considérées sont bien fixés à 1. Sinon, on calculera 0. Par exemple :

\ Binaire Décimal Hexadécimal
Première valeur 01010101 85 55
Seconde valeur 11110000 240 F0
AND 01010000 80 50

L'opérateur binaire OR (le ou inclusif)

Le tableau suivant précise le fonctionnement de l'opérateur OR.

OR 0 1
0 0 1
1 1 1

On peut appliquer cet opérateur sur deux valeurs complexes : pour chaque pair de bits, on calculera 1 si ou moins un des deux bits de même position dans les deux valeurs considérées est fixé à 1. Sinon, on calculera 0. Par exemple :

\ Binaire Décimal Hexadécimal
Première valeur 01010101 85 55
Seconde valeur 11110000 240 F0
OR 11110101 245 F5

L'opérateur binaire XOR (le ou exclusif)

Le tableau suivant précise le fonctionnement de l'opérateur XOR.

XOR 0 1
0 0 1
1 1 0

On peut appliquer cet opérateur sur deux valeurs complexes : pour chaque pair de bits, on calculera 1 si un seul des deux bits de même position dans les deux valeurs considérées est fixé à 1. Sinon, on calculera 0. Par exemple :

\ Binaire Décimal Hexadécimal
Première valeur 01010101 85 55
Seconde valeur 11110000 240 F0
XOR 10100101 165 A5

L'opérateur binaire NOT

Le tableau suivant précise le fonctionnement de l'opérateur NOT.

Bit NOT
0 1
1 0

On peut appliquer cet opérateur sur une valeur complexe : chacun de ses bits sera inversé. Par exemple :

\ Binaire
Une valeur 01010101
NOT de cette valeur 10101010

Représentation des nombres négatifs

En informatique les nombres signés sont gérés d'une manière particulière. Pour un type entier quelconque, le bit dit de point fort (celui le plus à gauche) est appelé bit de signe. S'il est fixé à 1, on a alors à faire à une valeur négative. S'il est à 0, la valeur est donc considérée comme positive.

Cette représentation des nombres négatifs utilisée par Python est appelée « Complément à deux ». Cette représentation cherche à éviter d'avoir deux formes de la valeur 0 (signé ou non), contrairement à la représentation de type « complément à un ».

Les opérateurs Python relatifs aux opérations binaires de base

Il est maintenant temps de voir comment représenter les opérateurs vu précédemment (AND, OR, XOR et NOT) en Python. Le tableau suivant précise les caractères utilisés pour représenter chacun des opérateurs binaires considérés. Il est vrai qu'il est dommage que Python est récupéré ces caractères du langage C plutôt que d'utiliser des mots clés : c'est moins lisible, mais bon, c'est comme ça.

Opérateurs binaires AND OR XOR NOT
Opérateurs binaires Python & | ^ ~

Le programme suivant effectue quelques calculs grâce à ces opérateurs.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
>>> value1 = 0b10101010
>>> value2 = 0b00001111
>>> bin(value1 & value2)
'0b1010'
>>> bin(value1 | value2)
'0b10101111'
>>> bin(value1 ^ value2)
'0b10100101'
>>> bin(~value1)
'-0b10101011'
>>
Utilisation des opérateurs binaires Python

Les opérateurs de décalage de bits

Python vous propose deux autres opérateurs permettant de décaler les bits d'un certain nombre de rangs. L'opérateur << permet de décaler les bits vers la gauche, alors que l'opérateur >> permet un décalage vers la droite. Dans les deux cas, l'opérande de droite de l'opérateur correspond au nombre de rangs sur lesquels opérer le décalage. Voici un petit exemple montrant ces possibilités.

un opérande est en quelque sorte un paramètre de l'opérateur.
 1 
 2 
 3 
 4 
 5 
 6 
>>> value = 0b00010001      # 17 en décimal
>>> bin(value << 2)
'0b1000100'
>>> bin(value >> 2)
'0b100'
>>>
Utilisation des opérateurs de décalage de bits
n'oubliez pas qu'un décalage vers la gauche correspond à une multiplication par 2 et qu'un décalage vers la droite correspond à une division par 2. En conséquence, l'exemple ci-dessous multiplie 17 par 4 et divise 17 par 4 (division entière).

Les opérateurs d'affectation

Pour clore ce chapitre, notez que les opérateurs que nous venons d'étudier peuvent être combinés à une affectation. Ainsi l'expression a &= 0b1111 est équivalente à l'expression a = a & 0b1111. Il en va de même pour les autres opérateurs proposés. Voici la liste de toutes les combinaisons possibles avec un opérateur d'affectation.

Opérateur combiné Exemple d'utilisation Equivalence
&= a &= 0b1111 a = a & 0b1111
|= a |= 0b1111 a = a | 0b1111
^= a ^= 0b1111 a = a ^ 0b1111
<<= a <<= 0b1111 a = a << 0b1111
>>= a >>= 0b1111 a = a >> 0b1111

Voici un petit exemple d'utilisation de ces opérateurs.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
>>> value = 0b0001000100
>>> while value > 0:
...     value >>= 1
...     print(bin(value))
... 
0b100010
0b10001
0b1000
0b100
0b10
0b1
0b0
>>>
Utilisation des opérateurs combinés
Manipulation de valeurs entières Manipulation de valeurs flottantes