What does ~n return for a Python int, and how do you get fixed-width bitwise results?

## The mental model: infinite sign extension Python's bitwise operators are total functions on unbounded integers, and the way to keep them straight is a single rule: imagine every `int` written in two's complement and extended infinitely to the left with copies of its sign bit. A non-negative number has infinitely many leading zeros; a negative number has infinitely many leading ones. `&`, `|`, `^` and `~` then operate bit by bit on those infinite strings, and the result always ends up being a finite integer again because the leading bits are all identical. That single rule produces everything else: - `~n` flips every bit, including the infinite sign run, which turns the sign around. Arithmetically it is exactly `-n - 1`, so `~5` is `-6` and `~-1` is `0`. - `-1` is the all-ones value, so `n ^ -1` is `~n` and `n & -1` is `n`. - `&` between two negatives stays negative, because both sign runs are ones. `5 & -1` is `5`, `-2 & -3` is `-4`. ```pycon >>> ~5 -6 >>> 5 ^ -1 -6 >>> ~0 -1 >>> -2 & -3 -4 ``` The most common wrong answer in an interview is `~5 == 250`. That is the 8-bit answer, and it is only correct in a language where the value has a declared width. Python has no width to complement inside. ## Shifts `<<` is an ordinary multiplication by a power of two and never overflows or wraps; `1 << 200` simply allocates a larger integer. The practical limit is memory, and shifting by an enormous count allocates memory proportional to the result, so a shift count read from untrusted input is a resource concern rather than an arithmetic one. `>>` is an arithmetic shift that floors toward negative infinity, consistent with the infinite-sign-extension model: `-8 >> 1` is `-4`, `-7 >> 1` is `-4` (not `-3`), and `-1 >> 100` is still `-1`, because shifting an infinite run of ones rightwards leaves an infinite run of ones. There is no `>>>` operator in Python. It would be meaningless: an unsigned right shift is defined by the width it shifts zeros into, and there is no width. A negative shift count raises `ValueError`, and shifting or masking a `float` raises `TypeError` - bitwise operators accept only integers, which includes booleans since `bool` is an `int` subclass. ## Emulating fixed width When you are reimplementing an algorithm that was specified for 32-bit or 64-bit registers - a checksum, a hash function, a protocol field - you must add the width back yourself. Mask after every operation that can grow or go negative, and convert back to a signed interpretation only when you need one: ```python MASK32 = (1 << 32) - 1 def not32(n: int) -> int: return ~n & MASK32 def as_signed32(n: int) -> int: n &= MASK32 return n - (1 << 32) if n >= 1 << 31 else n print(not32(5)) # 4294967290 print(as_signed32(not32(5))) # -6 ``` The masking discipline is the whole trick: `& MASK32` after each step keeps values in range, and it must be applied after shifts and additions too, because both can push a value past 32 bits. Forgetting one mask usually produces a result that is correct for small inputs and wrong for large ones, which is the worst kind of bug to find later. ## Measuring bits `int.bit_length()` returns the bit count of the absolute value with no leading zeros, so `(255).bit_length()` is 8, `(-1).bit_length()` is 1 and `(0).bit_length()` is 0. It never counts a sign bit, because there is no fixed field for one. `int.bit_count()`, added in Python 3.10, counts the one bits of the absolute value, so `(5).bit_count()` and `(-5).bit_count()` are both 2. If you need the popcount of a negative value under a specific width, mask it first. ## Why the design is the way it is Any other definition would need a width, and the language deliberately does not have one. Defining bitwise operators on the infinitely sign-extended representation keeps them consistent with arithmetic - `x >> 1` equals `x // 2` for every integer, positive or negative - and keeps every operator total. The cost is that programmers arriving from a fixed-width language must supply the width themselves, explicitly, with a mask.