## Bitwise Operators In Python

## What are Bitwise Operators?

Bitwise operators are used for operating on operands treating them as a string of bits. Hence, the name bitwise – stands for bit-by-bit operation. The returned output is in decimal format.

- Bitwise Logical Operators:
**AND**,**OR**,**XOR**, and**NOT**. - Bitwise Shift Operators:
**Left Shift**and**Right Shift**.

Now, let’s discuss each bitwise operator in detail:

## Bitwise Logical Operators

### 1. AND Operator

The bitwise AND operator, represented by the **&** sign, performs logical conjunction on the corresponding bits of its operands.

It returns 1 if the bits at the same position in both numbers (operands) are also 1, else returns 0. Arithmetically, this is equivalent to the **intersection** of the bit values:

Where ‘*i*’ represents the index (position) of the bits.

Let us consider the following truth table to understand this:

Let’s understand with an example in Python:

**Example:**

#bitwise AND num1 = 9 num2 = 13 print(num1 & num2) Copy code

**Output:**

9 Copy code

In the above code, we used the **&** operator between the operands **num1** and **num2**. The operator performs the following function behind the scenes:

num1 = 9 -> binary representation of 9 = 1001 num2 = 13 -> binary representation of 13 = 1101 num1 & num2 = 1001 & 1101 = 1001 = 9 Copy code

### 2. OR Operator

The bitwise OR operator, represented by the **|** sign, performs logical disjunction on the corresponding bits of its operands.

It returns 1 if either of the bits at the same position in both numbers (operands) is 1, else returns 0. Arithmetically, this is equivalent to the **union** of the bit values:

Where ‘*i*’ represents the index (position) of the bits.

This can be better understood through the following truth table:

Let’s understand with an example in Python –

**Example:**

#bitwise OR num1 = 12 num2 = 6 print(num1 | num2) Copy code

**Output:**

14 Copy code

In the above code, we used the **|** operator between the operands **num1** and **num2**. The operator performs the following function behind the scenes:

num1 = 12 -> binary representation of 12 = 1100 num2 = 6 -> binary representation of 6 = 0110 num1 | num2 = 1100 | 0110 = 1110 = 14 Copy code

### 3. XOR Operator

The bitwise XOR operator stands for “exclusive or” and performs exclusive disjunction on the corresponding bits of its operands.

This operator evaluates two mutually exclusive conditions and checks if exactly one of them is met – it returns 1 if one of the bits is 0 and the other is 1. If both the corresponding bits are either 0 or 1, it returns 0.

Arithmetically, this is represented as:

Where ‘*i*’ represents the index (position) of the bits.

**Note:** In Python, *modulo is represented by the % sign. Here, it performs a *division between the dividend (A*i* + B*i) *and the divisor 2 and returns the remainder.

The XOR operation can be better understood through the following truth table:

Let’s understand with an example in Python –

**Example:**

#bitwise XOR num1 = 3 num2 = 10 print(num1 ^ num2) Copy code

**Output:**

9 Copy code

In the above code, we used the **^** operator between the operands **num1** and **num2**. The operator performs the following function behind the scenes:

num1 = 3 -> binary representation of 3 = 0011 num2 = 10 -> binary representation of 10 = 1010 num1 ^ num2 = 0011 ^ 1010 = 1110 = 14 Copy code

### 4. NOT Operator

The bitwise NOT operator, represented by the**~ **sign, performs logical negation on the operand by inverting all of its bits.

It works with a single operand and returns its *one’s complement*. – converting 1 to 0 and vice-versa. Arithmetically, this is equivalent to the **subtraction** of the corresponding bit values from one:

Where ‘*i*’ represents the index (position) of the bits.

This can be better understood through the following truth table:

Let’s understand with an example in Python –

**Example:**

#bitwise NOT num = 342 print(~num) Copy code

**Output:**

-343 Copy code

In the above code, we used the **~ **operator with the operand **num**. The operator performs the following function behind the scenes:

num = 342 -> binary representation of 342 = 101010110 ~num = ~101010110 = -( 1 + 010101001) = -(101010111) = -343 Copy code

## Bitwise Shift Operators

### 1. Left Shift Operator

The bitwise left shift operator, represented by the **<< **sign, shifts the bits of its first operand to the left by the number of places specified in its second operand. The operator also takes care of the gap that arises on the right edge of the new bit pattern by substituting 0s in place of the gap(s). The sign bits are not affected by the left shift operator.

When a bit shifts to the left by one place, its value doubles. Similarly, shifting a bit by two places to the left would quadruple its value. So, when you will add up all the bits in a given number, you’ll notice that the number gets doubled with every place shifted.

Let’s understand with the following examples in Python –

**Example 1:**

#bitwise left shift num = 13 print(num << 1) print(num << 3) Copy code

**Output 1:**

26 104 Copy code

In the above code, we used the **<<** operator first with operands **num **and** 1**, and then again with operands **num **and** 3**. The operator performs the following function behind the scenes:

num = 13 -> binary representation of 13 = 00001101 num << 1 #the bits shift left to 1 place -> 00011010 = 26 num << 3 #the bits shift left to 3 places -> 01101000 = 104 Copy cod

**Example 2:**

#bitwise left shift num = -45 print(num << 2) Copy code

**Output 2:**

-180 Copy code

In the above code, we used the **<<** operator first with operands **num **and** 2**. The operator performs the following function behind the scenes:

