Python - Memory Layout

Memory Layout in Python

Introduction

Memory layout in Python refers to the way objects, variables, and data structures are stored and accessed in memory. Understanding memory layout is crucial for optimizing performance, reducing memory usage, and writing efficient Python code, particularly for large-scale data processing, numerical computations, and low-level system interaction.

This detailed document explores how Python handles memory allocation and layout internally, with emphasis on:

• Python’s object model
• Built-in data types memory behavior
• Memory management techniques
• Garbage collection
• Memory profiling tools
• NumPy memory layout (C vs Fortran order)
• Memory views and buffer protocol

Python Object Model and Memory

Everything is an Object

In Python, everything is an object — including integers, strings, functions, and even classes. Every object is an instance of some class, with metadata, type info, and data stored in memory.

Memory Structure of an Object

Each Python object consists of:

• Reference count (for garbage collection)
• Type pointer (pointer to object’s type/class)
• Data fields (actual data)

Using sys.getsizeof()

import sys

x = 10
print("Size of int object:", sys.getsizeof(x))

s = "Hello"
print("Size of string object:", sys.getsizeof(s))

Memory Layout of Built-in Types

Integers

Python integers are objects, not just raw binary data. They include additional metadata which makes them significantly larger than a C int.

import sys

a = 100
print(sys.getsizeof(a))  # 28 bytes in most systems

Lists

Python lists are dynamic arrays of object references. Each element is a pointer to a separate object.

lst = [1, 2, 3, 4, 5]
print(sys.getsizeof(lst))  # size of list container

Tuples

Tuples are like lists but immutable and slightly more memory efficient.

tup = (1, 2, 3)
print(sys.getsizeof(tup))

Dictionaries

Dictionaries use a hash table internally, which grows dynamically. Keys and values are stored as references.

my_dict = {'a': 1, 'b': 2}
print(sys.getsizeof(my_dict))

Reference Counting and Garbage Collection

Reference Counting

Python uses reference counting to track memory usage. An object is deleted when its reference count drops to zero.

import sys

x = [1, 2, 3]
print(sys.getrefcount(x))

Garbage Collection

Python also includes a cyclic garbage collector to handle reference cycles.

import gc

print("Garbage collector thresholds:", gc.get_threshold())
gc.collect()  # Manually invoke garbage collector

Dynamic Typing and Memory Impact

Variable Rebinding

a = 10
b = a  # b points to the same int object
a = 20  # a now points to a new int object

Immutability

Immutable types (like int, str, tuple) are not changed in-place, which can lead to more memory allocation than expected.

Memory Efficiency with Generators

Using Generators

def gen():
    for i in range(1000000):
        yield i

g = gen()
print(next(g))

List vs Generator Memory

import sys

lst = [x for x in range(1000000)]
gen = (x for x in range(1000000))

print("List size:", sys.getsizeof(lst))
print("Generator size:", sys.getsizeof(gen))

NumPy Memory Layout

Contiguous Memory

NumPy arrays store data in contiguous blocks of memory, enabling vectorized operations and efficient access.

C vs Fortran Order

import numpy as np

a = np.array([[1, 2], [3, 4]], order='C')
b = np.array([[1, 2], [3, 4]], order='F')

print("C-order strides:", a.strides)
print("F-order strides:", b.strides)

Viewing Memory Layout

a = np.array([[1, 2], [3, 4]])
print(a.flags)

Strides in NumPy

Understanding Strides

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Shape:", arr.shape)
print("Strides:", arr.strides)

Using strides for slicing

print(arr[::2, ::2])

Memory Views and Buffer Protocol

Memory Views

Memory views provide a way to access memory without copying data. Useful for binary I/O and NumPy interfacing.

data = bytearray(b"abcdef")
view = memoryview(data)
print(view[0])

Modifying via Memory View

view[0] = 65
print(data)

Array Copying and Views

Shallow Copy (View)

arr = np.array([1, 2, 3])
view = arr.view()
view[0] = 100
print(arr)  # Changed

Deep Copy

arr = np.array([1, 2, 3])
copy = arr.copy()
copy[0] = 100
print(arr)  # Not changed

Memory Profiling and Optimization

Using memory_profiler

from memory_profiler import profile

@profile
def my_func():
    a = [0] * 1000000
    return a

my_func()

Using tracemalloc

import tracemalloc

tracemalloc.start()
a = [0] * 1000000
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

for stat in top_stats[:5]:
    print(stat)

Built-in Tools for Introspection

dir() and __sizeof__()

class MyClass:
    def __init__(self):
        self.data = [1] * 1000

obj = MyClass()
print(obj.__sizeof__())

Shared Memory and Multiprocessing

Shared Arrays

from multiprocessing import Array

arr = Array('i', [1, 2, 3, 4])
print(arr[:])

Best Practices for Memory Optimization

• Use built-in data structures efficiently (e.g., set vs list)
• Use generators instead of lists where possible
• Use memoryview for binary data manipulation
• Use NumPy arrays for large numerical datasets
• Profile memory usage regularly
• Use appropriate data types (e.g., int8 vs int64)

Advanced: Memory Mapping with NumPy

Memory Mapping Large Files

data = np.memmap('data.dat', dtype='float32', mode='w+', shape=(1000, 1000))
data[:] = np.random.rand(1000, 1000)
data.flush()

Reading Back with Memory Mapping

data = np.memmap('data.dat', dtype='float32', mode='r', shape=(1000, 1000))
print(data[0, 0])

Understanding memory layout in Python is crucial for building performant and memory-efficient applications. From the object model to NumPy's contiguous memory buffers and the use of views and the buffer protocol, Python provides a rich set of tools for managing memory explicitly or implicitly.

Armed with this knowledge, developers can write high-performance code, diagnose memory bottlenecks, and work confidently with large data. Whether you're writing numerical algorithms with NumPy or handling binary files, memory layout understanding is a critical skill in advanced Python programming.