Home >> python >> Inheritance in Python

Inheritance in Python

Welcome to another tutorial, here you learn about Inheritance in Python.

Inheritances are very important in Object Oriented Programming, OOP. During complex or even sampling coding, we might have situations that require us to write a few classes with some common features and some unique, class-specific features, that consist of both variables and methods. In OOP, we take out the common part and put it in a separate class, then make all the other classes inherit this class, and thereby be able to use its methods and variables, thus reducing rewriting those common features in every class repeatedly.

In inheritance, the class which inherits another class is known as the Child class, and the class that is inherited by other classes is known as the Parent class. However, this can only be used for related classes. Suppose, a class says LivingOrganism with all the primary features of a living organism defined in it, such as eating, breathing, and so on. This class can easily be reused by another class Animal and HumanBeings, because they share the same features.

In some instances, we can use inheritance to simplify large classes with a lot of variables and methods, into smaller classes by breaking down the functionality into core features and secondary features. also, core features are generally kept in the parent class.

Syntax for Inheritance

Now, If there is a class Parent and another class Child and we want the class Child to inherit the class Parent, then it will be like this:

# Parent class
class Parent:
    # class variable
    a = 10;
    b = 100;
    # some class methods
    def doThis();
    def doThat();

# Child class inheriting Parent class
class Child(Parent):
    # child class variable
    x = 1000;
    y = -1;
    # some child class method
    def doWhat();
    def doNotDoThat();

Just as shown in the example above, if we specify another class's name in parentheses, while declaring a class, we can specify inheritance. As all the properties of the Parent will be inherited by the Child. As such, every method and variable defined in the class Parent becomes part of the Child's class.

Some Examples of Inheritance.

Suppose, Animals can be divided into multiple types such as mammals, amphibians, reptiles, and so on. Even as they are different physically and biologically, there exist many characteristics that are common amongst them. Thus, in our example, we will define a parent class with the name Animal, that will possess some basic properties and functions related to animals.

Afterward, we will define classes for various types, and they will also inherit the class Animal.

Below is the animal class:

class Animal:
    # properties
	multicellular = True
	# Eukaryotic means Cells with Nucleus
	eukaryotic = True
	
	# functions
	def breath();
	def feed();

Let’s proceed by defining a class for Mammals. You know mammals are animals with warm blood, they produce milk for their infants, and so on.

The mammal class is:

class Mammal(Animal):
	# properties
	haveMammaryGland = True;
	def warmBlood = True;
	
	# functions
	def produceMilk();

Now, we can also create another class for Amphibians:

class Amphibian(Animal):
	# properties
	liveInWater = True;
	
	# functions
	def metamorphosis();

From the examples above, the classes Mammals and Amphibian inherits the class Animal, thus, they will have the properties and functions defined in that class (i.e. Animal).

In that is the case, then, any object of Amphibian class, like a Frog will have the properties including multicellular from Animal class; eukaryotic, from class Animal; liveInWater, from class Amphibian; and would be able to breath(), feed() and do metamorphosis().

Let’s see how all this can be written as code, if we create an object, say Frog:

>>> Amphibian Frog = Amphibian()
>>> Frog.breath();   # calling function defined in Animal class
>>> Frog.metamorphosis();    # calling function defined in Amphibian class
>>> print (Frog.liveInWater)

Output:

True

Benefits of using Inheritance in Python

Below are some of the benefits of inheritance in Python.

Aids less code repetition, because the common code can be placed in the parent class, thereby making it available to all the child classes.
Provides Structured Coding: when the codes are divided into classes, we can then structure our software better by dividing functionality into classes.
Makes coding more scalable.

Accessing Parent Class Element in Child Class

When we are working in a child class, at some point you may have to use the parent class's properties or functions. For you to access the parent class's elements the dot. an operator can be used.

Parent.variableName

The above example showed how to access the variables, but if there is a need to call the parent class's function; it is done like this:

Parent.functionName()

Note: The Parent is the name of our parent class, and variableName and functionName() are its variable and function respectively.

Check out this example to understand the paragraph above.

class Parent:
  	var1 = 1
  	def func1(self):
  	    # do something here

class Child(Parent):
  	var2 = 2
  	def func2(self):
        # do something here too
  		# time to use var1 from 'Parent'
  	    myVar = Parent.var1 + 10
  	    return myVar

-Advertisement-