Opérateurs bit à bit Python

Les opérateurs binaires de Python sont utilisés pour effectuer des calculs binaires sur des entiers. Les entiers sont convertis en format binaire et ensuite des opérations sont effectuées bit par bit, d'où le nom d'opérateurs binaires. Les opérateurs binaires de Python ne fonctionnent que sur des entiers et la sortie finale est retournée au format décimal. Les opérateurs binaires de Python sont également appelés opérateurs binaires.

Opérateurs bit à bit Python

Il y a 6 opérateurs bit à bit en Python. Le tableau ci-dessous fournit des détails courts à leur sujet.

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

1. Opérateur ET bit à bit

L'opérateur binaire ET de Python renvoie 1 si les deux bits sont 1, sinon 0.

>>> 10&7
2
>>> 

2. Opérateur OU binaire

L'opérateur binaire ou en Python retourne 1 si l'un des bits est 1. Si les deux bits sont 0, il retourne 0.

>>> 10|7
15
>>> 

3. Opérateur XOR bit à bit

L'opérateur XOR bit à bit en Python 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 bit

Le complément à un de Python d'un nombre 'A' est égal à -(A+1).

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

5. Opérateur de décalage à gauche en binaire

L'opérateur de décalage à gauche binaire en 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 binaire

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

>>> 10 >> 2
2
>>>  

Surcharge des opérateurs bit à bit en Python

Python prend en charge la surcharge des opérateurs. Il existe différentes méthodes que nous pouvons mettre en œuvre pour prendre en charge les opérateurs bitwise pour nos objets personnalisés.

Voici un exemple de surcharge d'un 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înes, veuillez lire les f-strings en Python.

Résumé

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