Object lifecycle overview in Python

Introduction

Objects in Python go through a life from creation to removal. Understanding this helps you manage memory and program behavior better.

When you want to know how and when your data is stored and removed.

When you need to clean up resources like files or network connections.

When debugging why some objects still use memory.

When learning how Python manages your program's data automatically.

Syntax

Python

class ClassName:
    def __init__(self):
        # called when object is created
        pass
    def __del__(self):
        # called when object is about to be destroyed
        pass

__init__ is the constructor method called when an object is created.

__del__ is the destructor method called when an object is about to be removed.

Examples

This creates a Car object and prints messages when created and destroyed.

Python

class Car:
    def __init__(self):
        print('Car created')
    def __del__(self):
        print('Car destroyed')

my_car = Car()

Shows how to pass data when creating an object and track its lifecycle.

Python

class Book:
    def __init__(self, title):
        self.title = title
        print(f'Book "{self.title}" created')
    def __del__(self):
        print(f'Book "{self.title}" destroyed')

novel = Book('Python Guide')

Sample Program

This program creates a Person object, does some work, then deletes the object explicitly to show the destruction message.

Python

class Person:
    def __init__(self, name):
        self.name = name
        print(f'Person {self.name} created')
    def __del__(self):
        print(f'Person {self.name} destroyed')

p = Person('Alice')
print('Doing some work...')
del p
print('End of program')

Important Notes

Python automatically removes objects when no references point to them.

The __del__ method is not guaranteed to run immediately when you delete an object.

Use del to remove references, but Python's garbage collector decides when to free memory.

Summary

Objects are created with __init__ and destroyed with __del__.

Understanding object lifecycle helps manage resources and memory.

Python handles most cleanup automatically, but you can control it when needed.

Practice

1. What is the first step in the lifecycle of a Python object?

easy

A. Creation of the object in memory

B. Deletion of the object

C. Garbage collection

D. Assignment of a variable

Solution

1. Step 1: Understand object lifecycle start

   The lifecycle of a Python object begins when it is created in memory.

2. Step 2: Differentiate from other lifecycle stages

   Deletion and garbage collection happen later, after creation and use.

3. Final Answer:

   Creation of the object in memory -> Option A

4. Quick Check:

   Object lifecycle starts with creation [OK]

Hint: Object lifecycle always starts with creation [OK]

Common Mistakes:

• Confusing creation with deletion
• Thinking garbage collection happens first
• Assuming variable assignment is the first step

2. Which of the following is the correct syntax to define a destructor method in a Python class?

easy

A. def destructor(self):

B. def __del__(self):

C. def delete(self):

D. def __destroy__(self):

Solution

1. Step 1: Recall destructor method name

   In Python, the destructor method is named __del__ with double underscores before and after.

2. Step 2: Check syntax correctness

   The correct syntax is def __del__(self): which matches Python's special method naming.

3. Final Answer:

   def __del__(self): -> Option B

4. Quick Check:

   Destructor method = __del__ [OK]

Hint: Destructor method is always named __del__ [OK]

Common Mistakes:

• Using wrong method names like destructor or delete
• Missing double underscores
• Confusing with constructor __init__

3. What will be the output of the following code?

class MyClass:
    def __init__(self):
        print('Created')
    def __del__(self):
        print('Deleted')

obj = MyClass()
print('Object in use')
del obj
print('End')

medium

A. Created\nObject in use\nDeleted\nEnd

B. Created\nDeleted\nObject in use\nEnd

C. Object in use\nCreated\nDeleted\nEnd

D. Created\nObject in use\nEnd

Solution

1. Step 1: Trace object creation and constructor call

   When obj = MyClass() runs, __init__ prints 'Created'.

2. Step 2: Follow print and deletion order

   Next, 'Object in use' prints. Then del obj calls __del__, printing 'Deleted'. Finally, 'End' prints.

3. Final Answer:

   Created\nObject in use\nDeleted\nEnd -> Option A

4. Quick Check:

   Constructor then prints, then destructor after del [OK]

Hint: Destructor runs only after del or object goes out of scope [OK]

Common Mistakes:

• Assuming destructor runs immediately after creation
• Ignoring order of print statements
• Thinking del obj skips destructor

4. Identify the error in this code related to object lifecycle:

class Sample:
    def __init__(self):
        print('Init called')
    def __del__(self):
        print('Del called')

obj = Sample()
obj = None
print('Done')

medium

A. Destructor __del__ will not be called because obj is set to None

B. Syntax error in class definition

C. No error; destructor will be called when obj is set to None

D. Constructor __init__ will not be called

Solution

1. Step 1: Understand what happens when obj is set to None

   Setting obj = None removes the reference to the Sample object, so it becomes eligible for garbage collection.

2. Step 2: Confirm destructor call behavior

   When no references remain, __del__ is called, so 'Del called' will print before 'Done'.

3. Final Answer:

   No error; destructor will be called when obj is set to None -> Option C

4. Quick Check:

   Destructor runs when object has no references [OK]

Hint: Destructor runs when last reference is removed [OK]

Common Mistakes:

• Thinking setting variable to None skips destructor
• Confusing syntax errors with lifecycle behavior
• Assuming constructor is skipped

5. Given a list of objects created inside a function, when will their destructors be called?

class Item:
    def __init__(self, name):
        self.name = name
        print(f'Created {name}')
    def __del__(self):
        print(f'Deleted {self.name}')

def create_items():
    items = [Item('a'), Item('b'), Item('c')]
    print('Items created')

create_items()
print('Function ended')

hard

A. Destructors called immediately after 'Items created' inside the function

B. Destructors called before 'Items created'

C. Destructors never called because list holds references

D. Destructors called after 'Function ended' when function scope ends

Solution

1. Step 1: Analyze object references inside function

   Objects are stored in the list 'items' inside create_items(). They exist until the function ends.

2. Step 2: Determine when objects lose references

   When create_items() finishes, 'items' list is destroyed, removing references to objects, triggering destructors.

3. Step 3: Confirm output order

   So, 'Items created' prints, then function ends, then destructors print, then 'Function ended' prints.

4. Final Answer:

   Destructors called after 'Function ended' when function scope ends -> Option D

5. Quick Check:

   Objects destroyed after function scope ends [OK]

Hint: Objects destroyed when last reference goes out of scope [OK]

Common Mistakes:

• Thinking destructors run immediately after creation
• Assuming list keeps objects alive forever
• Confusing print order with destructor timing