But you would be wrong, my friend. Python may handle memory allocation automatically for us, but it doesn’t mean we can just sit back and let the magic happen without any understanding of what’s going on behind the scenes. In fact, having a basic grasp of Python’s memory management is crucial to designing efficient applications that don’t run out of memory or crash due to memory leaks. First how does Python allocate memory for objects? Well, it uses something called an object allocator.

This is essentially a function that takes care of finding available memory in the heap (the part of RAM used by dynamic data structures like arrays and linked lists) and assigning it to new objects as they are created. Python has two main types of object allocators: the small object allocator and the large object allocator. The small object allocator handles objects that fit into a single page (typically 4KB on modern systems), while the large object allocator is responsible for larger objects. The small object allocator uses a technique called “buddy memory allocation” to allocate contiguous blocks of memory.

This involves dividing the available heap space into fixed-size chunks, and then assigning them to objects as needed. When an object is freed up (i.e., no longer in use), its chunk is merged with another nearby chunk to create a larger block that can be used for future allocations. The large object allocator, on the other hand, uses a technique called “slab allocation” to allocate memory for objects that are too big to fit into a single page. This involves dividing the available heap space into fixed-size slabs (typically 1MB or more), and then assigning them to objects as needed.

When an object is freed up, its slab is marked as “available” and can be used for future allocations. Now that we understand how Python allocates memory, deallocation aka garbage collection. Unlike C or other low-level languages, Python doesn’t require us to explicitly free up memory when we’re done with it. Instead, Python uses a technique called “garbage collection” to automatically reclaim unused memory.

Python has two main types of garbage collectors: the reference counting collector and the cyclic garbage collector (also known as the mark-and-sweep collector). The reference counting collector keeps track of how many references each object has, and frees up an object when its reference count drops to zero. The cyclic garbage collector, on the other hand, is used for objects that have circular references (i.e., they refer to each other in a cycle). This can cause problems with traditional reference counting collectors because they don’t know how to handle cycles if object A refers to object B, and object B refers back to object A, then their reference counts will never drop to zero! To solve this problem, the cyclic garbage collector uses a technique called “mark-and-sweep” to identify objects that are no longer in use.

This involves marking all reachable objects (i.e., those that can be reached from a starting point), and then sweeping up any unreachable objects (i.e., those that aren’t marked). Of course, this is just scratching the surface there are many more details to explore if you want to dive deeper into the world of Python internals. But for now, let’s raise a glass (or mug) to efficient and memory-friendly code!