Operações bit-a-bit - Python

Operações bit-a-bit são realizadas em cada bit dos números do tipo int. Para compreender a natureza das operações bit-a-bit, é necessário entender como os números são representados em binário.

Representação Binária dos Números

No sistema binário, cada bit de um número pode ter apenas dois valores: 0 e 1. Por exemplo, o número 0 no sistema decimal também é igual a 0 no sistema binário, e o número 1 no sistema decimal corresponde a 1 no sistema binário. O próximo número no sistema decimal, que é 2, no sistema binário é representado como 10. Ou seja, quando somamos 1 a 1, o resultado é 10, e assim por diante.

Por exemplo, o número 5 em representação binária é 101 e possui três bits. Para exibir um número decimal no sistema binário, pode-se usar o especificador 0b:

number = 5  # em binário: 101
print(f"number = {number:0b}")  # number = 101

Sem especificar o prefixo, a função print() exibe o número no sistema decimal.

Python também permite definir números diretamente em binário. Para isso, o número binário é indicado após o prefixo 0b:

number = 0b101  # define o número em binário
print(f"number = {number:0b}")  # number = 101
print(f"number = {number}")      # number = 5 - no sistema decimal

Operadores bit-a-bit Lógicos

As operações lógicas são realizadas em cada bit dos números. Em Python, existem os seguintes operadores bit-a-bit lógicos:

&E (AND) Lógico
A operação de "E" lógico é realizada bit-a-bit. Se ambos os bits dos operandos forem 1, o resultado é 1; caso contrário, o resultado é 0. Por exemplo:
```
x1 = 2  # 010
y1 = 5  # 101
z1 = x1 & y1
print(f"z1 = {z1}")   # z1 = 0

x2 = 4  # 100
y2 = 5  # 101
z2 = x2 & y2
print(f"z2 = {z2}")        # z2 = 4
print(f"z2 = {z2:0b}")     # z2 = 100
```
No primeiro caso, os números 2 e 5 em binário são 010 e 101, respectivamente. Realizando a operação bit-a-bit (0*1, 1*0, 0*1), obtemos 000.
No segundo caso, o número 4 em binário é 100 e o número 5 é 101. Realizando a operação bit-a-bit (1*1, 0*0, 0*1), obtemos 100.

| OU (OR) Lógico

A operação de OU lógico também é realizada bit-a-bit, mas retorna 1 se pelo menos um dos bits for 1. Por exemplo:

x1 = 2       # 010
y1 = 5       # 101
z1 = x1 | y1 # 111
print(f"z1 = {z1}")        # z1 = 7
print(f"z1 = {z1:0b}")     # z1 = 111

x2 = 4       # 100
y2 = 5       # 101
z2 = x2 | y2 # 101

print(f"z2 = {z2}")        # z2 = 5
print(f"z2 = {z2:0b}")     # z2 = 101

^ OU(XOR) Exclusivo Lógico
A operação de OU exclusivo lógico retorna 1 se os bits dos operandos forem diferentes, caso contrário, retorna 0. Também conhecida como XOR. Por exemplo:
```
x = 9       # 1001
y = 5       # 0101
z = x ^ y   # 1100
print(f"z = {z}")        # z = 12
print(f"z = {z:0b}")     # z = 1100
```
Neste caso, os números 9 e 5 em binário são 1001 e 0101, respectivamente. Realizando a operação bit-a-bit (1*0, 0*1, 0*0, 1*1), obtemos 1100.
Frequentemente, essa operação é utilizada para criptografia simples:
```
x = 45       # Número a ser criptografado - binário: 101101
key = 102    # Chave - binário: 1100110

encrypt = x ^ key    # Resultado: 1001011 ou 75
print(f"Número criptografado: {encrypt}")

decrypt = encrypt ^ key    # Resultado: número original 45
print(f"Número descriptografado: {decrypt}")
```
Também é possível usar essa operação para trocar os valores de duas variáveis sem uma variável temporária:
```
x = 9       # 1001
y = 5       # 0101
x = x ^ y
y = x ^ y
x = x ^ y

print(f"x = {x}")  # x = 5
print(f"y = {y}")  # y = 9
```
~ (NOT) Inversão
A operação de inversão bit-a-bit inverte todos os bits do número. A expressão ~x é equivalente a -(x + 1). Por exemplo:
```
x = 5
y = ~x
print(f"y: {y}")  # -6
```

Operações de Deslocamento

As operações de deslocamento também são realizadas bit-a-bit e podem ser para a direita ou para a esquerda.

x << y desloca o número x para a esquerda por y bits. Por exemplo, 4 << 1 desloca o número 4 (100 em binário) uma posição para a esquerda, resultando em 1000, que é 8 no sistema decimal.
x >> y desloca o número x para a direita por y bits. Por exemplo, 16 >> 1 desloca o número 16 (10000 em binário) uma posição para a direita, resultando em 1000, que é 8 no sistema decimal.

Assim, se o número a ser deslocado é divisível por dois, o deslocamento à esquerda ou à direita equivale a multiplicação ou divisão por potências de dois. Por exemplo:


a = 16       
b = 2
c = a << b # 16 * 2^2 = 64
print(c)  # 64

d = c >> b # 64 / 2^2 = 16
print(d)  # 16.


x = 8
y = 3
z = x >> y # 8 / 2^3 = 1
print(z)  # 1

Outro exemplo:

a = 21 # 10101
b = 2 

c = a >> b # 21 / 2^2 = 5
print(c)  # 5