Python inheritance
Table of Contents
Python inheritance
Python inheritance is a mechanism that allows a new class to be based on an existing class, inheriting all its attributes and methods. The new class, known as the subclass or derived class, can add new features or override existing ones from the superclass or base class.
This approach promotes code reuse, reduces redundancy, and facilitates maintenance and extensibility of software systems.
In Python, inheritance is implemented through the use of the “class” keyword, followed by the subclass name and the superclass name in parentheses. Multiple inheritance is also supported, where a subclass can inherit from multiple superclasses, separated by commas.
What is the meaning of Python Inheritance ?
Python Inheritance is a way of creating a new class by inheriting properties and methods of an existing class. The new class created is known as a subclass or derived class and the existing class is known as the superclass or base class.
Here’s an example to explain how inheritance works in Python:
# Define a superclass
class Vehicle:
def __init__(self, color, speed):
self.color = color
self.speed = speed
def drive(self):
print("Driving...")
# Define a subclass
class Car(Vehicle):
def __init__(self, color, speed, model):
# calling the superclass constructor
super().__init__(color, speed)
self.model = model
def drive(self):
print("Driving a car...")
# Create objects of the classes
vehicle = Vehicle("Red", 100)
car = Car("Blue", 120, "Sedan")
# Access superclass methods and attributes
print(vehicle.color) # Output: "Red"
vehicle.drive() # Output: "Driving..."
# Access subclass methods and attributes
print(car.color) # Output: "Blue"
print(car.model) # Output: "Sedan"
car.drive() # Output: "Driving a car..."- In the above example, we have a superclass called “Vehicle” that has two attributes – “color” and “speed” and a method “drive()”.
- We then define a subclass called “Car” that inherits from the “Vehicle” superclass.
- The “Car” subclass has an additional attribute “model” and overrides the “drive()” method of the “Vehicle” superclass.
- We then create two objects of the classes, “vehicle” and “car”, and access their attributes and methods.
- We can see that the “car” object has access to the attributes and methods of both the “Car” and “Vehicle” classes.
How to Create a Parent Class ?
- To create a parent class in Python, you define a new class and specify it as the base class of any derived classes you want to create.
- The derived classes will inherit all the attributes and methods of the parent class, and can also add their own attributes and methods.
Here’s an example of creating a parent class:
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def make_sound(self):
print("This animal makes a sound.")
class Dog(Animal):
def make_sound(self):
print("Woof!")
class Cat(Animal):
def make_sound(self):
print("Meow!")
my_dog = Dog("Buddy", 3)
my_cat = Cat("Fluffy", 5)
print(my_dog.name) # Output: "Buddy"
print(my_dog.age) # Output: 3
my_dog.make_sound() # Output: "Woof!"
print(my_cat.name) # Output: "Fluffy"
print(my_cat.age) # Output: 5
my_cat.make_sound() # Output: "Meow!"- In this example, the “Animal” class is the parent class, and the “Dog” and “Cat” classes are derived classes that inherit from it.
- The “Animal” class has an “init()” method that initializes the “name” and “age” attributes, and a “make_sound()” method that prints a generic sound message.
- The “Dog” and “Cat” classes both have their own “make_sound()” methods that override the method in the “Animal” class with specific sound messages for dogs and cats.
You can create as many derived classes as you need, and each one will have access to all the attributes and methods of the parent class.
How to Create a Child Class ?
- To create a child class in Python, you define a new class and specify the parent class as its base class using parentheses after the new class name.
- This will cause the child class to inherit all the attributes and methods of the parent class, which it can then customize or add to as needed.
Here’s an example of creating a child class:
class Vehicle:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def start(self):
print("The vehicle is starting.")
class Car(Vehicle):
def __init__(self, make, model, year, doors):
super().__init__(make, model, year)
self.doors = doors
def start(self):
print("The car is starting.")
class Truck(Vehicle):
def __init__(self, make, model, year, payload):
super().__init__(make, model, year)
self.payload = payload
def load(self):
print("The truck is loading cargo.")
my_car = Car("Toyota", "Corolla", 2020, 4)
my_truck = Truck("Ford", "F-150", 2018, 1500)
print(my_car.make) # Output: "Toyota"
print(my_car.doors) # Output: 4
my_car.start() # Output: "The car is starting."
print(my_truck.make) # Output: "Ford"
print(my_truck.payload) # Output: 1500
my_truck.start() # Output: "The vehicle is starting."
my_truck.load() # Output: "The truck is loading cargo."
- In this example, the “Vehicle” class is the parent class, and the “Car” and “Truck” classes are child classes that inherit from it.
- The “Vehicle” class has an “init()” method that initializes the “make”, “model”, and “year” attributes, and a “start()” method that prints a generic start message.
- The “Car” and “Truck” classes both have their own “init()” methods that use the “super()” function to call the parent class’s “init()” method and add their own “doors” or “payload” attributes.
- The “Car” class also has its own “start()” method that overrides the parent class’s method with a specific message for cars, while the “Truck” class has its own “load()” method that is unique to trucks.
You can create as many child classes as you need, and each one will have access to all the attributes and methods of the parent class.
Add the __init__() Function
- In Python, the __init__() function is a special method that is called when an object of a class is created.
- It is used to initialize the attributes of the object, and can also perform other setup tasks if needed.
To add the __init__() function to a class, you define it within the class definition like this:
class MyClass: def __init__(self, attribute1, attribute2): self.attribute1 = attribute1 self.attribute2 = attribute2
- In this example, the MyClass class has an __init__() function that takes two arguments, attribute1 and attribute2.
- Within the function, the self parameter refers to the object being created, and is used to set the values of the object’s attributes.
Here’s an example of using the __init__() function to create a Person class:
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def greet(self):
print("Hello, my name is", self.name)
person1 = Person("Alice", 25, "female")
person2 = Person("Bob", 30, "male")
print(person1.name) # Output: "Alice"
print(person1.age) # Output: 25
print(person1.gender) # Output: "female"
person1.greet() # Output: "Hello, my name is Alice"
person2.greet() # Output: "Hello, my name is Bob"- In this example, the Person class has an __init__() function that initializes the name, age, and gender attributes of each Person object.
- The class also has a greet() method that prints a greeting message using the name attribute. Two Person objects, person1 and person2, are created using the Person class with different values for their attributes.
- The attributes and methods of each object can be accessed using dot notation.
Use the super() Function
In Python, the super() function is used to call a method from a parent class. - This is useful when you want to override a method in a child class, but still want to use the functionality of the parent class’s method.
Here’s an example of using the super() function to call a parent class’s method:
class Parent:
def my_method(self):
print("This is the parent class.")
class Child(Parent):
def my_method(self):
super().my_method() # call the parent class's method
print("This is the child class.")
child = Child()
child.my_method() # Output: "This is the parent class." "This is the child class."- In this example, the Parent class has a my_method() method that prints a message.
- The Child class inherits from the Parent class and also has a my_method() method, but it uses the super() function to call the parent class’s my_method() method before printing its own message.
- When the my_method() method of the Child object is called, it first prints “This is the parent class.”, and then prints “This is the child class.”
- Using the super() function in the __init__() method of a child class is a common pattern in Python to initialize the attributes of the parent class.
Here’s an example:
class Parent:
def __init__(self, attribute1):
self.attribute1 = attribute1
class Child(Parent):
def __init__(self, attribute1, attribute2):
super().__init__(attribute1) # initialize the parent class's attribute
self.attribute2 = attribute2
child = Child("value1", "value2")
print(child.attribute1) # Output: "value1"
print(child.attribute2) # Output: "value2"
- In this example, the Parent class has an __init__() method that initializes the attribute1 attribute.
- The Child class inherits from the Parent class and has its own __init__() method that initializes the attribute2 attribute. In the Child class’s __init__() method, the super() function is used to call the __init__() method of the parent class and initialize its attribute1 attribute.
- Then, the attribute2 attribute of the child class is initialized. When a Child object is created, both attributes are initialized correctly.
Add Properties
In Python, properties allow you to define getters, setters, and deleters for class attributes.
- This gives you more control over how your attributes are accessed and manipulated.
- To add a property to a class attribute, you define getter, setter, and deleter methods using the @property, @<attribute>.setter, and @<attribute>.deleter decorators, respectively.
Here’s an example:
class Person:
def __init__(self, name, age):
self._name = name
self._age = age
@property
def name(self):
return self._name
@name.setter
def name(self, value):
self._name = value
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if value < 0:
raise ValueError("Age must be positive.")
self._age = value
@age.deleter
def age(self):
del self._age
- In this example, the Person class has name and age attributes that are initialized in the __init__() method.
- The name and age attributes each have a getter and setter method defined using the @property and <attribute>.setter decorators.
- The age attribute also has a deleter method defined using the @<attribute>.deleter decorator.
- The name getter method simply returns the _name attribute.
- The name setter method sets the _name attribute to the value passed in. Similarly, the age getter method returns the _age attribute, but the age setter method first checks that the value passed in is positive before setting the _age attribute.
The age deleter method deletes the _age attribute.
Here’s an example of using the Person class with its properties:
person = Person("Alice", 25)
print(person.name) # Output: "Alice"
person.name = "Bob"
print(person.name) # Output: "Bob"
print(person.age) # Output: 25
person.age = 30
print(person.age) # Output: 30
del person.age
print(person.age) # Raises AttributeError: 'Person' object has no attribute '_age'
class Person:
def __init__(self, name, age):
self._name = name
self._age = age
@property
def name(self):
return self._name
@name.setter
def name(self, value):
self._name = value
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if value < 0:
raise ValueError("Age must be positive.")
self._age = value
@age.deleter
def age(self):
del self._age
- In this example, a Person object is created with a name of “Alice” and an age of 25.
- The name and age attributes are accessed using the property getter methods.
- The name attribute is then updated using the property setter method, and the age attribute is updated using the property setter method after passing the check for a positive value.
- Finally, the age attribute is deleted using the property deleter method, which raises an AttributeError when the age attribute is accessed again.
Add Methods
Methods can be added to a class to perform specific actions or operations. To add a method to a class, you simply define it within the class definition.
Here’s an example:
class Rectangle: def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height def perimeter(self): return 2 * (self.width + self.height)
- In this example, the Rectangle class has an __init__() method that initializes the width and height attributes of a rectangle.
- It also has an area() method that calculates and returns the area of the rectangle, and a perimeter() method that calculates and returns the perimeter of the rectangle.
Here’s an example of using the Rectangle class with its methods:
rectangle = Rectangle(10, 5)
print(rectangle.area()) # Output: 50
print(rectangle.perimeter()) # Output: 30
here's another example of a class with methods:
class BankAccount:
def __init__(self, balance):
self.balance = balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
if self.balance >= amount:
self.balance -= amount
else:
print("Insufficient funds.")
def display_balance(self):
print(f"Current balance: {self.balance}")- In this example, the BankAccount class has an __init__() method that initializes the balance attribute of a bank account.
- It also has a deposit() method that adds a specified amount to the balance attribute, a withdraw() method that subtracts a specified amount from the balance attribute if there are sufficient funds, and a display_balance() method that displays the current balance of the bank account.
Here’s an example of using the BankAccount class with its methods:
account = BankAccount(1000) account.display_balance() # Output: "Current balance: 1000" account.deposit(500) account.display_balance() # Output: "Current balance: 1500" account.withdraw(2000) # Output: "Insufficient funds." account.display_balance() # Output: "Current balance: 1500" account.withdraw(1000) account.display_balance() # Output: "Current balance: 500"
- In this example, a BankAccount object is created with an initial balance of 1000.
- The display_balance() method is called to display the initial balance.
- The deposit() method is then called to add 500 to the balance, and the display_balance() method is called again to display the new balance.
- The withdraw() method is then called twice, once with an amount greater than the balance (which prints an error message) and once with an amount less than or equal to the balance (which subtracts the amount from the balance).
- The display_balance() method is called again after each withdrawal to display the new balance.
Types of Inheritance with examples
Here are a few more examples to illustrate Python Inheritance:
Single Inheritance
class Animal:
def __init__(self, name, species):
self.name = name
self.species = species
def move(self):
print(f"{self.name} is moving...")
class Dog(Animal):
def bark(self):
print(f"{self.name} is barking...")
my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.species) # Output: "Golden Retriever"
my_dog.move() # Output: "Buddy is moving..."
my_dog.bark() # Output: "Buddy is barking..."- In this example, we have a superclass called “Animal” and a subclass called “Dog” that inherits from the “Animal” class.
- The “Dog” subclass has an additional method called “bark()”.
- We then create an object of the “Dog” class and access its attributes and methods.
Example:
Single inheritance is a type of inheritance where a derived class inherits from a single base class.
class Vehicle:
def __init__(self, name, color):
self.name = name
self.color = color
def drive(self):
print(f"{self.name} is driving...")
class Car(Vehicle):
def __init__(self, name, color, model):
super().__init__(name, color)
self.model = model
my_car = Car("BMW", "Black", "X5")
print(my_car.model) # Output: "X5"
my_car.drive() # Output: "BMW is driving..."- In this example, the “Vehicle” class is the base class, and the “Car” class is the derived class that inherits from the “Vehicle” class.
- The “Car” class has an additional attribute called “model” and overrides the “drive()” method of the “Vehicle” class.
Multiple Inheritance
Multiple inheritance is a type of inheritance where a derived class inherits from multiple base classes.
class Animal:
def __init__(self, name):
self.name = name
def move(self):
print(f"{self.name} is moving...")
class Pet:
def __init__(self, owner):
self.owner = owner
def play(self):
print(f"{self.owner} is playing with {self.name}...")
class Dog(Animal, Pet):
def bark(self):
print(f"{self.name} is barking...")
my_dog = Dog("Buddy", "John")
my_dog.move() # Output: "Buddy is moving..."
my_dog.play() # Output: "John is playing with Buddy..."
my_dog.bark() # Output: "Buddy is barking..."
- In this example, we have two superclasses – “Animal” and “Pet” – and a subclass called “Dog” that inherits from both the superclasses.
- The “Dog” subclass has an additional method called “bark()”.
- We then create an object of the “Dog” class and access its attributes and methods.
Hierarchical Inheritance
Hierarchical inheritance is a type of inheritance where a derived class inherits from a single base class, and multiple derived classes can inherit from the same base class.
class Shape:
def __init__(self, name):
self.name = name
def area(self):
pass
class Circle(Shape):
def __init__(self, name, radius):
super().__init__(name)
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
class Rectangle(Shape):
def __init__(self, name, length, breadth):
super().__init__(name)
self.length = length
self.breadth = breadth
def area(self):
return self.length * self.breadth
my_circle = Circle("Circle", 5)
my_rectangle = Rectangle("Rectangle", 4, 6)
print(my_circle.area()) # Output: 78.5
print(my_rectangle.area()) # Output: 24- In this example, we have a superclass called “Shape” and two subclasses called “Circle” and “Rectangle” that inherit from the “Shape” class.
- Each subclass overrides the “area()” method of the “Shape” class to compute the area of a circle or rectangle.
- We then create objects of the “Circle” and “Rectangle” classes and access their attributes and methods.
Hybrid Inheritance
Hybrid inheritance is a combination of multiple inheritance and multi-level inheritance.
class Vehicle:
def __init__(self, name):
self.name = name
def drive(self):
print(f"{self.name} is driving...")
class Car(Vehicle):
def __init__(self, name, model):
super().__init__(name)
self.model = model
class Electric:
def __init__(self, name, battery):
self.name = name
self.battery = battery
def charge(self):
print(f"{self.name} is charging...")
class ElectricCar(Car, Electric):
def __init__(self, name, model, battery):
Car.__init__(self, name, model)
Electric.__init__(self, name, battery)
my_electric_car = ElectricCar("Tesla", "Model S", "100 kWh")
my_electric_car.drive() # Output: "Tesla is driving..."
my_electric_car.charge() # Output: "Tesla is charging..."- In this example, the “Vehicle” and “Electric” classes are the base classes, and the “Car” and “ElectricCar” classes are the derived classes.
- The “Car” class inherits from the “Vehicle” class, the “Electric” class has an additional method called “charge()”, and the “ElectricCar” class inherits from both the “Car” and “Electric” classes.
- The “ElectricCar” class has an attribute called “battery” and can call the “drive()” and “charge()” methods.
Example:
Hybrid inheritance is a combination of multiple types of inheritance. It is a complex type of inheritance that involves multiple base classes and multiple derived classes.
class A:
def foo(self):
print("A")
class B(A):
def foo(self):
print("B")
class C(A):
def foo(self):
print("C")
class D(B, C):
pass
class E:
def bar(self):
print("E")
class F(D, E):
pass
my_f = F()
my_f.foo() # Output: "B"
my_f.bar() # Output: "E"- In this example, there are multiple base classes (“A”, “B”, “C”, and “E”) and multiple derived classes (“D” and “F”).
- The “D” class inherits from both “B” and “C”, and the “F” class inherits from both “D” and “E”.
- When the “foo()” method is called on an instance of the “F” class, Python will look for the method in the “F” class first, then in the “D” class (which will inherit from “B” because it is listed first in the “D” class inheritance), then in the “B” class, then in the “C” class, and finally in the “A” class.
- When the “bar()” method is called on an instance of the “F” class, Python will look for the method in the “F” class first, then in the “D” class, and finally in the “E” class.
MRO – Method Resolution Order
Method Resolution Order (MRO) is the order in which Python looks for methods to execute in a class hierarchy. It is used to determine which method to call when a method is called on an instance of a class.
class A:
def foo(self):
print("A")
class B(A):
def foo(self):
print("B")
class C(A):
def foo(self):
print("C")
class D(B, C):
pass
my_d = D()
my_d.foo() # Output: "B"- In this example, the “A”, “B”, and “C” classes are the base classes, and the “D” class is the derived class.
- The “B” and “C” classes both override the “foo()” method from the “A” class, and the “D” class inherits from both “B” and “C” classes.
- When the “foo()” method is called on an instance of the “D” class, Python will look for the method in the “D” class first, then in the “B” class (because “B” is listed before “C” in the “D” class inheritance), then in the “C” class, and finally in the “A” class.
Abstract Base Classes
An abstract base class (ABC) is a class that cannot be instantiated, and is only meant to be subclassed. ABCs are used to define a common interface for a group of subclasses, and to enforce the implementation of certain methods in those subclasses.
from abc import ABC, abstractmethod
class Animal(ABC):
def __init__(self, name):
self.name = name
@abstractmethod
def move(self):
pass
class Dog(Animal):
def move(self):
print(f"{self.name} is running...")
class Cat(Animal):
def move(self):
print(f"{self.name} is walking...")
# This will raise a TypeError because Animal is an abstract class
my_animal = Animal("Some Animal")
my_dog = Dog("Buddy")
my_dog.move() # Output: "Buddy is running..."
my_cat = Cat("Fluffy")
my_cat.move() # Output: "Fluffy is walking..."- In this example, the “Animal” class is an abstract base class that defines an abstract method called “move()”.
- The “Dog” and “Cat” classes are concrete subclasses of “Animal” that implement the “move()” method in their own way. Attempting to instantiate the “Animal” class will raise a TypeError because it is an abstract class.
- Multiple choice quiz about python inheritance
1-What is inheritance in Python?
a) A way to create new classes from existing classes
b) A way to create new instances from existing classes
c) A way to create new methods from existing classes
d) A way to create new attributes from existing classes
2-Which keyword is used to inherit a class in Python?
a) extend
b) inherit
c) include
d) super
3-Which type of inheritance involves creating a new class from two or more existing classes?
a) Single inheritance
b) Multiple inheritance
c) Hierarchical inheritance
d) Hybrid inheritance
4-Which method is used to initialize attributes of a subclass in Python?
a) new()
b) init()
c) str()
d) repr()
5-Which method is used to call the method of the parent class from the subclass in Python?
a) super()
b) parent()
c) base()
d) ancestor()
Answers:
1-a 2-a 3-b 4-b 5-a
6-Which method is used to check if a class is a subclass of another class in Python?
a) issubclass()
b) superclass()
c) parentclass()
d) childclass()
7-Which type of inheritance involves creating a new class from an existing class and adding new attributes and methods?
a) Single inheritance
b) Multiple inheritance
c) Hierarchical inheritance
d) Inheritance with extension
8-Which method is used to override a method of the parent class in the subclass in Python?
a) new()
b) init()
c) str()
d) repr()
9-Which method is used to create a string representation of an object in Python?
a) new()
b) init()
c) str()
d) repr()
10-Which keyword is used to prevent a method from being overridden in the subclass in Python?
a) final
b) override
c) prevent
d) None of the above
Answers: 6-a 7-d 8-d 9-c 10-a
11-Which method is used to check if an object is an instance of a class in Python?
a) isclass()
b) isinstance()
c) type()
d) class()
12-Which type of inheritance involves creating a new class from an existing class but not adding any new attributes or methods?
a) Single inheritance
b) Multiple inheritance
c) Hierarchical inheritance
d) Inheritance without extension
13-Which method is used to call a method of the parent class from the subclass in Python?
a) super()
b) parent()
c) base()
d) ancestor()
14-Which method is used to create a copy of an object in Python?
a) new()
b) init()
c) str()
d) copy()
15-Which keyword is used to inherit a class and its attributes and methods without creating a new subclass in Python?
a) extend
b) inherit
c) include
d) None of the above
Answers:11-b 12-a 13-a 14-d 15-d
16-Which type of inheritance involves creating a new class from an existing class and modifying the behavior of the existing methods?
a) Single inheritance
b) Multiple inheritance
c) Hierarchical inheritance
d) Overriding inheritance
17-Which method is used to delete an attribute of an object in Python?
a) delete()
b) remove()
c) delattr()
d) deleteattr()
18-Which method is used to compare two objects in Python?
a) compare()
b) equal()
c) cmp()
d) eq()
19-Which method is used to perform a deep copy of an object in Python?
a) new()
b) init()
c) str()
d) deepcopy()
20-Which keyword is used to inherit a class and its attributes and methods as-is in Python?
a) extend
b) inherit
c) include
d) None of the above
Answers:16-d 17-c 18-d 19-d 20-b
21-Which type of inheritance involves creating a new class from two or more existing classes?
a) Single inheritance
b) Multiple inheritance
c) Hierarchical inheritance
d) Overriding inheritance
22-Which method is used to create a new instance of a class in Python?
a) new()
b) init()
c) str()
d) copy()
23-Which method is used to return the length of an object in Python?
a) len()
b) size()
c) length()
d) count()
24-Which method is used to perform an operation on an object when it is used as an operand with a built-in operator in Python?
a) call()
b) operation()
c) operator()
d) add()
25-Which keyword is used to indicate that a method or attribute is private in Python?
a) private
b) protected
c) public
d) None of the above
Answers: 21-b 22-a 23-a 24-d 25-b
26-Which type of inheritance involves creating a new class from two or more existing classes?
a) Single inheritance
b) Multiple inheritance
c) Hierarchical inheritance
d) Overriding inheritance
27-Which method is used to create a new instance of a class in Python?
a) new()
b) init()
c) str()
d) copy()
28-Which method is used to return the length of an object in Python?
a) len()
b) size()
c) length()
d) count()
29-Which method is used to perform an operation on an object when it is used as an operand with a built-in operator in Python?
a) call()
b) operation()
c) operator()
d) add()
30-Which keyword is used to indicate that a method or attribute is private in Python?
a) private
b) protected
c) public
d) None of the above
Answers: 26- b 27-a 28-a 29-d 30-b
31-Which type of inheritance involves creating a new class from an existing class and modifying the behavior of the existing methods?
a) Single inheritance
b) Multiple inheritance
c) Hierarchical inheritance
d) Overriding inheritance
32-Which method is used to delete an attribute of an object in Python?
a) delete()
b) remove()
c) delattr()
d) deleteattr()
33-Which method is used to compare two objects in Python?
a) compare()
b) equal()
c) cmp()
d) eq()
34-Which method is used to perform a deep copy of an object in Python?
a) new()
b) init()
c) str()
d) deepcopy()
35-Which keyword is used to inherit a class and its attributes and methods as-is in Python?
a) extend
b) inherit
c) include
d) None of the above
Answers:31-d 32-c 33-d 34-d 35-b