No history yet

Python Memory Architecture

Variables as Pointers

In many programming languages, a variable is like a box where you store a value. If you assign a new value, you're replacing the contents of the box. Python thinks about this differently.

In Python, variables aren't boxes. They're more like labels or signposts that point to objects in your computer's memory. The object itself holds the value, its type, and other information.

Python's variables aren't buckets that contain things; they're pointers that reference objects.

This is because in Python, everything is an object. A number, a string of text, a list, even a function—they are all objects living in memory. Each object has three key components:

  • ID: A unique number that identifies the object, which is its memory address.
  • Type: The kind of object it is (e.g., integer, string, list).
  • Value: The actual data the object holds.

Identity vs Equality

Since variables just point to objects, we need a way to check two things: do two variables point to the exact same object, or do they point to different objects that happen to have the same value?

Python gives us two different operators for this:

  • == checks for equality. It asks, "Do these two objects have the same value?"
  • is checks for identity. It asks, "Do these two variables point to the very same object in memory?"
a = [1, 2, 3]
b = [1, 2, 3]
c = a

# Check for equality (value)
print(a == b)  # True, because their contents are the same

# Check for identity (same object in memory)
print(a is b)  # False, they are two separate list objects
print(a is c)  # True, because c is just another label for the object a points to

Here, a and b are separate lists that look identical, so a == b is true. But they exist in different memory locations, so a is b is false. However, c was assigned directly from a, so both variables now point to the exact same list object.

How Python Manages Memory

So where do all these objects live? Python doesn't just throw them into your computer's general memory. It manages its own private area called the Python private heap.

This heap is a dedicated space where all Python objects and data structures are stored. Python's memory manager is in charge of this space, handling when to create objects and, importantly, when to get rid of them.

To decide when an object can be removed, Python primarily uses a technique called reference counting.

An object's reference count is the number of variables (or labels) currently pointing to it.

When you create an object by assigning it to a variable, its reference count becomes 1. If you assign another variable to that same object, the count goes up to 2.

a = "hello" # "hello" object created, ref count is 1. b = a # ref count of "hello" is now 2.

If a variable is reassigned to point somewhere else, the original object's reference count decreases.

b = "world" # ref count of "hello" drops to 1.

When an object's reference count drops to zero, it means nothing is pointing to it anymore. The Python memory manager sees this and knows it's safe to remove the object from the heap, freeing up that memory. This automatic process is known as garbage collection.

Quiz Questions 1/6

In Python, which of the following is the most accurate analogy for a variable?

Quiz Questions 2/6

What is the primary purpose of the is operator in Python?

Understanding this object-based memory model is key to writing efficient and bug-free Python code, especially when you start working with large, complex data.