Python Bitwise XOR

The ^ operator in Python is the Exclusive OR (XOR) operator. It performs bitwise XOR on integers, logical XOR on booleans, and symmetric difference on sets.

result = operand_a ^ operand_b

Boolean Evaluation (Logical XOR)

The bool type explicitly overloads the ^ operator to return a bool. While it functions as a logical XOR for boolean values, it remains fundamentally a bitwise operator. This introduces critical differences in behavior compared to true logical operators (and, or):

Operator Precedence: The ^ operator has higher precedence than comparison operators (==, >, <, etc.). An expression like a == b ^ c == d evaluates as a == (b ^ c) == d. Parentheses are strictly required to evaluate the comparisons first.
No Short-Circuiting: Unlike and and or, the ^ operator evaluates both operands unconditionally.
No Implicit Coercion: The ^ operator does not implicitly coerce truthy or falsy values to booleans. Attempting to use ^ on unsupported types (e.g., "a" ^ "b") raises a TypeError.

Because of these bitwise characteristics, using the inequality operator on explicitly cast booleans (bool(a) != bool(b)) is generally the preferred, safer idiom for logical XOR in Python.

# Standard boolean XOR
a = True ^ False  # Returns True
b = True ^ True   # Returns False


# Precedence requires explicit parentheses for comparisons
c = (10 > 5) ^ (5 > 10)  # Returns True


# Preferred logical XOR idiom for arbitrary objects
d = bool("a") != bool("")  # Returns True

Integer Bitwise Mechanics

When applied to integers, the operator acts directly on the internal binary representation of the values. It aligns the bits by their least significant bit and applies the XOR logic to each column according to standard bitwise rules: it yields 1 if the bits are different, and 0 if they are identical.

a = 10  # Internal binary: ...00001010
b = 6   # Internal binary: ...00000110

result = a ^ b 

# Execution trace:

#   ...00001010  (10)

# ^ ...00000110  (6)

# ----------

#   ...00001100  (12)

print(result)  # Output: 12

Negative Numbers and Arbitrary Precision Python integers feature arbitrary precision. For bitwise operations, Python conceptually treats negative numbers as having an infinite string of leading 1 bits, utilizing a two’s complement representation. The ^ operator evaluates these infinite leading bits during execution.

c = -10 # Conceptually: ...11110110
d = 6   # Conceptually: ...00000110

result = c ^ d

# Execution trace:

#   ...11110110  (-10)

# ^ ...00000110  (6)

# ----------

#   ...11110000  (-16)

print(result)  # Output: -16

Set Symmetric Difference

For set and frozenset objects, Python overloads the ^ operator to compute the symmetric difference. It returns a new set containing elements present in either of the operands, but not in their intersection.

set_a = {1, 2, 3}
set_b = {3, 4, 5}

result = set_a ^ set_b
print(result)  # Output: {1, 2, 4, 5}

Underlying Data Model (Magic Methods)

The behavior of the ^ operator is governed by Python’s data model. Custom classes can define or override how the ^ operator interacts with their instances by implementing the following dunder (magic) methods:

__xor__(self, other): Handles the standard self ^ other operation.
__rxor__(self, other): Handles reflected (right-side) operations (other ^ self), invoked if the left operand does not support the operation.
__ixor__(self, other): Handles the augmented assignment operation ^=, modifying the object in place if supported.

class BitString:
    def __init__(self, value):
        self.value = value
        
    def __xor__(self, other):
        # Custom implementation mapping to the ^ operator
        return bin(int(self.value, 2) ^ int(other.value, 2))[2:]

bin1 = BitString("1010")
bin2 = BitString("0110")


# Invokes bin1.__xor__(bin2)
result = bin1 ^ bin2  
print(result)  # Output: 1100