Object lifecycle overview in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the object lifecycle in Python?

The object lifecycle is the process an object goes through from creation, usage, and finally to destruction when it is no longer needed.

beginner

How is an object created in Python?

An object is created when a class is called like a function, which runs the <code>__new__</code> method to create the object and then the <code>__init__</code> method to initialize it.

beginner

What happens during the usage phase of an object?

During usage, the object’s methods and properties are accessed and modified as needed by the program.

intermediate

How does Python destroy an object?

Python destroys an object when its reference count drops to zero, triggering the __del__ method and freeing memory.

intermediate

What is the role of __del__ method in the object lifecycle?

The __del__ method is called when an object is about to be destroyed, allowing cleanup actions before memory is freed.

Which method is called when a new object is created in Python?

A __init__

B __del__

C __str__

D __call__

The __init__ method initializes a new object when it is created.

When does Python destroy an object?

A Immediately after creation

B When its reference count reaches zero

C When the program starts

D When __init__ is called

Python destroys objects when no references to them remain.

What is the purpose of the __del__ method?

A To clean up before the object is destroyed

B To initialize the object

C To print the object

D To copy the object

The __del__ method allows cleanup actions before the object is removed.

Which phase comes after object creation in the lifecycle?

A Destruction

B Initialization

C Garbage collection

D Usage

After creation, the object is used by the program.

What triggers the object destruction process?

A Calling __init__

B Calling __str__

C Reference count dropping to zero

D Assigning a new value

When no references remain, Python destroys the object.

Describe the main stages of an object's lifecycle in Python.

Think about what happens from when you make an object to when it disappears.

Explain how Python knows when to destroy an object.

Consider how Python tracks if an object is still 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