# Why does ~True result in -2?

Each Answer to this Q is separated by one/two green lines.

In Python console:

``````~True
``````

Gives me:

``````-2
``````

Why? Can someone explain this particular case to me in binary?

`int(True)` is `1`.

`1` is:

``````00000001
``````

and `~1` is:

``````11111110
``````

Which is `-2` in Two’s complement1

1 Flip all the bits, add 1 to the resulting number and interpret the result as a binary representation of the magnitude and add a negative sign (since the number begins with 1):

``````11111110 ? 00000001 ? 00000010
?          ?
``````

Which is 2, but the sign is negative since the MSB is 1.

Worth mentioning:

Think about `bool`, you’ll find that it’s numeric in nature – It has two values, `True` and `False`, and they are just “customized” versions of the integers 1 and 0 that only print themselves differently. They are subclasses of the integer type `int`.

So they behave exactly as 1 and 0, except that `bool` redefines `str` and `repr` to display them differently.

``````>>> type(True)
<class 'bool'>
>>> isinstance(True, int)
True

>>> True == 1
True
>>> True is 1  # they're still different objects
False
``````

The Python `bool` type is a subclass of `int` (for historical reasons; booleans were only added in Python 2.3).

Since `int(True)` is `1`, `~True` is `~1` is `-2`.

See PEP 285 for why `bool` is a subclass of `int`.

If you wanted the boolean inverse, use `not`:

``````>>> not True
False
>>> not False
True
``````

If you wanted to know why `~1` is `-2`, it’s because you are inverting all bits in a signed integer; `00000001` becomes `1111110` which in a signed integer is a negative number, see Two’s complement:

``````>>> # Python 3
...
>>> import struct
>>> format(struct.pack('b', 1), '08b')
'00000001'
>>> format(struct.pack('b', ~1), '08b')
'11111110'
``````

where the initial `1` bit means the value is negative, and the rest of the bits encode the inverse of the positive number minus one.

`~True == -2` is not surprising if `True` means `1` and `~` means bitwise inversion

provided that

• `True` can be treated as an integer and
• integers are represented in Two’s complement

Edits:

• fixed the mixing between integer representation and bitwise inversion operator
• applied another polishing (the shorter the message, the more work needed) The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .