Object lifecycle overview in Python - Step-by-Step Execution

Concept Flow - Object lifecycle overview

Create Object

→Initialize __init__

↓

Use Object

↓

Delete Object

→Call __del__

This flow shows how an object is created, initialized, used, and then deleted in Python.

Execution Sample

Python

class MyObject:
    def __init__(self):
        print('Object created')
    def __del__(self):
        print('Object deleted')
obj = MyObject()
del obj

This code creates an object, prints a message on creation, then deletes it and prints a message on deletion.

Execution Table

Step	Action	Evaluation	Result
1	Create object obj	Calls __init__	Prints 'Object created'
2	Object obj ready	Object exists in memory	No output
3	Delete object obj	Calls __del__	Prints 'Object deleted'
4	Object obj removed	No longer accessible	No output

💡 Object is deleted and memory is freed, lifecycle ends

Variable Tracker

Variable	Start	After Creation	After Deletion
obj	None	Reference to MyObject instance	No reference (deleted)

Key Moments - 3 Insights

Why do we see 'Object created' printed immediately after creating obj?

Because the __init__ method runs right after the object is created, as shown in execution_table step 1.

Does __del__ run immediately when we call del obj?

Yes, __del__ is called when the object is deleted, as shown in execution_table step 3, printing 'Object deleted'.

What happens if we try to use obj after deletion?

The object no longer exists (execution_table step 4), so using obj will cause an error.

Visual Quiz - 3 Questions

Look at the execution_table, what is printed when the object is created?

A 'Object created'

B 'Object deleted'

C Nothing

D 'Object ready'

💡 Hint

See execution_table step 1, the __init__ method prints 'Object created'.

At which step does the object get removed from memory?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Check execution_table step 4, it shows the object is no longer accessible.

If we remove the del obj line, what changes in the execution_table?

A Step 2 would be missing

B Step 1 would not happen

C Step 3 and 4 would not happen

D All steps remain the same

💡 Hint

Without del obj, __del__ is not called, so steps 3 and 4 do not occur.

Concept Snapshot

Object lifecycle in Python:
1. Creation calls __init__ to initialize.
2. Object is ready to use.
3. Deletion calls __del__ to clean up.
4. Object memory is freed after deletion.
Use del to delete objects explicitly.

Full Transcript

This visual trace shows the lifecycle of a Python object. First, the object is created, triggering the __init__ method which prints 'Object created'. Then the object exists and can be used. When we delete the object using del, the __del__ method runs and prints 'Object deleted'. Finally, the object is removed from memory and cannot be used anymore. Variables track the object's reference before and after creation and deletion. Key moments clarify why __init__ and __del__ run when they do, and what happens if we try to use the object after deletion. The quiz tests understanding of these steps by asking about printed messages and lifecycle stages.

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