# The tilde operator in Python

## The tilde operator in Python

It is a unary operator (taking a single argument) that is borrowed from C, where all data types are just different ways of interpreting bytes. It is the invert or complement operation, in which all the bits of the input data are reversed.

In Python, for integers, the bits of the twos-complement representation of the integer are reversed (as in `b <- b XOR 1`

for each individual bit), and the result interpreted again as a twos-complement integer. So for integers, `~x`

is equivalent to `(-x) - 1`

.

The reified form of the `~`

operator is provided as `operator.invert`

. To support this operator in your own class, give it an `__invert__(self)`

method.

```
>>> import operator
>>> class Foo:
... def __invert__(self):
... print invert
...
>>> x = Foo()
>>> operator.invert(x)
invert
>>> ~x
invert
```

Any class in which it is meaningful to have a complement or inverse of an instance that is also an instance of the same class is a possible candidate for the invert operator. However, operator overloading can lead to confusion if misused, so be sure that it really makes sense to do so before supplying an `__invert__`

method to your class. (Note that byte-strings [ex: `xff`

] do not support this operator, even though it is meaningful to invert all the bits of a byte-string.)

`~`

is the bitwise complement operator in python which essentially calculates `-x - 1`

So a table would look like

```
i ~i
-----
0 -1
1 -2
2 -3
3 -4
4 -5
5 -6
```

So for `i = 0`

it would compare `s[0]`

with `s[len(s) - 1]`

, for `i = 1`

, `s[1]`

with `s[len(s) - 2]`

.

As for your other question, this can be useful for a range of bitwise hacks.

#### The tilde operator in Python

Besides being a bitwise complement operator, `~`

can also help revert a *boolean* value, though it is not the conventional `bool`

type here, rather you should use `numpy.bool_`

.

This is explained in,

```
import numpy as np
assert ~np.True_ == np.False_
```

Reversing logical value can be useful sometimes, e.g., below `~`

operator is used to cleanse your dataset and return you a column without NaN.

```
from numpy import NaN
import pandas as pd
matrix = pd.DataFrame([1,2,3,4,NaN], columns=[Number], dtype=float64)
# Remove NaN in column Number
matrix[Number][~matrix[Number].isnull()]
```