Python Data Types Architecture

The Type Hierarchy: Everything is an Object

In Python, functions are objects. Classes are objects. Modules are objects. Even the standard types like intand str are instances of the metaclass type. All of these ultimately inherit from the base object class.

# Checking types
x = 100
print(type(x))  # <class 'int'>

# ⚠️ Don't compare types directly!
# Bad: if type(x) == int:
# Good: isinstance() handles inheritance
class SuperInt(int): pass

n = SuperInt(5)
print(type(n) == int)      # False (Strict check fails)
print(isinstance(n, int))  # True (It behaves like an int)

Code Walkthrough

The isinstance(obj, class) function is the "polymorphic" way to check types. It returns Truenot just if the object is that exact class, but also if it inherits from that class. This follows the Liskov Substitution Principle: if a function expects an int, it should also accept a subclass of int.

History Lesson: The Great String Schism (Python 2 vs 3)

If you read older code, you might see u"hello" or unicode(). In Python 2, the default string type str was just a sequence of raw bytes (like ASCII). To support accents, emojis, and global languages, you had to explicitly use "unicode strings".

# Python 2 (Legacy)
x = "Hello"   # This was BYTES (ASCII)
y = u"Héllo"  # This was Unicode

# Python 3 (Modern)
x = "Héllo"   # This is UNICODE by default!
y = b"Data"   # This is BYTES (binary data)

# Why the change?
# Mixing bytes and unicode in Python 2 caused the infamous
# UnicodeDecodeError: 'ascii' codec can't decode byte...
# Python 3 forces you to be explicit: You must .encode() to get bytes
# and .decode() to get text.

This change was painful at the time but made Python the world-class language it is today for handling text processing and web development.

Memory Deep Dive: Mutability & References

This is the single most important concept in Python data structures.Immutable objects cannot be changed after creation. Mutable objects can be modified in place.

Since variables are just references (pointers) to objects, modifying a mutable object (like a list) will affect every variablethat points to it.

# SCENARIO 1: Immutable (Integer)
a = 10
b = a      # b points to the SAME object (10) as a
a = 20     # This creates a NEW object (20) and moves the label 'a'
           # 'b' still points to the old object (10)

print(f"a: {a}, b: {b}")  # a: 20, b: 10 (Safe!)


# SCENARIO 2: Mutable (List)
list_a = [1, 2, 3]
list_b = list_a   # list_b points to the SAME list object
list_a.append(4)  # Modifies the object IN PLACE

print(f"a: {list_a}")  # [1, 2, 3, 4]
print(f"b: {list_b}")  # [1, 2, 3, 4] (Changed!)

# SCENARIO 3: Preventing the trap with .copy()
list_c = [1, 2, 3]
list_d = list_c.copy()  # Creates a NEW distinct list object
list_c.append(4)

print(f"c: {list_c}")   # [1, 2, 3, 4]
print(f"d: {list_d}")   # [1, 2, 3] (Safe!)

Under the Hood: The `id()` Function

You can prove this behavior using the built-in id() function, which returns the memory address of an object (in CPython).

x = [1, 2]
y = x
print(id(x) == id(y))  # True (Same address)

y = x.copy()
print(id(x) == id(y))  # False (Different addresses)

Numeric Precision: Floats vs Integers

Python Integers are magical. In languages like C or Java, an integer is limited to 32 or 64 bits. If you exceed2,147,483,647, you get an overflow error.Python integers have arbitrary precision. They can be as large as your RAM allows.

The Floating Point Tragedy

Floats, however, are standard IEEE 754 double-precision numbers. They cannot represent all decimal fractions exactly. This leads to the infamous "0.30000000000000004" problem.

# The Problem
val = 0.1 + 0.2
print(val)          # 0.30000000000000004
print(val == 0.3)   # False! 😱

# The Fix: Use the Decimal module for financial math
from decimal import Decimal

d_val = Decimal('0.1') + Decimal('0.2')
print(d_val)         # 0.3
print(d_val == Decimal('0.3'))  # True

Code Walkthrough

• Line 2: Computers store numbers in binary (base-2). 0.1 is 1/10, which has a repeating binary expansion (like 1/3 in decimal), so it gets truncated.
• Line 8: Decimal stores numbers as digits (base-10), just like humans write them, avoiding conversion errors. Always pass strings '0.1' to Decimal, not floats 0.1!

CPython Internals: Optimization Secrets

To make Python faster, the CPython interpreter (the standard Python) uses several tricks to avoid allocating memory unnecessarily. Understanding these can explain "weird" behavior during debugging.

1. Small Integer Caching

Python pre-allocates integers from -5 to 256 when the interpreter starts. Every time you access these numbers, you get a reference to the existing singleton object.

# Small integers are cached
a = 100
b = 100
print(a is b)  # True (Same memory address)

# Large integers are NOT cached (usually)
x = 1000
y = 1000
print(x is y)  # False (Different objects)

# Note: Some IDEs/Compilers might optimize 'x = 1000; y = 1000' 
# within the same code block, masking this behavior.

2. String Interning

Python automatically "interns" (caches) strings that look like identifiers (letters, numbers, underscores). This allows for faster dictionary lookups since string comparison becomes a pointer comparison check.

The Special Case of 'None'

None is Python's Null. It represents the absence of a value. Crucially, None is a Singleton. There is only ever one None object in the entire system.

val = None

# ✅ The Correct Way (Identity Check)
if val is None:
    print("It's empty")

# ❌ The Wrong Way (Equality Check)
if val == None:
    print("It's empty")
    
# Why? A custom class could implement __eq__ to return True
# even if it's not actually None.

Advanced Memory Management: Garbage Collection

