Extending parent behavior in Python - Step-by-Step Execution

Concept Flow - Extending parent behavior

Define Parent class with method

↓

Define Child class overriding method

↓

Inside Child method: call super().method()

↓

Execute Parent method code

↓

Execute Child additional code

↓

Return/Finish

This flow shows how a child class method calls the parent class method first, then adds its own behavior.

Execution Sample

Python

class Parent:
    def greet(self):
        print("Hello from Parent")

class Child(Parent):
    def greet(self):
        super().greet()
        print("Hello from Child")

c = Child()
c.greet()

This code shows a child class calling the parent class greet method, then adding its own message.

Execution Table

Step	Action	Evaluation	Output
1	Create instance c of Child	c is Child object
2	Call c.greet()	Calls Child.greet()
3	Inside Child.greet(), call super().greet()	Calls Parent.greet()	Hello from Parent
4	After super().greet(), print Child message	Prints additional message	Hello from Child
5	Method ends	Return None

💡 Method finishes after printing both messages

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 5
c	undefined	Child instance created	Method greet called on c	Method greet finished

Key Moments - 2 Insights

Why do we use super().greet() inside the Child class method?

Using super().greet() calls the Parent class method first, so we keep the original behavior before adding new code, as shown in execution_table step 3.

What happens if we don't call super().greet() in the Child method?

The Parent's greet method won't run, so only the Child's message prints. This is because the Child method fully overrides the Parent method (see execution_table step 2).

Visual Quiz - 3 Questions

Look at the execution_table, what is printed at step 3?

A "Hello from Parent"

B "Hello from Child"

C Nothing is printed

D An error occurs

💡 Hint

Check the Output column at step 3 in the execution_table

At which step does the Child class add its own message?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the Action and Output columns for step 4 in the execution_table

If we remove super().greet() call, what changes in the output?

A Only "Hello from Parent" prints

B Both messages print as before

C Only "Hello from Child" prints

D No messages print

💡 Hint

Refer to key_moments explanation about skipping super() call

Concept Snapshot

Extending parent behavior:
- Use super().method() inside child method
- Calls parent method first
- Then add child-specific code
- Keeps parent behavior plus new features
- Avoids rewriting parent code

Full Transcript

This example shows how a child class method can extend the behavior of its parent class method by calling super().method(). First, the child method calls the parent method to run its code, then it adds its own code. The execution table traces each step: creating the child instance, calling the child method, calling the parent method inside it, printing both messages, and finishing. Key points include why super() is used to keep parent behavior and what happens if it is omitted. The visual quiz tests understanding of the output at each step and the effect of removing the super() call.