Python supports automatic garbage collection

Python supports automatic garbage collection Tutorial: The garbage collection is used in object-orientated programming and creates all kinds of objects. We need to store the computer’s memory in most programs never delete them. You can create thousands of objects with all these objects hold space in your computer’s memory. They will not manage all that memory manually, meet memory management. Python will handle objects by keeping a count to the references each object has in the program. Each object will store how many times it is referenced in the program. The count is updated with the program runtime and the time reaches zero. The memory for the object can be reclaimed and be free by the interpreter. Python’s memory allocation and deallocation method is that is automatic. The user doesn’t have to preallocate or deallocate memory similar to using dynamic memory allocation in languages such as C or C++.

Python uses two strategies for memory allocation:-

Reference counting
Garbage collection

The Python interpreter is used reference counting for memory management.
When reference to object is removed the reference count for an object is decremented.
And when the reference count becomes zero, the object is deallocated.

Example:-

B=9
B=4
The value 9 is an object and the reference count of object 9 is incremented to 1 inline 1.
Then at line 2, the reference count will become zero as it is dereference.
The garbage collector deallocates the object.
Reference cycles will involve lists, tuples, instances, classes, dictionaries, and functions are common.
For creating a reference cycle,
   def create_cycle ():
   x = [ ]
   x.append(x)
   create_cycle ()
Here the create_cycle () will create an object x which refers to itself and the object x will not be freed when the function returns.
It causes the memory that x is using to be held onto until the Python garbage collector is invoked.

Functions:-

Gc.enable ():-it enables automatic garbage collection.
Gc.disable ():-also disable automatic garbage collection and heap memory can still be the garbage collection can still be initiated using the gc.collect ().
Gc.collect ():-it runs a garbage collection.
Gc.mean_alloc ():-also return the number of bytes of heap RAMS that is allocated.
Gc.mem_free ():-Return the number of bytes of heap RAM or -1.

Garbage Collection in Python:-

The python language will support garbage collection that means it takes care of the memory for you.
In some programming languages, you have to clean objects yourself as c, c++, etc.
Here you can delete the objects manually if you want and clean up your computer memory.
Here to delete an object you can use the del keyword.
Del my_object
Here if object doesn’t exists, you get the error as,
>>>del my_object
Traceback(most recent call last):
File”<stdin>”,line1,in<module>
NameError:name’my_object’is not defined
>>>
Output:-
3
Teaceback(most recent call last):
File”t.py”,line 5,in<module>
Print(x)
NameError:name’x’ is not defined
In the first two lines of program the object is known and after deletion object x cannot be printed.
The garbage collection we automated completely.
The del () destructor is called before the object is destroyed.
x = []
x.append (l)
x.append (2)
The list for reference count is created now and it cannot be reached from inside Python.

Automatic Garbage Collection of Cycles:-

Python schedule garbage collection that is based upon a threshold of object allocations and object deallocations.
Example:-
import gc
print ("Garbage collection thresholds:",
gc.get_threshold ())
Output:-
Garbage collection thresholds (700, 10, 10)

Manual Garbage Collection:-

The garbage collection can be invoked manually as,
import gc
  i = 0
def create_cycle ():
            x = { }
            x[i+1] = x
            print x
                       collected = gc.collect ()
                       print "Garbage collector: collected %d objects." % (collected)
                       print "Creating cycles..."
                       for i in range (10):
                     create_cycle ()
                     collected = gc.collect ()
                     print "Garbage collector: collected %d objects." % (collected)
Output:-
Garbage collector: collected 0 objects.
Creating cycles...
{1: {...}}
{2: {...}}
{3: {...}}
{4: {...}}
{5: {...}}
{6: {...}}
{7: {...}}
{8: {...}}
{9: {...}}
{10: {...}}
Garbage collector: collected 10 objects.
There are two ways of performing manual garbage collection:-