Integers, Bit Operations and bool

## One integer type, no width Python 3 has exactly one built-in integer type, `int`, and it is arbitrary precision - what other ecosystems call a big integer. Python 2 had two types, a machine-width integer and an unbounded long that the interpreter promoted to automatically; PEP 237 merged them, and the survivor is the unbounded one. So the overflow answers you would give in C, Java or Go simply do not apply: there is no wraparound, no undefined behaviour, no signed/unsigned distinction and no width to choose. `2 ** 200`, a factorial of 5000, or a cryptographic-size modulus are all ordinary values. ## How CPython stores it A CPython `int` object is an object header plus a sign-and-size field plus an array of digits. On a typical 64-bit build each digit holds 30 bits (some builds use 15), so the value is stored base 2**30, little-digit-first. Growing a number means allocating a bigger object - integers are immutable, so every arithmetic result is a fresh object. Two conveniences sit on top: values from -5 to 256 are preallocated and shared, so those objects are reused rather than allocated, and `sys.getsizeof()` will show you the object growing as the value does. ```pycon >>> import sys >>> sys.getsizeof(1) < sys.getsizeof(2 ** 200) True ``` ## What that buys you The entire class of overflow bugs that dominates fixed-width languages does not exist inside Python. An id sequence does not exhaust a 32-bit space, an accumulating counter does not flip negative, an intermediate product in a sum does not silently truncate. Because the type is exact, integer arithmetic is also a safe place to do money arithmetic in minor units, checksum accumulation, or index math on very large collections without reasoning about ranges. The failure mode moves outward rather than disappearing. The size only matters when the number crosses a boundary: a `BIGINT` column, a JSON consumer whose parser stores numbers as doubles, a C extension expecting a machine word, or a fixed-width binary format. At those boundaries you either get an explicit error - `int.to_bytes()` raises `OverflowError` when the value does not fit the byte length you asked for - or silent truncation on the other side. That is why the interesting review question about a Python integer is never 'can it overflow' but 'what is the narrowest thing that will ever read it'. ## What it costs Memory: proportional to the bit count, plus the object header. A list of a million small integers is fine; a list of a million 4096-bit integers is not. Time: operations are not constant time. Addition and subtraction are linear in the number of digits, multiplication uses a schoolbook algorithm for small operands and switches to a subquadratic Karatsuba algorithm above a threshold, and division is more expensive still. Converting between binary digits and a decimal string is superlinear for very large values. None of this matters at everyday magnitudes, and all of it matters in a tight numeric loop - which is exactly why numeric-heavy work is usually pushed down into a compiled extension that uses machine-width or vectorised types. Hashing stays cheap and consistent: equal integers hash equally regardless of magnitude, because the hash reduces the value modulo a Mersenne prime rather than truncating it. ## Measuring an int `int.bit_length()` gives the number of bits needed to represent the absolute value, excluding the sign and leading zeros - `(2 ** 200).bit_length()` is 201, and `(0).bit_length()` is 0. `int.bit_count()`, added in Python 3.10, returns how many of those bits are ones, again for the absolute value. Both are the honest way to ask how big a value has become, and both are far better than comparing against an invented constant. ## Interview traps The two mistakes an interviewer listens for are 'Python ints wrap at 64 bits' and '`sys.maxsize` is the largest integer'. The first is a leftover instinct from another language; the second confuses an address-space quantity with a numeric limit. The right frame is: an `int` is bounded only by available memory, its operations are not O(1), and fixed width is something you opt into at the edges of the process rather than something the language imposes.