Operadores Bitwise en Python

Los operadores bit a bit de Python se utilizan para realizar cálculos bit a bit en enteros. Los enteros se convierten en formato binario y luego se realizan operaciones bit a bit, de ahí el nombre de operadores bit a bit. Los operadores bit a bit de Python funcionan solo en enteros y la salida final se devuelve en formato decimal. También se les llama operadores binarios.

Operadores Bit a Bit de Python

Hay 6 operadores bit a bit en Python. La tabla a continuación proporciona detalles breves sobre ellos.

Veamos estos operadores uno por uno y comprendamos cómo funcionan.

1. Operador AND bit a bit

El operador bit a bit AND de Python devuelve 1 si ambos bits son 1, de lo contrario devuelve 0.

>>> 10&7
2
>>> 

2. Operador OR bit a bit

El operador bit a bit OR de Python devuelve 1 si alguno de los bits es 1. Si ambos bits son 0, entonces devuelve 0.

>>> 10|7
15
>>> 

3. Operador XOR a nivel de bits

El operador XOR a nivel de bits en Python devuelve 1 si uno de los bits es 0 y el otro bit es 1. Si ambos bits son 0 o 1, entonces devuelve 0.

>>> 10^7
13
>>> 

4. Operador de Complemento de unos a nivel de bits

El complemento de unos a nivel de bits en Python de un número ‘A’ es igual a -(A+1).

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

5. Operador de Desplazamiento a la Izquierda a Nivel de Bits

El operador de desplazamiento a la izquierda a nivel de bits en Python desplaza los bits del operando izquierdo hacia el lado izquierdo la cantidad de veces especificada en el operando derecho. En términos simples, se agregan 0s al final del número binario.

>>> 10 << 2
40
>>> 

6. Operador de Desplazamiento a la Derecha a Nivel de Bits

El operador de desplazamiento a la derecha en Python es exactamente lo opuesto al operador de desplazamiento a la izquierda. Luego, los bits del operando del lado izquierdo se mueven hacia el lado derecho la cantidad de veces especificada. En términos simples, los bits del lado derecho se eliminan.

>>> 10 >> 2
2
>>>  

Sobrecarga de operadores bit a bit en Python

Python admite la sobrecarga de operadores. Hay varios métodos que podemos implementar para admitir operadores bit a bit para nuestros objetos personalizados.

Aquí tienes un ejemplo de sobrecarga de operadores bit a bit para nuestro objeto personalizado.

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}')

Salida:

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 no estás familiarizado con el nuevo formato de cadena, por favor lee cadenas f en Python.

Resumen

Los operadores bit a bit en Python se utilizan principalmente en cálculos matemáticos. También podemos implementar métodos específicos para admitir operadores bit a bit en nuestras implementaciones de clases personalizadas.