[ PYTHON ] - Bitwise (Champs de bits)

Nous allons parler dans ce post des opérations sur les bits ou champs de bits
Cet article est tiré d'un chapitre de mon livre, présenté plus bas.


5.2 Les opérateurs : and / or / xor / not

Dans ce chapitre nous allons faire des opérations sur les bits et pour cela il faut des notions en binaire. Les opérations sur les bits se font grâce aux opérateurs : &, |, ^, ~,

Respectivement : and (et), or (ou), xor (ou exclusif) et not (non).
Il y a aussi les opérateurs de décalage mais nous les verrons plus bas.
En binaire pour savoir comment fonctionne un opérateur il faut regarder sa table de vérité.



5.2.1 and (et)

Nous commençons avec l’opérateur & (and), regardons sans tarder sa table de vérité :

La table nous dit que quand on utilise l’opérateur sur deux valeurs 1 elle renvoie 1 sinon dans tous les autre cas, elle renvoie 0.

Faisons un essai :

Regardez, j’ai aligné à droite leur valeur binaire pour que vous compreniez que les bits se comparent un à un (Comme les additions sur papier à l’école).

Sur l’opération : 5 & 20 ce qui nous donne en binaire :

00000101 et

00010100

On constate que le premier bit (on part de la droite en binaire) de n1 est 1 et celui de n2 est 0 donc le résultat donnera 0, pour le deuxième ils sont tous les deux à zéro, ça donnera zéro aussi. Pour le troisième ils sont tous les deux à 1 donc il sera à 1 dans le résultat. Et pour les suivants ils donneront tous zéros.

00000101 et

00010100

00000100

Ce qui nous donne 4.

Regardez ce code :

Je crée une liste de 256 valeurs allant de 0 à 255 : toutes les valeurs possibles pour 8 bits, que je stocke dans une liste.
Ne soyez pas perturbé par la ligne 28 qui ne sert à rien dans le cas présent mais je m’en suis servi pour d’autres exemples (quoi qu’il en soit j’utiliserai la liste x dans cet exemple.

Je crée une boucle sur toute la liste qui va appliquer l’opérateur sur toutes les valeurs de la liste avec la valeur suivante exemple :

1&2, puis 2&3, puis 3&4, jusqu’à la fin de la liste.

Pourquoi avoir mis des ‘formats’ dans les prints ? C’est simple, je voulais que les résultats s’affichent en binaire et pas sous forme d’entiers.

La dernière instruction print est juste pour afficher des lignes d’étoiles entre chaque rapport.

Voici le résultat :

Mais vous allez me dire qu’au début de la liste ça ne sert pas à grand chose vu que si les deux raports n’on pas le même nombre d’unité et qu’ils ne sont pas alignés il n’y a aucun intérêt.
Donc améliorons le code :

Je crée une fonction à la ligne 31 qui va récupérer le nombre, y appliquer le format binaire comme plus haut, mais qui va ensuite le convertir en chaine de caractères pour pouvoir lui appliquer la méthode zfill, qui est une méthode de remplissage de caractères. Et je lui donne 8 en argument.

Dans la boucle il ne me reste plus qu’a envoyer l’élément à la fonction et à l’afficher dans un print et le tour est joué. (J’aurais pu faire le print dans la fonction, d’ailleurs ça aurait été mieux).

Regardons maintenant le résultat :

Maintenant il est beaucoup plus simple de comprendre les opérations.

5.2.2 or (ou)

Passons à l’opérateur : | or (ou) son symbole se fait avec alt Gr + 6 sur clavier azerty. Regardons sa table de vérité : 

S’il y a un 1 sur un des deux côté elle renvoie 1 sinon elle renvoie 0. Plutôt simple, essayons :

Avec les mêmes valeurs que plus haut : 5, 20 donc :
5 | 20 = 21 :

00000101 ou

00010100

00010101

Ce qui donne 21.
Reprenons notre boucle utilisée plus haut mais cette fois pour l’opérateur ‘ou’ :

Comme vous pouvez le constater je l’ai légèrement modifiée puisque maintenant, je fais le print directement dans la fonction, ce qui fait beaucoup plus propre et plus pro aussi.
Voyons ce que ça donne :

5.2.3 xor (ou exclusif) :

Passons à l’opérateur ^ou exclusif (xor). Voici sa table de vérité :

Il ne renvoie 1 que si seulement un des deux et à 1, autrement il renvoie 0.

Essayons :

Toujours avec les valeurs 5, 20, donc :
5^20 = 17.

00000101 ou exclusif

00010100

00010001

Ce qui donne 17.
Voyons notre boucle : 

Jusque là, la seule chose qui a changé c’est le signe.
Affichons le résultat, du moins une partie (voir capture suivante) :

5.2.4 not (non)


Pour l’opérateur : ~ non (not) le signe tilde, je n’afficherai pas sa table de vérité puisque c’est la plus simple. Ce n’est pas une opération qui se fait avec deux valeurs, mais une seule et elle se contente d’inverser la valeur des bits. Les 0 deviennent 1 et les 1 deviennent des 0.

5.3 Les opérateurs de décalages

Dans cette partie nous allons parler des opérateurs de décalages à gauche et les opérateurs de décalages à droite. Ils se composent avec les signes :


<< (décalage à gauche) et

>> (décalage à droite).


Mais à quoi servent-ils ?
Ils servent à décaler les bits d’un nombre d’unités spécifié vers la gauche ou vers la droite.

5.3.1 Décalage à gauche

Commençons par l’opérateur de décalage à gauche. Gardons les valeurs utilisées plus haut, en particulier : 5 :

En faisant : 5<<2, je demande à ce que tous les bits de 5 soient décalés de 2 unités vers la gauche.
C’est comme si j’avais fait :

00000101 << 2

00010100

Donc : 20.

Pour les plus attentifs, vous remarquerez qu’en binaire un décalage vers la gauche d’une unité revient à doubler la valeur, de deux unités la valeur sera multiplié par 4 etc...


5.3.2 Décalage à droite

C’est exactement le même principe pour le décalage à droite sauf qu’au lieu de multiplier la valeur par deux à chaque unité décalée, ça la divise.

Prenons 10 en binaire et décalons-le de 1 vers la droite. Regardez :

00001010>>1

00000101

Résultat : 5.

Mais attention prenons 5 et décalons-le une nouvelle fois de 1 vers la droite :

00000101>>1

00000010

Résultat 2.

Comment est-ce possible ? Tout simplement parce que le bit 1 qui était tout à droite à disparu.
Quand vous décalez de 1 vers la droite, le premier bit (vers la droite) disparaît. Tout comme quand vous décalez de 2 vers la droite, les deux premiers (vers la droite) disparaissent etc…

Tout comme pour le décalage à gauche si la valeur dépasse 256, des bits seront ajoutés et la valeur ne sera plus codé sur 8 bits mais sur le nombre de bits nécessaires pour la représenter en binaire. 

 

Voila j'espère que cet article vous a plu. Vous pouvez poser vos questions en commentaires.
Merci à ceux qui partagent mes articles, c'est ce qui permet de faire vivre le blog.

Et pour ceux qui veulent en savoir plus, voici le lien pour acquérir le livre :