### Question :

What’s the usage of the tilde operator in Python?

One thing I can think about is do something in both sides of a string or list, such as check if a string is palindromic or not:

```
def is_palindromic(s):
return all(s[i] == s[~i] for i in range(len(s) / 2))
```

Any other good usage?

##
Answer #1:

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.)

##
Answer #2:

`~`

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.

##
Answer #3:

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()]
```

##
Answer #4:

One should note that in the case of array indexing, `array[~i]`

amounts to `reversed_array[i]`

. It can be seen as indexing starting from the end of the array:

```
[0, 1, 2, 3, 4, 5, 6, 7, 8]
^ ^
i ~i
```

##
Answer #5:

The only time I’ve ever used this in practice is with `numpy/pandas`

. For example, with the `.isin()`

dataframe method.

In the docs they show this basic example

```
>>> df.isin([0, 2])
num_legs num_wings
falcon True True
dog False True
```

But what if instead you wanted all the rows **not in** [0, 2]?

```
>>> ~df.isin([0, 2])
num_legs num_wings
falcon False False
dog True False
```

##
Answer #6:

I was solving this leetcode problem and I came across this beautiful solution by a user named Zitao Wang.

The problem goes like this for each element in the given array find the product of all the remaining numbers without making use of divison and in `O(n)`

time

The standard solution is:

```
Pass 1: For all elements compute product of all the elements to the left of it
Pass 2: For all elements compute product of all the elements to the right of it
and then multiplying them for the final answer
```

His solution uses only one for loop by making use of. He computes the left product and right product on the fly using `~`

```
def productExceptSelf(self, nums):
res = [1]*len(nums)
lprod = 1
rprod = 1
for i in range(len(nums)):
res[i] *= lprod
lprod *= nums[i]
res[~i] *= rprod
rprod *= nums[~i]
return res
```

##
Answer #7:

This is minor usage is tilde…

```
def split_train_test_by_id(data, test_ratio, id_column):
ids = data[id_column]
in_test_set = ids.apply(lambda id_: test_set_check(id_, test_ratio))
return data.loc[~in_test_set], data.loc[in_test_set]
```

the code above is from “Hands On Machine Learning”

you use tilde (~ sign) as alternative to – sign index marker

just like you use minus – is for integer index

ex)

```
array = [1,2,3,4,5,6]
print(array[-1])
```

is the samething as

`print(array[~1])`