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

`~`

implemented by the special method`__invert__`

is unrelated to the`not`

operator, which logically negates the value returned by`__bool__`

(or`__nonzero__`

in 2.x). It's also unrelated to the`-`

unary negation operator, implemented by`__neg__`

. For example`~True == -2`

, which isn't`False`

or false, and`-False == 0`

, which is still false.`-False==0`

) Its confusing, since you were talking about the`~`

, and`~False == -1`

which is not False.`__neg__`

). Probably I should have continued using`True`

, e.g.`-True == -1`

, which isn't -2 or`False`

or false, which more clearly links it back to the`~True`

result and also that the arithmetic negation of a`bool`

is different from its logical negation. I wasn't trying to be deep. I was just highlighting 3 operations and the underlying special methods that sometimes get confused.