bit-wise operation unary ~ (invert)

You are exactly right. It's an artifact of two's complement integer representation.

In 16 bits, 1 is represented as 0000 0000 0000 0001. Inverted, you get 1111 1111 1111 1110, which is -2. Similarly, 15 is 0000 0000 0000 1111. Inverted, you get 1111 1111 1111 0000, which is -16.

In general, ~n = -n - 1

The '~' operator is defined as: "The bit-wise inversion of x is defined as -(x+1). It only applies to integral numbers."Python Doc - 5.5

The important part of this sentence is that this is related to 'integral numbers' (also called integers). Your example represents a 4 bit number.

'0001' = 1 

The integer range of a 4 bit number is '-8..0..7'. On the other hand you could use 'unsigned integers', that do not include negative number and the range for your 4 bit number would be '0..15'.

Since Python operates on integers the behavior you described is expected. Integers are represented using two's complement. In case of a 4 bit number this looks like the following.

 7 = '0111'
 0 = '0000'
-1 = '1111'
-8 = '1000'

Python uses 32bit for integer representation in case you have a 32-bit OS. You can check the largest integer with:

sys.maxint # (2^31)-1 for my system

In case you would like an unsigned integer returned for you 4 bit number you have to mask.

'0001' = a   # unsigned '1' / integer '1'
'1110' = ~a  # unsigned '14' / integer -2

(~a & 0xF) # returns 14

If you want to get an unsigned 8 bit number range (0..255) instead just use:

(~a & 0xFF) # returns 254

It looks like I found simpler solution that does what is desired:

uint8: x ^ 0xFF
uint16: x ^ 0xFFFF
uint32: x ^ 0xFFFFFFFF
uint64: x ^ 0xFFFFFFFFFFFFFFFF

You could also use unsigned ints (for example from the numpy package) to achieve the expected behaviour.

>>> import numpy as np
>>> bin( ~ np.uint8(1))
'0b11111110'