Operadores Bitwise em Python

Os operadores bit a bit em Python são utilizados para realizar cálculos bit a bit em números inteiros. Os inteiros são convertidos para o formato binário e as operações são realizadas bit a bit, daí o nome operadores bit a bit. Os operadores bit a bit em Python funcionam apenas em números inteiros, e a saída final é retornada no formato decimal. Os operadores bit a bit em Python também são chamados de operadores binários.

Operadores Bit a Bit em Python

Há 6 operadores bit a bit em Python. A tabela abaixo fornece detalhes breves sobre eles.

Vamos analisar esses operadores um por um e entender como eles funcionam.

1. Operador E Bit a Bit

O operador bit a bit “E” em Python retorna 1 se ambos os bits forem 1; caso contrário, retorna 0.

>>> 10&7
2
>>> 

2. Operador OU Bit a Bit

O operador bit a bit “OU” em Python retorna 1 se qualquer um dos bits for 1. Se ambos os bits forem 0, retorna 0.

>>> 10|7
15
>>> 

3. Operador XOR Bitwise

O operador XOR bitwise em Python retorna 1 se um dos bits for 0 e o outro bit for 1. Se ambos os bits forem 0 ou 1, então retorna 0.

>>> 10^7
13
>>> 

4. Operador de Complemento de Uns Bitwise

O complemento de uns bitwise em Python de um número ‘A’ é igual a -(A+1).

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

5. Operador de Deslocamento para a Esquerda Bitwise

O operador de deslocamento para a esquerda bitwise em Python desloca os bits do operando esquerdo para o lado esquerdo pelo número de vezes dado no operando direito. Em termos simples, o número binário é acrescentado com 0s no final.

>>> 10 << 2
40
>>> 

6. Operador de Deslocamento para a Direita Bitwise

O operador de deslocamento à direita do Python é exatamente o oposto do operador de deslocamento à esquerda. Em seguida, os bits do operando do lado esquerdo são movidos para o lado direito pelo número dado de vezes. Em termos simples, os bits do lado direito são removidos.

>>> 10 >> 2
2
>>>  

Sobrecarga de Operador Bit a Bit em Python

O Python suporta sobrecarga de operador. Existem vários métodos que podemos implementar para suportar operadores bit a bit para nossos objetos personalizados.

Aqui está um exemplo de sobrecarga de operador bit a bit para nosso 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}')

Resultado:

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]

Se você não está familiarizado com a nova formatação de string, por favor, leia f-strings em Python.

Resumo

Os operadores bit a bit do Python são principalmente usados em cálculos matemáticos. Também podemos implementar métodos específicos para suportar operadores bit a bit para nossas implementações de classe personalizadas.