Python Bitwise AND Assignment

The &= operator is the in-place bitwise AND assignment operator. It evaluates the bitwise AND operation between the left and right operands, and subsequently assigns the resulting value back to the left operand’s reference.

Syntax

x &= y

Logically, this is evaluated as:

x = x & y

Type-Specific Behavior

The behavior of the &= operator depends on the data types of the operands:

1. Integers (Bitwise AND)

When applied to integers, &= performs a bit-by-bit comparison of the binary representations of the operands. A bit in the resulting integer is set to 1 if and only if the corresponding bits in both operands are 1. Otherwise, the bit is set to 0.

x = 12      # Binary: 1100
x &= 10     # Binary: 1010
print(x)    # Output: 8 (Binary: 1000)

2. Sets (Intersection Update)

When applied to sets, &= performs an in-place intersection. It mutates the left operand, retaining only the elements that are present in both the left and right sets.

s = {1, 2, 3, 4}
s &= {3, 4, 5, 6}
print(s)    # Output: {3, 4}

Underlying Data Model (Dunder Methods)

When the Python interpreter encounters x &= y, it attempts to invoke the augmented assignment magic method __iand__ on the left operand:

x = x.__iand__(y)

Mutable Types (e.g., Sets): If __iand__ is implemented, the operation modifies the object in memory and returns self. The variable x remains bound to the exact same memory address.
Immutable Types (e.g., Integers): Integers do not implement __iand__ because they cannot be mutated. Python automatically falls back to the standard bitwise AND method __and__. It evaluates x.__and__(y), creates a completely new integer object in memory with the result, and rebinds the variable x to this new object.