Inheritance is a way to create a new class from an existing class.
It helps us reuse code, extend functionality, and follow the DRY (Don't Repeat Yourself) principle.
The base class (or parent class) contains common features.
The derived class (or child class) inherits from the base class and can:
Use parent’s methods and attributes
Add its own attributes and methods
Modify (override) methods from the parent class.
Think of inheritance like a family tree. A child inherits traits (methods and attributes) from their parents, but they can also have their own unique traits.
Single Inheritance
Single Inheritance is a type of inheritance where a child class inherits from only one parent class. This allows the child class to reuse the methods and attributes of the parent class while also adding its own unique features.
🔹 1. Creating a Parent Class
class Person: def __init__(self, name): self.name = name def introduce(self): print(f"Hi, I'm {self.name}")
🔍 Explanation:
__init__ is the constructor; it runs when the object is created.
introduce() is a method that prints a greeting.
🔹 2. Creating a Child Class (Inheritance)
class Student(Person): pass
🔍 Explanation:
Student class inherits from Person using (Person).
pass means no additional code — it still works because it inherits from Person.
s = Student("Ali")s.introduce() # Output: Hi, I'm Ali
🔹 3. Adding New Methods to the Child Class
class Student(Person): def study(self): print(f"{self.name} is studying.")
s = Student("Bob")s.introduce() # Inherited from Persons.study() # Defined in Student
🔹 4. Overriding Methods
If a child class provides its own implementation of a method that is already defined in the parent class, it "overrides" the parent's method.
You can change how a method works in the child class.
class Student(Person): def introduce(self): # Overriding the method print(f"Hello, I'm student {self.name}")
s = Student("Ahmad")s.introduce() # Output: Hello, I'm student Ahmad
Example: Method Overriding — Birds That Fly (and One That Doesn't)
# PARENT CLASS (the general rule)class Bird: def fly(self): # This is the DEFAULT behavior for all birds print("Most birds can fly.")# CHILD CLASS 1 — OVERRIDES fly()class Penguin(Bird): # Penguin INHERITS everything from Bird, # but it OVERRIDES the fly() method with its own version def fly(self): # This replaces Bird's fly() for any Penguin object print("Penguins cannot fly — they swim!")# CHILD CLASS 2 — DOES NOT OVERRIDE fly()class Sparrow(Bird): # Sparrow inherits from Bird but does NOT define its own fly() # So it will automatically use Bird's fly() method as-is def sing(self): print("Sparrows can sing beautifully!")# TESTING ITprint("--- Penguin ---")p = Penguin()p.fly() # Uses Penguin's OWN fly() → overriding in action # Output: Penguins cannot fly — they swim!print("\n--- Sparrow ---")s = Sparrow()s.fly() # No fly() in Sparrow, so Python goes UP to Bird and uses that # Output: Most birds can fly.s.sing() # Sparrow's own method, not inherited # Output: Sparrows can sing beautifully!print("\n--- Bird ---")b = Bird()b.fly() # The original, unchanged method # Output: Most birds can fly.# HOW PYTHON SEARCHES FOR A METHOD (MRO — Method Resolution Order)# ----------------------------------------------------------------# For p.fly() → checks Penguin ✔ found → stops here# For s.fly() → checks Sparrow ✖ not found → checks Bird ✔ found → stops here# For b.fly() → checks Bird ✔ found → stops here
Comparison Table
Class
Has own fly()?
Behavior
Bird
✅ Yes (original)
Prints the default message
Penguin
✅ Yes (overridden)
Prints its own custom message
Sparrow
❌ No
Falls back to Bird's fly() automatically
Key insight: If a child class does not override a method, Python automatically travels up the inheritance chain and uses the parent's version. You don't have to do anything — it just works.
🔹 5. Using super() to Call the Parent Method
The super() function is used to call methods from the parent class inside the child class. This is most commonly used in the init method to ensure the parent class is properly initialized.
If you override a method, but still want to use the original version from the parent, use super().
class Student(Person): def introduce(self): super().introduce() # Call Person's version print("I'm also a student.")
s = Student("Hamza")s.introduce()# Output:# Hi, I'm Hamza# I'm also a student.
Example: super() - Person and Teacher Classes
# PARENT CLASSclass Person: def __init__(self, name): # Every Person has a name self.name = name# CHILD CLASSclass Teacher(Person): def __init__(self, name, subject): # Step 1: Call Person's __init__() using super() # This sets self.name — just like Person does # Without this line, self.name would never be assigned! super().__init__(name) # Step 2: Now add Teacher's OWN extra attribute self.subject = subject# TESTING ITt = Teacher("Mr. Ahmed", "Mathematics")print(t.name) # Set by Person.__init__() via super() # Output: Mr. Ahmedprint(t.subject) # Set by Teacher.__init__() directly # Output: Mathematics
WHAT HAPPENS STEP BY STEP WHEN Teacher("Mr. Ahmed", "Mathematics") IS CALLED?
Back in Teacher.init(), self.subject = "Mathematics" is set
The Teacher object is now fully initialized with BOTH attributes
Why Not Just Write Person.__init__(self, name) Instead?
You can, but super() is the better practice:
Approach
Code
Problem
Without super()
Person.__init__(self, name)
Hardcodes the parent name — breaks if you rename the class or change inheritance
With super()
super().__init__(name)
Flexible, clean, and works correctly with multiple inheritance
Simple analogy: Imagine you're a Teacher filling out a form. Instead of rewriting your personal details from scratch, you say "copy everything from my Person profile" and then just add your subject on top. That's exactly what super() does.
Example: super() - Vehicle and Car Classes
# Parent classclass Vehicle: def __init__(self, brand): # Brand of the vehicle (e.g., Toyota, Ford) self.brand = brand def drive(self): print("The vehicle is moving.")# Child classclass Car(Vehicle): def __init__(self, brand, model): # Call the parent class constructor to set the brand super().__init__(brand) # Set the model of the car (e.g., Corolla, Mustang) self.model = model # Override the drive method with a more specific message def drive(self): print(f"The {self.brand} {self.model} is driving.")# Creating an object of the parent classvehicle = Vehicle("GenericBrand")print("Calling drive() on Vehicle object:")vehicle.drive() # Output: The vehicle is moving.print("\nCreating a Car object...")# Creating an object of the child classcar = Car("Toyota", "Corolla")print("Calling drive() on Car object:")car.drive() # Output: The Toyota Corolla is driving.# Accessing attributesprint("\nAccessing Car attributes:")print("Brand:", car.brand) # Output: Toyotaprint("Model:", car.model) # Output: Corolla
🚗 Imagine This:
A Vehicle is like a general category (e.g., anything that moves on wheels).
A Car is a specific type of Vehicle.
🔍 What's Happening
Parent Class - Vehicle
Has a brand (like "Toyota").
Has a drive() method that prints a basic message.
Child Class - Car
Inherits from Vehicle (so it gets brand and drive()).
Adds a new attribute: model (like "Corolla").
Changes (overrides) the drive() method to be more specific.
Using the Classes
When you call drive() on a Vehicle, it says a generic message.
When you call drive() on a Car, it says a message with the brand and model.
Multilevel Inheritance in Python
Multilevel Inheritance is a type of inheritance where a class (child class) inherits from another class (parent class), and then another class (grandchild class) inherits from the child class. This forms a chain of inheritance.
Multilevel Inheritance Example: Person, Student, and GraduateStudent in Python
class Person: def speak(self): print("Person speaks")class Student(Person): def study(self): print("Student studies")class GraduateStudent(Student): def research(self): print("Graduate student does research")g = GraduateStudent()g.speak()g.study()g.research()
Example: E-Commerce Product Catalog
Scenario
Different types of products (e.g., physical, digital, subscription) share common attributes but have unique behaviors. Inheritance helps avoid code duplication.
