Mastering Python Bitwise Operators: A Comprehensive Guide with Examples

Python bitwise operators stand out as powerful tools for working with individual bits of integer values. Bitwise operators allow for efficient manipulation and analysis of binary data, making them particularly useful in scenarios like data encoding, cryptography, and low-level system programming. In this article, we will delve into Python’s bitwise operators, explaining their functionality and providing illustrative examples.

Table of Contents

1. Understanding Bitwise Operators.

Bitwise operators perform operations at the bit level, treating the operands as sequences of bits rather than traditional integer or floating-point values.

Python provides six main bitwise operators:
Bitwise AND (`&`): Sets each bit to 1 if both corresponding bits of the operands are 1.
Bitwise OR (`|`): Sets each bit to 1 if either corresponding bit of the operands is 1.

Bitwise XOR (`^`): Sets each bit to 1 if exactly one corresponding bit of the operands is 1.
Bitwise NOT (`~`): Flips the bits, changing 1s to 0s and vice versa.
Left Shift (`<<`): Shifts the bits of the left operand to the left by the number of positions specified by the right operand.

Right Shift (`>>`): Shifts the bits of the left operand to the right by the number of positions specified by the right operand.

2. Bitwise AND (`&`) Operator.

The bitwise AND operator compares each bit of the operands and returns a new integer with bits set to 1 only where both operands have corresponding bits set to 1.

def bitwise_and():
    a = 5    # 101
    b = 3    # 011
    result = a & b
    # result is 1 (001)
    print('result =', result)

if __name__ == "__main__":

    bitwise_and()

The above example code output.
```
result = 1
```

3. Bitwise OR (`|`) Operator.

The bitwise OR operator compares each bit of the operands and returns a new integer with bits set to 1 where either or both operands have corresponding bits set to 1.

def bitwise_or():
    a = 5    # 101
    b = 3    # 011
    result = a | b
    # result is 7 (111)
    print('result =', result)

if __name__ == "__main__":

    bitwise_or()

Above code output.
```
result = 7
```

4. Bitwise XOR (`^`) Operator.

The bitwise XOR operator compares each bit of the operands and returns a new integer with bits set to 1 where exactly one of the operands has the corresponding bit set to 1 ( 0⊕0=0, 0⊕1=1, 1⊕0=1, 1⊕1=0).
```
def bitwise_xor():
    a = 5    # 101
    b = 3    # 011
    result = a ^ b
    # result is 6 (110)
    print('result =', result)

if __name__ == "__main__":

    bitwise_xor()
```

Above code output.
```
result = 6
```

5. Bitwise NOT (`~`) Operator.

The bitwise NOT operator flips the bits of the operand, changing 1s to 0s and vice versa. It operates on a single operand.

def bitwise_not():
    a = 10
    print('a =', a)
    print('bin(a) =', bin(a))
    result = ~a
    print('result =', result)
    print('bin(result) =', bin(result))

    print('\n')

    b = -9
    print('b =', b)
    print('bin(b) =', bin(b))
    result = ~b
    print('result =', result)
    print('bin(result) =', bin(result))


if __name__ == "__main__":

    bitwise_not()

Above Python source code execution output.

a = 10
bin(a) = 0b1010
result = -11
bin(result) = -0b1011

b = -9
bin(b) = -0b1001
result = 8
bin(result) = 0b1000

In the above example, we can see that the NOT(‘~’) operator adds one to the value of the operand and then changes the sign accordingly.

6. Left Shift (`<<`) Operator.

The left shift operator shifts the bits of the left operand to the left by a number of positions specified by the right operand.

This is equivalent to multiplying the left operand by 2 raised to the power of the right operand.

def bitwise_left_shift():
    a = 5     # 101
    shifted = a << 2
    # shifted is 20 (10100)
    print('a =',a)
    print('bin(a) =',bin(a))
    print('')
    print('shifted =',shifted)
    print('bin(shifted) =',bin(shifted))

if __name__ == "__main__":

    bitwise_left_shift()

Above example code execution result.

a = 5
bin(a) = 0b101

shifted = 20
bin(shifted) = 0b10100

7. Right Shift (`>>`) Operator.

The right shift operator shifts the bits of the left operand to the right by a number of positions specified by the right operand.

This is equivalent to the integer division of the left operand by 2 raised to the power of the right operand.

def bitwise_right_shift():
    a = 99
    shifted = a >> 3
    print('a =',a)
    print('bin(a) =',bin(a))
    print('')
    print('shifted =',shifted)
    print('bin(shifted) =',bin(shifted))    

if __name__ == "__main__":

    bitwise_right_shift()