Previously, we discussed about objects and classes in Python and how you can implement them. In this article, we’ll take it a little further by learning about inheritance in Python. Inheritance is one of the three building blocks of object-oriented programming with polymorphism and encapsulation being the other two.
Inheritance is a process that allows a class to reuse member variables and methods of another class. The class that inherits member variables and methods from another class is called a derived class or child class and the class that is being inherited by a child class is called a base class or a parent class.
In this article, you will learn about inheritance in Python with the help of examples. You will also study how to pass values from child class constructors to parent class constructors.
Basic Example of Inheritance in Python
Let’s take a look at a very simple example of inheritance in Python:
class X:
def print_text(self):
self.var = 10
print("This is parent class")
class Y(X):
pass
The script above defines a class X
with one method print_text()
and an instance variable var
. The class Y
inherits the class X
. The class Y
doesn’t contain any member variable or method. It is evident from the example above that to inherit a class, you need to pass the parent class name inside parentheses that follow the child’s class name. Since the class Y
now inherits the class X
, the class Y
can access the print_text()
method and the var
variable by default.
Let’s call the print_text()
method and print the value of the var
variable of the Y
class using an object of the class X
:
x = X()
x.print_text()
print(x.var)
Here is the output:
This is parent class 10
The output shows that the child class X
is able to access the parent class Y's
methods and variables. It is important to mention that only the public members of a class can be inherited by the child class. The protected members can be inherited in case if both the parent and child classes are in the same package while the private members of a class cannot be inherited. To study more about public, protected, and private members, see this article.
Advanced Example of Inheritance
This section contains a more advanced example of inheritance in Python.
Let’s define a class Animal
, with child classes Cat
, Butterfly
and Fish
:
class Animal:
def animal_details(self):
self.name = "Animal"
self.category = "Mammal"
self.age = 0
def show_animal_details(self):
print("The name of parent class is ", self.name)
The Animal
class contains three instance variables name
, category
and age
, defined inside an instance method animal_details()
. The Animal
class also contains an instance method show_animal_details()
which prints the name of the animal.
Next, we define Cat
, Butterfly
and Fish
classes that inherit the Animal class.
class Cat(Animal):
def cat_details(self):
self.number_of_paws = 4
print("A cat has", self.number_of_paws , "pawns")
class Butterfly(Animal):
def butterfly_details(self):
self.number_of_wings = 8
print("A butterfly has", self.number_of_wings, "wings")
class Fish(Animal):
def fish_details(self):
self.number_of_fins = 4
print("A fish has", self.number_of_fins, "fins")
The Cat
class has its own method cat_details()
and a member variable number_of_paws
, which means that in addition to having access to the name
, category
and age
member variables of the parent Animal
class, the Cat
class has its own set of member variables.
Similarly, the Butterfly
and Fish
classes have the methods butterfly_details()
and fish_details()
, respectively. The butterfly_details()
method prints the value of the number_of_wings variable of the Butterfly class whereas the fish_details()
method prints the value of the
The basic idea of inheritance is that the methods and variables that are common in multiple child classes are included in the parent class. The methods and variables that are specific and not common among child classes are added in respective child classes.
For example, since not all animals have paws
, therefore the variable number_of_paws
has not been added to the parent Animal
class, rather it is added to the child Cat
class. Similarly, the variable number_of_wings
and number_of_fins
are intrinsic to respectively Butterfly
and Fish
classes, therefore these variables are added in the respective child classes and not in the Parent Animal
class.
The following script creates objects of the Cat
, Fish
and Butterfly
classes and access the parent and child class methods and variables:
cat = Cat()
cat.animal_details()
cat.show_animal_details()
print(cat.category)
print(cat.age)
cat.cat_details()
Here is the output of the script above:
The name of parent class is Animal Mammal 0 A cat has 4 pawns
butterfly = Butterfly()
butterfly.animal_details()
butterfly.show_animal_details()
print(butterfly.category)
print(butterfly.age)
butterfly.butterfly_details()
Output:
The name of parent class is Animal Mammal 0 A butterfly has 8 wings
fish = Fish()
fish.animal_details()
fish.show_animal_details()
print(fish.category)
print(fish.age)
fish.fish_details()
Output:
The name of parent class is Animal Mammal 0 A fish has 4 fins
You can see that the child classes have successfully accessed the parent class methods and variables.
Accessing Parent Class Constructors via Child Classes
There is one problem with the Cat
, Butterfly
, and Fish
classes that we defined in the previous section. In all the three cases i.e. when we create the objects of Cat
, Butterfly
, and Fish
classes and call the show_animal_details()
method. The method always prints the animal name as animal
, the category as mammals
, and the age as 0
. We want that for Cat
class object, the name should be cat
, and the category should be mammal
. Similarly, for Butterfly class object the category should be insect
rather than mammal
. Similarly, the name of the Fish class object should be fish
. We can use constructors to implement this logic.
Let’s define the Animal class with a constructor:
class Animal:
def __init__(self, name, category, age):
self.name = name
self.category = category
self.age = age
def show_animal_details(self):
print("The name of animal is ", self.name)
print("The category of animal is ", self.category)
print("The age of animal is ", self.age)
In the script above, the Animal
class constructor initializes the name
, category
and age
variables. The show_animal_details()
method prints the value of these variables.
Next, we define Cat
, Butterfly
and Fish
classes with constructors. The parent class constructors can be accessed from within a child class using the super()
object. Look at the following script for a better understanding.
class Cat(Animal):
def __init__(self, name, category, age, paws):
super().__init__(name, category, age)
self.number_of_paws = paws
print("A cat has", self.number_of_paws , "paws")
The Cat
class constructor accepts 4 arguments: name
, category
, age
and paws. The first three arguments are passed to the parent class constructor via the super()
object, while the fourth argument i.e paws
is used to initialize the child class variable number_of_paws
.
Similarly, the Butterfly and Fish class also pass arguments to the parent Animal class constructor as shown below:
class Butterfly(Animal):
def __init__(self, name, category, age, paws):
super().__init__(name, category, age)
self.number_of_wings = paws
print("A butterfly has", self.number_of_wings, "wings")
class Fish(Animal):
def __init__(self, name, category, age, paws):
super().__init__(name, category, age)
self.number_of_fins = paws
print("A fish has", self.number_of_fins, "fins")
Now while creating objects of the Cat
, Fish
and Butterfly
classes, you can pass the values for the name, category and age variables of the parent class. You can see the values for the name, category and age variables of the child class objects via the show_animal_details()
function as shown below:
cat = Cat("cat","mammal",5, 4)
cat.show_animal_details()
Here is the output:
A cat has 4 paws The name of animal is cat The category of animal is mammal The age of animal is 5
Similarly, the following script creates Butterfly and Fish class objects and prints the values for their name, category, and age variables.
fish = Fish("fish","bony_fish", 10, 4)
fish.show_animal_details()
butterfly = Butterfly("butterfly","insect", 10, 4)
butterfly.show_animal_details()
The output of the above script is as follows:
A fish has 4 fins The name of animal is fish The category of animal is bony_fish The age of animal is 10 A butterfly has 4 wings The name of animal is butterfly The category of animal is insect The age of animal is 10
Wrapping Up
Inheritance is one of the most useful concepts in object-oriented programming. Inheritance fosters code reusability and organization. The article explains the concept of inheritance in Python with the help of examples. The article also shows how you can initialize parent class variables by calling the parent class constructors from child classes.
If you wish to learn more about Python, make sure to check out our collection of Python tutorials.
Comments