We established that variables are references to objects. But what happens when an object has no references? Example: x = 10; x = 20. The integer object 10 is now "orphaned". Python's Memory Manager handles this automatically via two mechanisms.

1. Reference Counting (Primary)

Every object in Python contains a field ob_refcnt. When you assign x = obj, count goes up. When you delete del x or reassign, count goes down. When references hit 0, the memory is instantly reclaimed. This is deterministic and fast.

2. Cyclic Garbage Collector (Secondary)

What if Object A refers to Object B, and Object B refers to Object A? Their reference counts never hit 0, even if the rest of the program can't access them! This is a "Reference Cycle". Python has a separate Garbage Collector (GC) that periodically wakes up, pauses your program, scans for these cycles, and cleans them up.

import gc

# Define a class
class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

# Create a cycle
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1  # Cycle!

# Delete references
del node1
del node2
# At this point, ref counts are 1 (pointing to each other).
# They are technically garbage but Ref Counting can't see it.

# Manually trigger GC (usually automatic)
gc.collect()

Deep Dive: How Python Integers Work

We mentioned Python Integers have "Arbitrary Precision". How? In CPython, an int is a C struct containing an array of digits (stored in base-2^30).

When you calculate 2 ** 1000, Python dynamically expands this array to store the result. This makes Python slower at math than C (which uses CPU-native 64-bit integers) but infinitely more flexible. However, this abstraction has a cost: a simple integer takes 28 bytes of memory overhead in Python!

Performance Optimization: __slots__

By default, Python objects store their instance variables in a dictionary (__dict__). This allows you to add new attributes at runtime, but dictionaries use a lot of RAM. If you are creating millions of objects (e.g., points in a 3D game or pixels), this overhead kills performance.

The fix? __slots__.

class Point:
    # Tell Python: "Don't use a dictionary! Just reserve space for x and y."
    __slots__ = ['x', 'y']
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
p.x = 10
# p.z = 5  # AttributeError! Can't add new attributes dynamically.

Code Walkthrough

Using __slots__ removes the dynamic __dict__ and prevents adding new attributes, but it makes attribute access faster and reduces memory usage significantly (often by 40-50%).

Bitwise Magic: Integers as Bits

Since computers execute binary logic, Python exposes direct access to these operations via Bitwise Operators. These are crucial for networking (flags), cryptography, and lower-level optimization.

x = 10       # Binary: 1010
y = 4        # Binary: 0100

print(x & y)   # Bitwise AND: 0000 -> 0
print(x | y)   # Bitwise OR:  1110 -> 14
print(x ^ y)   # Bitwise XOR: 1110 -> 14
print(x << 1)  # Left Shift: 10100 -&gt; 20 (Multiply by 2)
print(x >> 1)  # Right Shift: 0101 -&gt; 5  (Divide by 2)

# Binary Representation Helper
print(bin(x))  # '0b1010'

Under the Hood: Python Bytecode

When you run a script, Python compiles it into Bytecode - a low-level set of instructions for the Python Virtual Machine (PVM). We can inspect this using the dis module to see exactly what operations are happening.

import dis

def add(a, b):
    return a + b

# Show the Bytecode instructions
dis.dis(add)

Output Explanation

  2           0 LOAD_FAST                0 (a)
              2 LOAD_FAST                1 (b)
              4 BINARY_ADD
              6 RETURN_VALUE

This confirms that adding two variables involves pushing them onto the stack (LOAD_FAST), executing the addition (BINARY_ADD), and returning the result. No magic, just operations.

Modern Data Models: Enums and Dataclasses

Python 3.4+ introduced powerful ways to structure data that go beyond simple dictionaries and classes.

1. Enumerations (Enum)

Stop using "Magic Strings" or integers (0=Red, 1=Blue) to represent fixed states. Enums make code readable and type-safe.

from enum import Enum, auto

class Status(Enum):
    PENDING = auto()
    RUNNING = auto()
    COMPLETED = auto()
    FAILED = auto()

def check_job(status):
    # Safer than: if status == "RUNNING":
    if status is Status.RUNNING:
        print("Job is active")

print(Status.PENDING.name)  # 'PENDING'
print(Status.PENDING.value) # 1

2. Dataclasses

Writing __init__, __repr__, and __eq__ for every data-holding class is tedious. Dataclasses (Python 3.7+) automate this. They are essentially "Mutable Structs".

from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str
    active: bool = True

# Auto-generated __init__!
u = User(1, "Alice", "alice@example.com")

# Auto-generated __repr__!
print(u) 
# User(id=1, name='Alice', email='alice@example.com', active=True)

# Auto-generated __eq__!
u2 = User(1, "Alice", "alice@example.com")
print(u == u2)  # True (Value equality)

Beyond Basics: The Collections Module

While lists and dicts are powerful, Python includes specialized container datatypes in the collections module. Knowing these separates intermediate developers from experts.

1. defaultdict

A dictionary that calls a factory function to supply missing values. No more KeyError!

from collections import defaultdict

# Counting words without checking keys
word_counts = defaultdict(int)  # Default value is 0
words = ["apple", "banana", "apple", "cherry"]

for word in words:
    word_counts[word] += 1  # No KeyError on first access!

print(dict(word_counts))  # {'apple': 2, 'banana': 1, 'cherry': 1}

2. Counter

A dict subclass for counting hashable objects. It comes with powerful utility methods.

from collections import Counter

# Instant frequency analysis
counts = Counter("mississippi")
print(counts.most_common(2))  # [('i', 4), ('s', 4)]

# Math with counters
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)
print(c1 + c2)  # Counter({'a': 4, 'b': 3})

3. deque (Double-Ended Queue)

Lists are optimized for fixed-length operations. Inserting at the beginning list.insert(0, x) is slow (O(n)).deque is optimized for O(1) appends and pops from both ends.