# Python Bitwise Operators

Filed Under: Python

Python bitwise operators are used to perform bitwise calculations on integers. The integers are converted into binary format and then operations are performed bit by bit, hence the name bitwise operators.

Python bitwise operators work on integers only and the final output is returned in the decimal format. Python bitwise operators are also called binary operators.

## Python Bitwise Operators

There are 6 bitwise operators in Python. The below table provides short details about them.

Bitwise OperatorDescriptionSimple Example
&Bitwise AND Operator10 & 7 = 2
|Bitwise OR Operator10 | 7 = 15
^Bitwise XOR Operator10 ^ 7 = 13
~Bitwise Ones’ Compliment Operator~10 = -11
<<Bitwise Left Shift operator10<<2 = 40
>>Bitwise Right Shift Operator10>>1 = 5

Let’s look into these operators one by one and understand how they work.

### 1. Bitwise AND Operator

Python bitwise and operator returns 1 if both the bits are 1, otherwise 0.

``````
>>> 10&7
2
>>>
`````` Python Bitwise And Operator

### 2. Bitwise OR Operator

Python bitwise or operator returns 1 if any of the bits is 1. If both the bits are 0, then it returns 0.

``````
>>> 10|7
15
>>>
`````` Python Bitwise Or Operator

### 3. Bitwise XOR Operator

Python bitwise XOR operator returns 1 if one of the bits is 0 and the other bit is 1. If both the bits are 0 or 1, then it returns 0.

``````
>>> 10^7
13
>>>
`````` Python Bitwise XOR Operator

### 4. Bitwise Ones’ Complement Operator

Python Ones’ complement of a number ‘A’ is equal to -(A+1).

``````
>>> ~10
-11
>>> ~-10
9
>>>
`````` Python Bitwise Ones Complement Operator

### 5. Bitwise Left Shift Operator

Python bitwise left shift operator shifts the left operand bits towards the left side for the given number of times in the right operand. In simple terms, the binary number is appended with 0s at the end.

``````
>>> 10 << 2
40
>>>
`````` Python Bitwise Left Shift Operator

### 6. Bitwise Right Shift Operator

Python right shift operator is exactly the opposite of the left shift operator. Then left side operand bits are moved towards the right side for the given number of times. In simple terms, the right side bits are removed.

``````
>>> 10 >> 2
2
>>>
`````` Python Bitwise Right Shift Operator

Python supports operator overloading. There are various methods that we can implement to support bitwise operators for our custom objects.

Bitwise OperatorMethod to Implement
&__and__(self, other)
|__or__(self, other)
^__xor__(self, other)
~__invert__(self)
<<__lshift__(self, other)
>>__rshift__(self, other)

Here is an example of a bitwise operator overloading for our custom object.

``````
class Data:
id = 0

def __init__(self, i):
self.id = i

def __and__(self, other):
if isinstance(other, Data):
return Data(self.id & other.id)
else:
raise ValueError('Argument must be object of Data')

def __or__(self, other):
if isinstance(other, Data):
return Data(self.id | other.id)
else:
raise ValueError('Argument must be object of Data')

def __xor__(self, other):
if isinstance(other, Data):
return Data(self.id ^ other.id)
else:
raise ValueError('Argument must be object of Data')

def __lshift__(self, other):
if isinstance(other, int):
return Data(self.id << other)
else:
raise ValueError('Argument must be integer')

def __rshift__(self, other):
if isinstance(other, int):
return Data(self.id >> other)
else:
raise ValueError('Argument must be integer')

def __invert__(self):
return Data(~self.id)

def __str__(self):
return f'Data[{self.id}]'

d1 = Data(10)
d2 = Data(7)

print(f'd1&d2 = {d1&d2}')
print(f'd1|d2 = {d1|d2}')
print(f'd1^d2 = {d1^d2}')
print(f'd1<<2 = {d1<<2}')
print(f'd1>>2 = {d1>>2}')
print(f'~d1 = {~d1}')
``````

Output:

``````
d1&d2 = Data
d1|d2 = Data
d1^d2 = Data
d1<<2 = Data
d1>>2 = Data
~d1 = Data[-11]
``````
If you are not familiar with the new string formatting, please read f-strings in Python.

## Summary

Python bitwise operators are mostly used in mathematical calculations. We can implement specific methods to support bitwise operators for our custom class implementations too.

1. Radhika says:

Awesome! I loved the explanation!

2. Pranav Sudhir says:

Great Description.Appreciate the efforts.

3. Parth Jain says:

made my concepts clear thank you!!!

4. Rekha says:

a = 81
a << 2 = 324

Can you please explain this ?

1. zaltar says:

a=81 (in decimal) ; 81 => 1010001 (in binary)

now 1010001< 101000100

now converting the above binary number back to decimal we get 324

5. h.agnes says:

very nice and clear, thank you !

6. UDHAYAKUMAR says:

How bitwise NOT works..?

7. Nathanael HANIA says:

In the 5 section : “Bitwise Left Shift Operator”
>>> 10 >> 2
40
>>>

should be replaced by

>>> 10 << 2
40
>>>

1. Pankaj says:

Thanks for pointing out the typo error, I have fixed it.

8. magicandcode says:

Very succinct and clear description, awesome job!

9. pavani says:

i understand very clearly