# Python In-Place Bitwise Left-Shift Operator

Python’s in-place bitwise left-shift operator `x <<= y` calculates the left-shift operation `x << y`, and assigns the result to the first operands variable name `x`. You can set up the in-place left-shift behavior in your own class by overriding the magic “dunder” method `__ilshift__(self, other)` in your class definition.

```>>> x = 8
>>> x <<= 2
>>> x
32```

The expression `x <<= y` is syntactical sugar for the longer-form `x = x << y`:

```>>> x = 8
>>> x = x << 2
>>> x
32```

Let’s explore some examples on different data types of the operands.

## Recap Bitwise Left-Shift

The Python bitwise left-shift operator `x << n` shifts the binary representation of integer `x` by `n` positions to the left. For a positive integer, it inserts a `0` bit on the right and shifts all remaining bits by one position to the left. For example, if you left-shift the binary representation `0101` by one position, you’d obtain `01010`. Semantically, the bitwise left-shift operator `x << n` is the same as multiplying the integer `x` with `2**n`.

Here’s a minimal example:

```print(8 << 1)
# 16

print(8 << 2)
# 32

print(-3 << 1)
# -6```

Feel free to watch my explainer video here:

Related. To learn more about the bitwise left-shift operator, and how it works on positive and negative integers, check out our related tutorial: Python Bitwise Left-Shift Operator

## Incompatible Data Type

What if two operands have an incompatible data type—unlike floats and integers? For example, if you try to shift a float variable by a list variable (which doesn’t make sense)?

```>>> x = 3.0
>>> y = [1, 2]
>>> x << y
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
x << y
TypeError: unsupported operand type(s) for <<: 'float' and 'list'```

The result of incompatible addition is a `TypeError`. You can fix it by using only compatible data types for the in-place bitwise left-shift operation.

Can you use the bitwise left-shift operator on custom objects? Yes!

## Python In-Place Bitwise Left-Shift Magic Method

To use the in-place bitwise left-shift operator `<<=` on custom objects, you need to define the `__ilshift__()` method (“dunder method”, “magic method”) that takes two arguments `self` and `other`, updates the first argument `self` with the result of the operation, and returns the updated object.

In the following code, you combine two `Data` objects using the in-place left-shift operation:

```class Data:

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

def __ilshift__(self, other):
self.data <<= other.data
return self

x = Data(8)
y = Data(2)

x <<= y
print(x.data)
# 32
```

You can see that the content of the first operand is updated as a result of the in-place bitwise left-shift operation.

## Python In-Place Operators

In-place assignment operators (also called compound assignment operators) perform an operation in-place on a variable provided as first operand. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment. For example, `x += 3` is the same as `x = x + 3` of first calculating the result of `x +3` and then assigning it to the variable x. 