num = -45 -> binary representation of -45 = 10101101 num << 2 #the bits shift left to 2 places -> 10110100 = -180 Copy code

In signed binary representation, the left-most bit is considered to be the **sign bit** –

- If the left-most bit is 0, it is a positive number.
- If the left-most bit is 1, it is a negative number.

Since in example 2, the left-most bit is 1, we add the ‘-’ sign to the number to make it negative.

### 2. Right Shift Operator

The bitwise right shift operator, represented by the **>>** sign, shifts the bits of its first operand to the right by the number of places specified in its second operand. The operator also takes care of the gap that arises on the left edge of the new bit pattern by substituting 0s in the case of a positive number and 1s if the number is negative.

When a bit shifts to the right by one place, its value has the same effect as if the number is multiplied by some power of 2.

Let’s understand with an example in Python –

**Example 1:**

#bitwise right shift num = 120 print(num >> 1) print(num >> 3) Copy code

**Output 1:**

60 15 Copy code

In the above code, we used the **>>** operator first with operands **num **and** 1**, and then again with operands **num **and** 3**. The operator performs the following function behind the scenes:

num = 120 -> binary representation of 120 = 01111000 num >> 1 #the bits shift right to 1 place -> 00111100 = 60 num >> 3 #the bits shift right to 3 places -> 00001111 = 15 Copy cod

**Example 2:**

#bitwise right shift num = -10 print(num >> 2) Copy code

**Output 2:**

-3 Copy code

In the above code, we used the **>> **operator first with operands **num **and** 2**. The operator performs the following function behind the scenes:

num = -10 -> binary representation of -10 = 11110101 num >> 2 #the bits shift right to 2 places -> 11111101 = -3 Copy cod

### Bitwise Operator Overloading

Python supports operator overloading. Let’s understand this concept below:

Generally, we use the **‘+’** operator to *add* two operands. In Python, we can use it to perform the addition operation but apart from that, we can also use the **‘+’** operator to join two Python strings or merge two Python lists.

This extended functionality of an operator beyond its operational meaning is known as operator overloading. Consider the following example:

a = 'Star' b = 'bucks' print(a + b) Copy code

**Output:**

Starbucks Copy code

In the above code, we used the **+** operator to concatenate two strings.

The bitwise operator overloading consists of three different operators:

**Built-in Data Types****Third-party Modules****Custom Data Types**

Let’s look at each of them in detail:

## Built-in Data Types

From Python 3.9, the bitwise operators are defined for the following built-in data types:

- int
- bool
- set and frozenset
- dict

The bitwise operators in Python for the above data types can perform operations from set algebra, (such as union, intersection, and symmetric difference), as well as merge and update the dictionaries.

Consider **a** and **b** are Python sets, then the bitwise operators correspond to the following methods:

Set Method | Bitwise Operator Representation |

a.union(b) | a | b |

a.intersection(b) | a & b |

a.update(b) | a | = b |

a.symmetric_difference(b) | a ^ b |

a.symmetric_difference_update(b) | a ^ = b |

a.intersection_update(b) | a & = b |

Consider the following example of two container **sets** with different colored balls:

box1 = {'blue', 'green', 'white'} box2 = {'blue', 'red', 'yellow'} print("Union: ", box1 | box2) print("Intersection: ", box1 & box1) print("Symmetric difference: ", box1 ^ box2) print("Difference: ", box1 - box2) Copy c

**Output:**

Union: {''red', 'white, ‘blue’, ‘green’, ‘yellow’} Intersection: {‘green’, 'white’, ‘blue’} symmetric difference: {'white’, ‘red’, ‘green’, ‘yellow’} Difference: {'green', ‘white’} Copy code

## Third-part Modules

Many popular Python modules, including **NumPy** and **Pandas**, overload the bitwise operators for their specific data type.

For example, NumPy applies the operators to vectorized data in a pointwise fashion, as shown below:

import numpy as np arr = np. array([2, 4, 6, 8]) print(arr << 2) print(arr << 3) Copy code

**Output:**

As you can see from the code above, we do not need to apply the **<<** operator separately to each element of the NumPy array. This functionality can also be applied to basic Python lists.

## Custom Data Types

The custom data types can redefine the behavior of the Python bitwise operators where we first define a class, and then implement special methods, called *magic methods*, inside it.

This type of operator overloading is possible only on the newer data types. We cannot customize the behavior of the bitwise operators for existing data types.

Consider the following example:

a = 6 b = 2 string = 'Naukri' print(a + b) print(int.__add__(a,b)) print (a + string) Copy code

**Output:**

So, for the last print statement, the code throws a TypeError because the built-in ‘int’ class does not have the **add()** method for the summation of ‘int’ and ‘str’ data types.

The following table gives a quick run-through of the special methods for bitwise operator overloading:

Expression | Magic Method |

instance & value | .and(self,value) |

value & instance | .rand(self,value) |

instance &= value | .iand(self,value) |

instance | value | .or(self,value) |

value | instance | .ror(self,value) |

instance|= value | .ior(self,value) |

instance ^ value | .xor(self,value) |

value ^ instance | .rxor(self,value) |

instance ^= value | .ixor(self,value) |

+ More 7 Rows |

**Endnotes**

Hope this article was helpful for you to understand bitwise operators in Python. We learned about the two types of bitwise operators: Bitwise Logical Operators and Bitwise Shift Operators and how to implement them in Python. We also learned about bitwise operator overloading. Want to learn more about Python and practice Python programming? Explore related articles here.