XOR em Python

XOR, ou OR exclusivo, compara dois valores e resulta em verdadeiro quando exatamente um deles é verdadeiro. Em Python, o operador circunflexo (^) executa XOR com inteiros e booleanos. Use-o quando precisar de um valor ou do outro, mas não de ambos, ou quando precisar comparar bits diretamente.

O que é XOR?

XOR compara dois bits e retorna 1 quando eles são diferentes e 0 quando são iguais:

• 0 XOR 0 = 0
• 0 XOR 1 = 1
• 1 XOR 0 = 1
• 1 XOR 1 = 0

A mesma regra se aplica a valores booleanos: exatamente um valor True produz True. Para inteiros, Python aplica essa regra independentemente a cada par de bits. Por isso, XOR booleano e XOR bit a bit estão relacionados, mas servem a finalidades diferentes.

Usando XOR com Inteiros

Use o operador circunflexo (^) para calcular o XOR bit a bit entre dois inteiros:

a = 5  # Binary: 0101
b = 3  # Binary: 0011

result = a ^ b
print(result)

6

A representação binária de 5 é 0101, e a de 3 é 0011. Comparar os bits correspondentes resulta em:

• 0 XOR 0 = 0
• 1 XOR 0 = 1
• 0 XOR 1 = 1
• 1 XOR 1 = 0

O resultado é 0110, ou 6 em decimal. O zero à esquerda serve apenas para alinhar os operandos; ele não altera o valor.

Usando XOR com Booleanos

Python também aplica ^ a valores booleanos. O programa a seguir mostra as quatro combinações de entrada e uma implementação orientada a booleanos, construída com and, or e not:

def xor(left, right):
    return (left and not right) or (not left and right)

for left, right in ((False, False), (False, True), (True, False), (True, True)):
    print(f"{left} ^ {right} -> {left ^ right}; xor() -> {xor(left, right)}")

False ^ False -> False; xor() -> False
False ^ True -> True; xor() -> True
True ^ False -> True; xor() -> True
True ^ True -> False; xor() -> False

A função é útil quando uma expressão booleana precisa de uma operação nomeada. Para entradas booleanas, left ^ right e xor(left, right) produzem os mesmos quatro resultados. A forma lógica destina-se a condições booleanas; use ^ para manipular bits de inteiros.

Aplicações práticas do XOR

O módulo operator expõe a mesma operação que a função xor(). Isso é conveniente quando você precisa de um objeto de função e funciona tanto com operandos booleanos quanto com inteiros:

from operator import xor

print(xor(True, False))
print(xor(5, 3))

True
6

Outra técnica conhecida de manipulação bit a bit permite trocar duas variáveis inteiras sem usar uma variável temporária:

x = 10
y = 20

x = x ^ y
y = x ^ y
x = x ^ y

print(x, y)

20 10

Começando com dois inteiros, as três operações funcionam assim:

1. x torna-se o XOR de x e y.
2. Em seguida, y recebe o valor original de x ao aplicar XOR ao novo x e a y.
3. Por fim, x é atualizado para o valor original de y usando a mesma lógica.

A técnica funciona com variáveis inteiras, mas o código Python comum costuma ser mais claro com o desempacotamento de tupla: x, y = y, x. A forma com XOR é principalmente útil para entender operações bit a bit ou quando se trabalha sob uma restrição que exige especificamente essa técnica.

Conclusão

Em Python, use ^ para XOR: ele compara valores booleanos diretamente e compara cada bit quando os operandos são inteiros. A função operator.xor() oferece a mesma operação em forma de função, enquanto and, or e not podem expressar explicitamente a regra booleana. Escolha a forma que comunica melhor se a tarefa é lógica ou envolve operações bit a bit.

FAQ

1. O que XOR significa em Python?
   XOR significa OR exclusivo: produz verdadeiro quando exatamente uma de duas entradas é verdadeira. Para operandos inteiros, aplica essa regra a cada bit correspondente.

2. Como realizo uma operação XOR em dois inteiros em Python?
   Use o operador circunflexo: result = a ^ b.

3. Posso usar XOR com valores booleanos em Python?
   Sim. True ^ False e False ^ True resultam em True, enquanto entradas booleanas iguais resultam em False.

4. Qual é uma aplicação prática de XOR na programação?
   XOR pode trocar duas variáveis inteiras por meio de três operações bit a bit. No código Python comum, o desempacotamento de tupla costuma ser mais claro.

5. XOR é comutativo em Python?
   Sim. XOR é comutativo, portanto a ^ b é igual a b ^ a para operandos compatíveis.