Polymorphism through inheritance in Python - Step-by-Step Execution

Concept Flow - Polymorphism through inheritance

Define Base Class

↓

Define Derived Classes

↓

Create Objects of Derived Classes

↓

Call Same Method on Each Object

↓

Each Object Uses Its Own Method Version

↓

Output Respective Results

This flow shows how a base class defines a method, derived classes override it, and calling the method on different objects runs their own version.

Execution Sample

Python

class Animal:
    def sound(self):
        return "Some sound"

class Dog(Animal):
    def sound(self):
        return "Bark"

class Cat(Animal):
    def sound(self):
        return "Meow"

animals = [Dog(), Cat()]
for a in animals:
    print(a.sound())

This code creates a base class Animal and two derived classes Dog and Cat, each with their own sound method. It prints the sound of each animal.

Execution Table

Step	Action	Object	Method Called	Result	Output
1	Create Dog object	Dog instance	-	-	-
2	Create Cat object	Cat instance	-	-	-
3	Call sound() on Dog	Dog instance	Dog.sound()	"Bark"	Bark
4	Call sound() on Cat	Cat instance	Cat.sound()	"Meow"	Meow
5	End of loop	-	-	-	-

💡 All objects processed, loop ends.

Variable Tracker

Variable	Start	After 1	After 2	Final
animals	[]	[Dog()]	[Dog(), Cat()]	[Dog(), Cat()]
a	None	Dog instance	Cat instance	Cat instance

Key Moments - 2 Insights

Why does calling sound() on different objects print different results?

Because each derived class overrides the sound() method, so when called on an object, Python uses the method version of that object's class (see execution_table steps 3 and 4).

Is the base class method sound() ever called here?

No, because both Dog and Cat override sound(), so their versions are used instead (execution_table rows 3 and 4). If a derived class did not override it, the base class method would run.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output when sound() is called on the Dog object?

A Some sound

B Bark

C Meow

D Error

💡 Hint

Check execution_table row 3 where Dog.sound() returns 'Bark'.

At which step does the Cat object’s sound() method get called?

A Step 4

B Step 1

C Step 3

D Step 2

💡 Hint

Look at execution_table row 4 for Cat.sound() call.

If the Cat class did not have its own sound() method, what would be the output when calling sound() on a Cat object?

A Bark

B Meow

C Some sound

D Error

💡 Hint

Without override, the base class method runs, see key_moments explanation.

Concept Snapshot

Polymorphism through inheritance means derived classes can have methods with the same name as the base class.
When calling these methods on objects, Python runs the version from the object's class.
This lets different objects respond differently to the same method call.
Use method overriding in derived classes to customize behavior.
Call methods on base class references to get polymorphic behavior.

Full Transcript

This example shows polymorphism using inheritance in Python. We define a base class Animal with a method sound(). Two derived classes Dog and Cat override this method with their own versions. We create objects of Dog and Cat and call sound() on each. The program prints 'Bark' for Dog and 'Meow' for Cat. This happens because Python uses the method version of the actual object's class, not just the base class. This is polymorphism: one method name, many behaviors depending on the object. If a derived class does not override the method, the base class version runs. This lets us write flexible code that works with different object types through a common interface.

Practice

1. What does polymorphism through inheritance allow in Python?

easy

A. One method name to have different behaviors in child classes

B. Multiple inheritance from unrelated classes

C. Using the same variable name in different functions

D. Creating objects without defining classes

Solution

1. Step 1: Understand polymorphism concept

   Polymorphism means one method name can behave differently depending on the class.

2. Step 2: Relate to inheritance

   Child classes override the method to provide their own behavior.

3. Final Answer:

   One method name to have different behaviors in child classes -> Option A

4. Quick Check:

   Polymorphism = One method, many behaviors [OK]

Hint: Polymorphism means same method, different actions [OK]

Common Mistakes:

• Confusing polymorphism with multiple inheritance
• Thinking polymorphism means same variable names
• Believing objects can exist without classes

2. Which of the following is the correct way to override a method in a child class?

