https://stackify.com/python-garbage-collection

Stackify: Python Garbage Collection

Each object in Python also comes with its own data value called a reference count. An object's reference count is increased each time it is referenced by other objects and decreased when a reference is removed. When an object's reference count reaches zero, it is deallocated from memory. Reference counting by itself is a somewhat limited and primitive way to manage memory, and doesn't catch all objects in need of deallocation. This is why it is paired with another garbage collection strategy.

Reference Counting

Sometimes objects have reference counts above 0, but no longer have references to it. These objects should be deallocated, but reference counting alone won't deallocate them. These are called unreachable objects. Garbage collectors will look for these unreachable objects and deallocate them.
Generational garbage collection runs under the assumption that most objects have a very short lifespan and can be deallocated shortly after creation. The older an object is, the less likely it is to become unreachable. This assumption is true for many Python programs. So, all objects are organized into three categories, referred to as generations. Garbage collection occurs separately for each generation and at different frequencies. All new objects start at generation 0 and if they survive a garbage collection that surveys generation 0, they are elevated to generation 1, which is surveyed less often. If they survive a garbage collection across generation 1, they move on to generation 2, which is the least surveyed.

Generational Garbage Collection

Some programming languages require that the programmer manually deallocate memory. However, Python does this automatically through the use of a garbage collector. In short, a garbage collector will deallocate memory for any objects that are deemed to be no longer necessary for the program. Python implements two strategies for garbage collection:
- Reference Counting
- Generational Garbage Collection

Saint Olaf College

In heap allocation, memory is allocated based on the Python code written. It is a pile of memory available for the program. All objects are stored in the heap memory. When an object is created, it is allocated in the heap memory while referencing information for it is stored in the stack allocation when necessary. Heap memory is also what allows for global variables. Since heap memory is more dependent on the program, and thus the programmer, it also also less safe than stack memory and has the potential to create a memory leak. If the heap memory ends up becoming completely full, the program can no longer run and will throw a specific error called an out of memory error. Memory deallocation in the heap memory requires the use of a garbage collector.

Heap Allocation

Geeks for Geeks is a website that offers information on a variety of programming languages, tips for coding interviews, and ideas for programming projects:  https://www.geeksforgeeks.org/python-programming-language/

Geeks for Geeks Python Programming Language

A memory leak is when memory is allocated in the heap memory, but is never deallocated. To avoid this, heap memory allocations should always be deallocated when no longer needed. When memory leaks are present, the available memory can shrink over time, slow down the performance of the program, and could eventually result in an out of memory error. While Python has a garbage collector to help prevent this, memory leaks can still happen in Python depending on the code.

Learn Before

Related

Learn After