In this blog post, we will explore in depth the memory management and garbage collection (GC) mechanisms in Python. Understanding these concepts is crucial for writing efficient and reliable Python code, especially when dealing with large amounts of data and high-load applications. We will start with the basics of Python memory management, delve into the workings of garbage collection, and demonstrate through practical code examples how to optimize memory usage in Python programs.

1. Python's Memory Management Mechanisms

As a high-level scripting language that combines interpretive, compiled, interactive, and object-oriented aspects, Python is unique among programming languages. In Python, variables do not need to be declared in advance, nor do they require a specified type. Programmers do not need to manage memory, as the Python interpreter automates this with garbage collection. Developers need not be overly concerned with the memory management mechanisms, as these are fully handled by the Python memory manager.

Python's memory management can be broken down into several key components:

• Memory Allocator: Python uses its own internal memory allocator to manage the allocation of objects in heap memory.
• Memory Pool: Python provides a memory pool for small objects (especially integers and short strings), which are frequently created and destroyed. By reusing these objects, Python significantly reduces the overhead of memory allocations.

1. Why Introduce a Memory Pool?

One of the design goals of Python, a high-level programming language, is to simplify memory management. The introduction of memory pools primarily addresses performance issues caused by the frequent allocation and deallocation of small memory blocks. Without a memory pool, each allocation and recycling of a small object would require a system call involving the operating system's memory manager, which is very time-consuming. The use of memory pools offers several advantages:

• Improved Memory Allocation Efficiency: By reusing already allocated memory blocks, the number of system calls is reduced, thereby accelerating the speed of memory allocation.
• Reduced Memory Fragmentation: Frequent allocation and deallocation of small objects can easily lead to memory fragmentation. Memory pools mitigate this issue by managing a continuous area of memory.
• Lowered Memory Management Overhead: Centralized management of the allocation and release of a group of small objects reduces memory management overhead and improves the overall performance of the program.

2. How Does the Memory Pool Work?

The implementation of the memory pool in Python is managed through a system called "blocks." The memory pool in Python is primarily implemented by Python's interpreter-level memory manager, such as Pymalloc, which works as follows:

• Creation of Memory Pools: When Python starts, it pre-allocates a large block of memory, which is divided into multiple fixed-size blocks. Each block is typically a multiple of the memory required by small objects.
• Allocation of Objects: When a program creates a small object, the interpreter checks if there are enough free blocks in the memory pool. If so, it directly allocates a block to this object from the pool, instead of requesting new memory from the operating system.
• Memory Recycling and Reuse: When an object is no longer used, its occupied memory block is not immediately returned to the operating system but is marked as available and retained in the memory pool. This block can then be reallocated to new objects.

Python's memory management is layered, with different layers using different memory allocation mechanisms. Let's take a look at the memory architecture of CPython:

Python's object management mainly occurs from Level+1 to Level+3.

Level+3: For Python's built-in objects (such as int, dict, etc.), each has a separate private memory pool, and the memory pools between objects are not shared, meaning the memory released by an int will not be allocated to a float.

Level+2: When the requested memory size is less than 256KB, memory allocation is mainly carried out by Python’s object allocator.

Level+1: When the requested memory size is greater than 256KB, allocation is carried out by Python's native memory allocator, essentially calling functions like malloc/realloc from the C standard library.

Let's look at some examples. For instance, Python uses a special optimization strategy for small integers and short strings. These objects are often created and destroyed frequently, so by using memory pool technology, Python pre-creates a range of these objects and continually reuses them, thereby avoiding frequent memory allocations and recycling.

Example: Observing Reuse of Small Integer Objects

# Python pre-creates and stores integers between -5 and 256 in the memory pool
a = 100
b = 100
print(a is b)  # Outputs True, indicating that both variables point to

 the same object in the memory pool

c = 300
d = 300
print(c is d)  # Outputs False, integers outside this range do not use the memory pool and are independently created

2. Python's Garbage Collection

Python's garbage collection (GC) is a key internal mechanism used to automatically free memory that is no longer in use. This mechanism primarily relies on reference counting to manage memory, supplemented by a more complex method—Generational Garbage Collection—to handle circular references and other issues that are difficult to resolve through reference counting alone. Below, we will detail these two mechanisms and their working principles.

1. Reference Counting

The most basic garbage collection technique in Python is reference counting. This is a simple and intuitive method of memory management, where:

• Reference Counting Mechanism: Each object has a reference counter that increases when the object is referenced and decreases when a reference is removed.
• Memory Release: When an object's reference count drops to zero, meaning no references are pointing to it, Python automatically frees the memory occupied by that object.

Flaws of Reference Counting

Despite its efficiency, reference counting has clear drawbacks. Its major problem is that it cannot handle circular references:

a = []
b = [a]
a.append(b)

# At this point, a and b reference each other. Even if they are no longer referenced by other objects, their reference counts will not drop to zero.

To address the issue of circular references, Python introduced a second-tier garbage collection mechanism: Generational Recycling.

2. Generational Recycling

Generational recycling is an advanced garbage collection strategy based on the observation that in most programs, the lifetimes of objects vary greatly. Some objects are quickly no longer needed, while others may persist throughout the runtime of the program. Python's generational recycling places objects into three "generations" (commonly referred to as generation 0, 1, and 2), with newly created objects initially placed in generation 0.

• Promotion of Objects: Each time garbage collection occurs in a generation, surviving objects are moved to the next generation. Each generation has a lower frequency of garbage collection than the previous one, reducing the inspection frequency for long-lived objects and thereby increasing efficiency.
• Detection of Circular References: Python uses a "mark-sweep" algorithm to detect and recycle objects with circular references. During garbage collection, the garbage collector marks all objects that can be reached from the root set (such as global namespaces, call stacks, etc.). Unreachable objects are considered garbage.

Example Code: Manually Triggering Garbage Collection

import gc

# Create objects
a = {}
b = {}
a['b'] = b
b['a'] = a

# Remove references
del a
del b

# Manually trigger garbage collection
collected = gc.collect()
print(f"Number of objects collected: {collected}")
print(f"Garbage collector: {gc.garbage}")