Bitwise Operators in Python

# Bitwise Operators in Python

Updated on Jul 13, 2022 18:15 IST

In this article, we will focus on focus on bitwise operators and understand how they perform computations in Python through examples.

In Python, operators are special characters or symbols that are used to perform arithmetic or logical operations on certain values and variables. These values that the operators operate on are known as operands.

## 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 = 9num2 = 13 print(num1 & num2)Copy code```

Output:

` `
`9Copy 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 = 9Copy 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 = 12num2 = 6 print(num1 | num2)Copy code`

Output:

` `
`14Copy 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 = 1100num2 = 6 -> binary representation of 6 = 0110 num1 | num2 = 1100 | 0110 = 1110 = 14Copy 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 (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 = 3num2 = 10 print(num1 ^ num2)Copy code`

Output:

` `
`9Copy 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 = 0011num2 = 10 -> binary representation of 10 = 1010 num1 ^ num2 = 0011 ^ 1010 = 1110 = 14Copy 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 = 342print(~num)Copy code`

Output:

` `
`-343Copy 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) = -343Copy code```

Now that we have understood all four bitwise logical operators, let’s move on to the two bitwise shift operators:

Python Map() Function
Python is an object-oriented programming language that also offers several functional programming utilities. In this article, we will focus on one of the most special in-built functions it offers –...read more
Type Casting in Python
Through this article, you will be able to learn about type conversion or type casting in Python. We will be discussing type casting into different data types.
Understanding Literals in Python
When starting with Python programming, it is important to get the basics right before we get into coding. In your very first class of Python, you will be introduced to...read more

## 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 shiftnum = 13print(num << 1) print(num << 3)Copy code`

Output 1:

` `
`26104Copy 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 = 104Copy code```

Example 2:

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

Output 2:

` `
`-180Copy 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 = -180Copy 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.

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 shiftnum = 120print(num >> 1) print(num >> 3)Copy code`

Output 1:

` `
`6015Copy 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 = 15Copy code```

Example 2:

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

Output 2:

` `
`-3Copy 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 = -3Copy code```

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:

` `
`StarbucksCopy code`

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

• 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 code```

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 = 6b = 2string = '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.

_______________

Recently completed any professional course/certification from the market? Tell us what you liked or disliked in the course for more curated content.