2. Reference Counting and Garbage Collection

Every object in Python has a reference count: a number that indicates how many references point to that object.

import sys
a = []
b = a
print(sys.getrefcount(a)) # Usually 3: a, b, and argument to getrefcount

• When the reference count drops to zero, the memory is deallocated.
• This is the primary mechanism for memory management.

Reference counting is a technique used by Python to manage memory. Each object in Python keeps track of how many references point to it through a reference count. When you create a new object, like an empty list in our example, its reference count increases by one for each variable or input that refers to it. In the example provided, both 'a' and 'b' reference the list, hence the reference count is 3 (including the internal reference made by the function getting the reference count). Once the references to the object drop to zero, meaning no part of the program is using it anymore, Python automatically frees the memory associated with that object.

Imagine a library where each book (object) has a counter (reference count) that tracks how many people have checked it out (references). If everyone returns the book, the counter drops to zero, and the library can remove it from the shelf (deallocate memory). If someone continues to check it out, the book remains on the shelf.

Reference counting fails when there are circular references (objects referring to each other), which keep each other alive.

import gc
class Node:
    def __init__(self):
        self.ref = self
a = Node()
del a # This won't immediately free memory
gc.collect() # Forces a garbage collection cycle

• Python’s gc module handles cyclic references.
• The garbage collector periodically scans for unreachable objects in cycles.

Cyclic garbage collection addresses a notable limitation of reference counting: circular references. A circular reference occurs when two or more objects reference each other, preventing their reference counts from ever reaching zero. In the provided code, when we create an instance of 'Node', it references itself, forming a cycle. Even if we delete the reference to 'a', the reference count does not become zero because the instance still refers to itself. The garbage collector, managed by the 'gc' module, identifies these cycles and clears the memory periodically by scanning for objects that can no longer be accessed, enabling Python to reclaim memory effectively.

Think of a group of friends who each keep in touch with one another. If Friend A calls Friend B, and Friend B calls Friend A back, they are in a loop of communication. If neither makes a new friend (loses contact with someone), they remain connected indefinitely. The garbage collector acts like a mediator who comes in, evaluates the situation, and determines that they can both move on and disconnect if they are not communicating with anyone else.

--