easy

A. Call the parent method inside the child method without redefining

B. Use the keyword override before the method

C. Define a method with the same name in the child class

D. Rename the method in the child class

Solution

1. Step 1: Check method overriding syntax

   In Python, overriding means defining a method with the same name in the child class.

2. Step 2: Verify other options

   Python does not use override keyword; renaming is not overriding; calling parent method alone is not overriding.

3. Final Answer:

   Define a method with the same name in the child class -> Option C

4. Quick Check:

   Override = same method name in child [OK]

Hint: Override by redefining method name in child class [OK]

Common Mistakes:

• Using a non-existent override keyword
• Thinking calling parent method equals overriding
• Renaming method instead of overriding

3. What will be the output of this code?

class Animal:
    def sound(self):
        return "Some sound"

class Dog(Animal):
    def sound(self):
        return "Bark"

class Cat(Animal):
    def sound(self):
        return "Meow"

animals = [Dog(), Cat(), Animal()]
for a in animals:
    print(a.sound())

medium

A. Bark\nMeow\nSome sound

B. Some sound\nSome sound\nSome sound

C. Bark\nMeow\nError

D. Error\nError\nError

Solution

1. Step 1: Identify method overriding

   Dog and Cat classes override sound method to return "Bark" and "Meow" respectively.

2. Step 2: Trace the loop output

   Loop calls sound() on Dog(), Cat(), and Animal() objects, printing "Bark", "Meow", and "Some sound".

3. Final Answer:

   Bark Meow Some sound -> Option A

4. Quick Check:

   Overridden methods print their own sounds [OK]

Hint: Child method overrides parent, prints child's return [OK]

Common Mistakes:

• Assuming parent method always runs
• Expecting errors from calling base class method
• Mixing output order

4. Find the error in this code that tries to demonstrate polymorphism:

class Vehicle:
    def move(self):
        print("Moving")

class Car(Vehicle):
    def move(self):
        print("Driving")

class Bike(Vehicle):
    def move(self):
        print("Riding")

vehicles = [Car(), Bike()]
for v in vehicles:
    v.move

medium

A. List should include Vehicle() instance

B. Incorrect class inheritance syntax

C. Using print instead of return in methods

D. Missing parentheses when calling move method

Solution

1. Step 1: Check method calls in loop

   The code uses v.move without parentheses, so method is not called.

2. Step 2: Understand effect of missing parentheses

   Without parentheses, method object is referenced but not executed, so no output occurs.

3. Final Answer:

   Missing parentheses when calling move method -> Option D

4. Quick Check:

   Method call needs () to execute [OK]

Hint: Always add () to call methods [OK]

Common Mistakes:

• Forgetting parentheses on method calls
• Thinking print vs return causes error here
• Believing inheritance syntax is wrong

5. You want to add a new class Bird that also uses polymorphism with sound(). Which code correctly extends the existing classes and uses polymorphism?

hard

A. class Bird:
def sound(self):
return "Chirp"

animals.append(Bird())
for a in animals:
print(a.sound())

B. class Bird(Animal):
def sound(self):
return "Chirp"

animals.append(Bird())
for a in animals:
print(a.sound())

C. class Bird(Animal):
def noise(self):
return "Chirp"

animals.append(Bird())
for a in animals:
print(a.sound())

D. class Bird(Animal):
def sound(self):
print("Chirp")

animals.append(Bird())
for a in animals:
print(a.sound())

Solution

1. Step 1: Check inheritance and method name

   Bird must inherit from Animal and override sound() method to maintain polymorphism.

2. Step 2: Verify method behavior and usage

   Method returns string "Chirp" like others; appending Bird() to animals list and calling sound() works correctly.

3. Final Answer:

   Correctly inherits Animal and overrides sound() returning "Chirp" -> Option B

4. Quick Check:

   Polymorphism needs same method name and inheritance [OK]

Hint: Inherit and override same method name with matching signature [OK]

Common Mistakes:

• Not inheriting from Animal class
• Using different method name like noise()
• Printing inside method instead of returning