# Python Bitwise Right-Shift >> Operator

5/5 - (1 vote)

The Python bitwise right-shift operator `x >> n` shifts the binary representation of integer `x` by `n` positions to the right. It inserts a `0` bit on the left and removes the right-most bit. For example, if you right-shift the binary representation `0101` by one position, you’d obtain `0010`. Semantically, the bitwise right-shift operator is the same as performing integer division by `2**n`.

Here’s a minimal example:

```print(8 >> 1)
# 4

print(8 >> 2)
# 2

print(-3 >> 1)
# -2```

Let’s dive deeper into the details next!

## Video Explainer

As you go over the article, you can watch my explainer video here:

## Example

In this example, you apply the bitwise right-shift operator to integer 32 shifting it by one position:

```x = 32

# Shift by one position to the right
res = x >> 1
print(res)
# 16

# Shift by two positions to the right
res = x >> 2
print(res)
# 8
```

The bit representation of decimal `32` is `"00100000"`. If you shift it by one position to the right, you obtain binary `"00010000"` (decimal 16). If you shift by two positions to the right, you obtain binary `"00001000"` (decimal 8). Here’s the tabular explanation:

Each row represents the resulting shifted binary representation of the original integer 32.

## Representing Negative Integers in Binaries

Python uses so-called complementary binaries to represent negative integers. The first bit of a complementary binary is the sign (0: positive, 1: negative). All remaining bits encode the number. You write a negative number `-x` as the bit pattern for `(x-1)` and flip all bits from 1 to 0 and from 0 to 1 (complement).

Here are two simple examples:

• To represent `x = -1` using 8 bits you first calculate `(1-1) = 0` and then flip all bits to calculate `"11111111"`.
• To represent `x = -10` using 8 bits you first calculate `(10-1) = 9` which is `"00001001"` in binary format. Then, you complement all bits to determine the negative (complementary) binary `"11110110"`.

Let’s use this knowledge in a couple of examples to showcase the working of the bitwise XOR operator on negative integers:

## Python Bitwise Right Shift on Negative Integers

Here’s the result of the bitwise right-shift operator `x >> n` when applied to example negative integer operands `x` and `n`:

You can see those examples in the following script:

```print(-1 >> 1)
# -1

print(-2 >> 1)
# -1

print(-4 >> 1)
# -2

print(-4 >> 2)
# -1
```

## How to Resolve ValueError: negative shift count?

You cannot use a negative shift count, i.e., in the expression `x >> n`, the second operand n must be non-negative. It can be zero. If you use a negative shift count, Python raises the “`ValueError: negative shift count`“. To resolve it, use the left-shift operation `x << n` instead of using a negative shift count.

Here’s an example of the `ValueError`:

```>>> 2 >> -1
Traceback (most recent call last):
File "<pyshell#19>", line 1, in <module>
2 >> -1
ValueError: negative shift count```

And here’s an example of how to resolve it using right-shift instead of left-shift operation:

```>>> 2 << 1
4```

To enable the right-shift operator on your custom object, use Python’s operator overloading functionality. Overloading works through what is called magic methods or dunder methods (for “double-underscore methods”). For the right-shift operator, the magic method is the `__rshift__(self, other)` method. It should return a new custom object that is the result of the bitwise operation.

Here’s a short overview of the Bitwise operators’ magic methods:

Here’s an example of how to accomplish these bitwise operators on a custom class `Data`. We marked this respective operator in the code:

```class Data:

def __init__(self, data):
self.data = data

def __and__(self, other):
return Data(self.data & other.data)

def __or__(self, other):
return Data(self.data | other.data)

def __xor__(self, other):
return Data(self.data ^ other.data)

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

def __lshift__(self, other):
return Data(self.data << other.data)

def __rshift__(self, other):
return Data(self.data >> other.data)

x = 2
y = 3
print('Operands: \n', 'x =', x, '\n', 'y =', y)
print()
print('Bitwise AND: ', x & y)
print('Bitwise OR: ', x | y)
print('Bitwise XOR: ', x ^ y)
print('Bitwise NOT: ', ~x)
print('Bitwise LEFT-SHIFT: ', x << y)
print('Bitwise RIGHT-SHIFT: ', x >> y)
```

The output is:

```Operands:
x = 2
y = 3

Bitwise AND:  2
Bitwise OR:  3
Bitwise XOR:  1
Bitwise NOT:  -3
Bitwise LEFT-SHIFT:  16
Bitwise RIGHT-SHIFT:  0```

## Bitwise Operators

Bitwise operators perform operations on the binary (bit) representation of integers. The following table gives a short overview of all existing bitwise operators. Note that we also provide the binary representation `100` for the decimal integer `4`, and `101` for the decimal integer `5` as a comment in the right column. 