Python Primitive Data Types: str, int, float, bool Physics

Execute print(0.1 + 0.2) inside a standard Python REPL shell, and the runtime returns: 0.30000000000000004. This is not an engine malfunction; it is the fundamental friction between base-10 human decimal arithmetic and the base-2 binary constraints of physical silicon transistors.

Every programmatic domain relies upon four core primitives: String (str), Integer (int), Float (float), and Boolean (bool). In Python, these abstractions do not merely format variables; they govern low-level memory allocation, CPU register utilization, and hardware-accelerated ALU pipelines. This guide dissects arbitrary-precision integer architectures, IEEE 754 floating-point mechanics, Unicode immutability constraints, and boolean sub-typing directly from a systems engineering viewpoint.

1. Integer (int): Arbitrary-Precision Bignum Mechanics

In statically compiled environments like C or Java, integers map directly to discrete 32-bit or 64-bit hardware registers. Exceeding $2^{63}-1$ triggers an Arithmetic Integer Overflow, cycling the signed bit into negative values.

Python 3 eradicates overflow boundaries entirely by implementing an internal arbitrary-precision Bignum structure:

• Digit Chunking Architecture: CPython decomposes large numbers into dynamic arrays of 30-bit limbs (digits).
• RAM-Bound Limits: Evaluating 2 ** 1000 does not crash the interpreter; Python dynamically expands heap allocation to house the required bit-depth, bounding integer capacity solely to available physical system memory.

  [STATIC HARDWARE REGISTERS vs. PYTHON DYNAMIC BIGNUM]

  C / Java (Fixed 64-bit Cell) : [64-bit Register] ---> Exceeds Capacity: HARD OVERFLOW!
  Python Bignum (C Struct Array): [30-bit Limb] + [30-bit Limb] + [30-bit Limb]... (Dynamically Scaled)

2. Float: Binary Fractions & IEEE 754 Precision Loss

Python floats conform to standard IEEE 754 Double-Precision (64-bit) binary formatting, allocating: 1 bit for the sign, 11 bits for the exponent, and 52 bits for the mantissa (fractional precision).

While base-10 fractional systems cleanly express numbers whose denominators share prime factors of 10 (2 and 5), base-2 registers can only terminate fractions whose denominators are pure powers of 2. Decimal 0.1 represents an infinite repeating binary sequence: 0.0001100110011.... Truncating this sequence at 53 bits introduces unavoidable precision drift, accumulating as microscopic residuals (e.g., ...0004).

# Financial and Mission-Critical Mitigation
from decimal import Decimal

# Using floats introduces rounding artifacts:
print(0.1 + 0.2 == 0.3) # Evaluates to False

# Using exact Decimal arbitrary-precision:
print(Decimal('0.1') + Decimal('0.2') == Decimal('0.3')) # Evaluates to True

3. String (str): Unicode Buffers & The Invariant of Immutability

Python strings represent sequences of immutable Unicode characters. Under PEP 393, CPython optimizes memory layouts dynamically via three distinct internal representations (Latin-1, UCS-2, or UCS-4), allocating 1, 2, or 4 bytes per character based on the highest code point within the string buffer.

Strings are strictly Immutable. Once allocated on the heap, character cells cannot be overwritten in place:

buffer = "Python"
# buffer[0] = "J" # Raises TypeError: 'str' object does not support item assignment

This immutability guarantees a stable hash value across the lifecycle of the string, ensuring constant-time $O(1)$ lookups when serving as keys in Python dictionary hash tables.

4. Boolean (bool): Integer Inheritance and Bit Logic

The bool datatype in Python is not an isolated binary type; it is an explicit architectural subclass of int:

• True evaluates numerically as integer 1.
• False evaluates numerically as integer 0.

# Demonstrating integer polymorphism
print(True + True)            # Output: 2
print(isinstance(True, int))  # Output: True
print(issubclass(bool, int))  # Output: True

5. Primitive Datatype Comparison & Memory Overhead

Measuring memory footprints via sys.getsizeof() illustrates the administrative overhead of Python's rich object wrappers: