CPython Internals: Memory Management, GC, and __slots__ in Python0%

Project: Vector Class with Overloaded Operators

CPython Internals: Memory Management, GC, and slots in Python

Advanced11 min read•Updated: 2026-10-23

🐍 CPython Internals: Memory Management, GC, and slots

To write high-performance Python systems handling millions of records, you must understand how the default CPython runtime allocates, manages, and reclaims memory.

🧮 1. Primary Mechanism: Reference Counting

CPython's fundamental memory management mechanism is Reference Counting:

Every Python object has an internal ob_refcnt field.
When a variable or container references the object, the count increments.
When a reference goes out of scope or is deleted with del, the count decrements.
As soon as ob_refcnt == 0, memory is immediately deallocated!

1import sys
2 
3x = [1, 2, 3]
4# Note: sys.getrefcount() temporarily creates 1 additional reference as an argument:
5print(sys.getrefcount(x)) # 2 (variable 'x' + getrefcount parameter)
6 
7y = x
8print(sys.getrefcount(x)) # 3
9 
10del y
11print(sys.getrefcount(x)) # 2

🔄 2. The Cyclic Garbage Collector (`gc` module)

Reference counting has one critical flaw: Cyclic References (when Object A points to Object B, and Object B points back to Object A). Even if all external references are deleted, their internal reference counts never drop to 0!

To prevent memory leaks from cycles, Python includes a Generational Garbage Collector that runs periodically:

It tracks container objects across 3 generations (Gen 0, Gen 1, Gen 2).
Young objects start in Gen 0; survivors of collection cycles are promoted.

1import gc
2 
3class Node:
4    def __init__(self, val):
5        self.val = val
6        self.neighbor = None
7 
8# Create a cyclic reference:
9a = Node("A")
10b = Node("B")
11a.neighbor = b
12b.neighbor = a
13 
14del a
15del b  # Neither reference count is zero due to cyclic mutual reference!
16 
17# Force an immediate full garbage collection run:
18unreachable = gc.collect()
19print(f"Reclaimed {unreachable} cyclic objects from memory.")

🚀 3. Massive Memory Savings with `slots`

By default, every Python class instance maintains an internal __dict__ to allow dynamic attribute assignment. While flexible, this dictionary consumes substantial memory overhead (typically 150–200 bytes per instance).

When instantiating millions of objects (such as financial records or coordinates), defining __slots__ eliminates the __dict__, storing attributes in a compact C-level array:

1class StandardPoint:
2    def __init__(self, x: float, y: float):
3        self.x = x
4        self.y = y
5 
6class SlottedPoint:
7    __slots__ = ("x", "y") # Fixes allowed attributes, eliminates __dict__
8    def __init__(self, x: float, y: float):
9        self.x = x
10        self.y = y
11 
12p_standard = StandardPoint(10.0, 20.0)
13p_slotted = SlottedPoint(10.0, 20.0)
14 
15print(hasattr(p_standard, "__dict__")) # True
16print(hasattr(p_slotted, "__dict__"))  # False (Saves ~60% RAM!)
17 
18# ❌ AttributeError: 'SlottedPoint' object has no attribute 'z'
19# p_slotted.z = 30.0

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What is the primary, immediate memory reclamation mechanism in CPython?

Question 2

Why does Python need the gc module in addition to reference counting?

Question 3

How many generations are used in Python's cyclic garbage collector?

Question 4

What is the primary performance benefit of defining __slots__ in a class?

Question 5

What happens when you attempt to assign an attribute not listed in __slots__ to a slotted instance?

🚀 What's Next?

In the next lesson, we will combine our magic method mechanics to build Project: Vector Class with Overloaded Operators (2: Magic Methods & Operator Overloading).

👉 Continue to Next Lesson: Project: Vector Class with Overloaded Operators →

Next Lesson

Project: Vector Class with Overloaded Operators

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Customizing Classes with Magic Methods	Project: Vector Class with Overloaded Operators

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Project: Vector Class with Overloaded Operators

CPython Internals: Memory Management, GC, and slots in Python

Advanced11 min read•Updated: 2026-10-23

Study Materials Cheatsheet

🐍 CPython Internals: Memory Management, GC, and slots

To write high-performance Python systems handling millions of records, you must understand how the default CPython runtime allocates, manages, and reclaims memory.

🧮 1. Primary Mechanism: Reference Counting

CPython's fundamental memory management mechanism is Reference Counting:

Every Python object has an internal ob_refcnt field.
When a variable or container references the object, the count increments.
When a reference goes out of scope or is deleted with del, the count decrements.
As soon as ob_refcnt == 0, memory is immediately deallocated!

1import sys
2 
3x = [1, 2, 3]
4# Note: sys.getrefcount() temporarily creates 1 additional reference as an argument:
5print(sys.getrefcount(x)) # 2 (variable 'x' + getrefcount parameter)
6 
7y = x
8print(sys.getrefcount(x)) # 3
9 
10del y
11print(sys.getrefcount(x)) # 2

🔄 2. The Cyclic Garbage Collector (`gc` module)

To prevent memory leaks from cycles, Python includes a Generational Garbage Collector that runs periodically:

It tracks container objects across 3 generations (Gen 0, Gen 1, Gen 2).
Young objects start in Gen 0; survivors of collection cycles are promoted.

1import gc
2 
3class Node:
4    def __init__(self, val):
5        self.val = val
6        self.neighbor = None
7 
8# Create a cyclic reference:
9a = Node("A")
10b = Node("B")
11a.neighbor = b
12b.neighbor = a
13 
14del a
15del b  # Neither reference count is zero due to cyclic mutual reference!
16 
17# Force an immediate full garbage collection run:
18unreachable = gc.collect()
19print(f"Reclaimed {unreachable} cyclic objects from memory.")

🚀 3. Massive Memory Savings with `slots`

When instantiating millions of objects (such as financial records or coordinates), defining __slots__ eliminates the __dict__, storing attributes in a compact C-level array:

1class StandardPoint:
2    def __init__(self, x: float, y: float):
3        self.x = x
4        self.y = y
5 
6class SlottedPoint:
7    __slots__ = ("x", "y") # Fixes allowed attributes, eliminates __dict__
8    def __init__(self, x: float, y: float):
9        self.x = x
10        self.y = y
11 
12p_standard = StandardPoint(10.0, 20.0)
13p_slotted = SlottedPoint(10.0, 20.0)
14 
15print(hasattr(p_standard, "__dict__")) # True
16print(hasattr(p_slotted, "__dict__"))  # False (Saves ~60% RAM!)
17 
18# ❌ AttributeError: 'SlottedPoint' object has no attribute 'z'
19# p_slotted.z = 30.0

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What is the primary, immediate memory reclamation mechanism in CPython?

Question 2

Why does Python need the gc module in addition to reference counting?

Question 3

How many generations are used in Python's cyclic garbage collector?

Question 4

What is the primary performance benefit of defining __slots__ in a class?

Question 5

What happens when you attempt to assign an attribute not listed in __slots__ to a slotted instance?

🚀 What's Next?

In the next lesson, we will combine our magic method mechanics to build Project: Vector Class with Overloaded Operators (2: Magic Methods & Operator Overloading).

👉 Continue to Next Lesson: Project: Vector Class with Overloaded Operators →

Next Lesson

Project: Vector Class with Overloaded Operators

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Customizing Classes with Magic Methods	Project: Vector Class with Overloaded Operators

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

🐍 CPython Internals: Memory Management, GC, and __slots__

🧮 1. Primary Mechanism: Reference Counting

🔄 2. The Cyclic Garbage Collector (gc module)

🚀 3. Massive Memory Savings with __slots__

Practice Quiz

🚀 What's Next?

Project: Vector Class with Overloaded Operators

Related Lessons

Practice Quiz

Loading Page Content...

🐍 CPython Internals: Memory Management, GC, and __slots__

🧮 1. Primary Mechanism: Reference Counting

🔄 2. The Cyclic Garbage Collector (gc module)

🚀 3. Massive Memory Savings with __slots__

Practice Quiz

🚀 What's Next?

Project: Vector Class with Overloaded Operators

Related Lessons

Practice Quiz

🐍 CPython Internals: Memory Management, GC, and slots

🔄 2. The Cyclic Garbage Collector (`gc` module)

🚀 3. Massive Memory Savings with `slots`

🐍 CPython Internals: Memory Management, GC, and slots

🔄 2. The Cyclic Garbage Collector (`gc` module)

🚀 3. Massive Memory Savings with `slots`