# Everything You Need To Know About 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: ANDORXOR, 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 Pythonmodulo is represented by the % sign. Here, it performs a division between the dividend (Ai + Bi) 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 thesign, 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:

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:

### 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.

Select the fields to be shown. Others will be hidden. Drag and drop to rearrange the order.
• Image
• SKU
• Rating
• Price
• Stock
• Availability
• Add to cart
• Description
• Content
• Weight
• Dimensions
• Additional information
Click outside to hide the comparison bar
Compare

## Subscribe to Newsletter

Stay ahead of the rapidly evolving world of technology with our news letters. Subscribe now!