Opérateurs de bits Python

Les opérateurs bit à bit Python sont utilisés pour effectuer des calculs bit à bit sur les entiers. Les entiers sont convertis en format binaire, puis les opérations sont effectuées bit par bit, d’où le nom d’opérateurs bit à bit. Les opérateurs bit à bit Python fonctionnent uniquement sur les entiers et la sortie finale est renvoyée au format décimal. Les opérateurs bit à bit Python sont également appelés opérateurs binaires.

Opérateurs bit à bit Python

Il existe 6 opérateurs bit à bit en Python. Le tableau ci-dessous fournit de brèves informations à leur sujet.

Examinons ces opérateurs un par un et comprenons comment ils fonctionnent.

1. Opérateur ET bit à bit

L’opérateur bit à bit et Python renvoie 1 si les deux bits sont à 1, sinon 0.

>>> 10&7
2
>>> 

2. Opérateur OU bit à bit

L’opérateur bit à bit ou Python renvoie 1 si l’un des bits est à 1. Si les deux bits sont à 0, alors il renvoie 0.

>>> 10|7
15
>>> 

3. Opérateur XOR bitwise

L’opérateur Python XOR bitwise retourne 1 si l’un des bits est 0 et que l’autre bit est 1. Si les deux bits sont 0 ou 1, alors il retourne 0.

>>> 10^7
13
>>> 

4. Opérateur de complément à un degré binaire

Le complément à un degré Python d’un nombre ‘A’ est égal à -(A+1).

>>> ~10
-11
>>> ~-10
9
>>> 

5. Opérateur de décalage à gauche de bits

L’opérateur de décalage à gauche de bits Python déplace les bits de l’opérande de gauche vers la gauche pour le nombre de fois donné dans l’opérande de droite. En termes simples, le nombre binaire est complété par des 0 à la fin.

>>> 10 << 2
40
>>> 

6. Opérateur de décalage à droite de bits

L’opérateur de décalage vers la droite en Python est exactement l’opposé de l’opérateur de décalage vers la gauche. Ensuite, les bits de l’opérande du côté gauche sont déplacés vers le côté droit pour le nombre donné de fois. En termes simples, les bits du côté droit sont supprimés.

>>> 10 >> 2
2
>>>  

Surcharge de l’opérateur Python Bitwise

Python prend en charge la surcharge des opérateurs. Il existe différentes méthodes que nous pouvons implémenter pour prendre en charge les opérateurs bit à bit pour nos objets personnalisés.

Voici un exemple de surcharge d’opérateur bit à bit pour notre objet personnalisé.

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __and__(self, other):
        print('Bitwise AND operator overloaded')
        if isinstance(other, Data):
            return Data(self.id & other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __or__(self, other):
        print('Bitwise OR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id | other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __xor__(self, other):
        print('Bitwise XOR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id ^ other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __lshift__(self, other):
        print('Bitwise Left Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id << other)
        else:
            raise ValueError('Argument must be integer')

    def __rshift__(self, other):
        print('Bitwise Right Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id >> other)
        else:
            raise ValueError('Argument must be integer')

    def __invert__(self):
        print('Bitwise Ones Complement operator overloaded')
        return Data(~self.id)

    def __str__(self):
        return f'Data[{self.id}]'


d1 = Data(10)
d2 = Data(7)

print(f'd1&d2 = {d1&d2}')
print(f'd1|d2 = {d1|d2}')
print(f'd1^d2 = {d1^d2}')
print(f'd1<<2 = {d1<<2}')
print(f'd1>>2 = {d1>>2}')
print(f'~d1 = {~d1}')

Sortie :

Bitwise AND operator overloaded
d1&d2 = Data[2]
Bitwise OR operator overloaded
d1|d2 = Data[15]
Bitwise XOR operator overloaded
d1^d2 = Data[13]
Bitwise Left Shift operator overloaded
d1<<2 = Data[40]
Bitwise Right Shift operator overloaded
d1>>2 = Data[2]
Bitwise Ones Complement operator overloaded
~d1 = Data[-11]

Si vous n’êtes pas familier avec le nouveau formatage de chaîne, veuillez lire les f-strings en Python.

Résumé

Les opérateurs bit à bit de Python sont principalement utilisés dans les calculs mathématiques. Nous pouvons également implémenter des méthodes spécifiques pour prendre en charge les opérateurs bit à bit pour nos implémentations de classe personnalisées.