> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# 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
```python theme={"dark"}
x &= y
```
Logically, this is evaluated as:
```python theme={"dark"}
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`.
```python theme={"dark"}
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.
```python theme={"dark"}
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:
```python theme={"dark"}
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.
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
