Learn how to use Class Inheritance in Object-Oriented Programming (OOP) with Python. Object-Oriented Programming (OOP) is a method of structuring a program by bundling related properties and behaviors into individual objects.
Object-oriented programming creates reusable patterns of code to curtail redundancy in development projects. One way that object-oriented programming achieves recyclable code is through inheritance, when one subclass can leverage code from another base class.
This tutorial will go through some of the major aspects of inheritance in Python, including how parent classes and child classes work, how to override methods and attributes, how to use the
super() function, and how to make use of multiple inheritance.
Inheritance is when a class uses code constructed within another class. If we think of inheritance in terms of biology, we can think of a child inheriting certain traits from their parent. That is, a child can inherit a parent’s height or eye color. Children also may share the same last name with their parents.
Classes called child classes or subclasses inherit methods and variables from parent classes or base classes.
We can think of a parent class called
Parent that has class variables for
eye_color that the child class
Child will inherit from the
Child subclass is inheriting from the
Parent base class, the
Child class can reuse the code of
Parent, allowing the programmer to use fewer lines of code and decrease redundancy.
Parent or base classes create a pattern out of which child or subclasses can be based on. Parent classes allow us to create child classes through inheritance without having to write the same code over again each time. Any class can be made into a parent class, so they are each fully functional classes in their own right, rather than just templates.
Let’s say we have a general
Bank_account parent class that has
Business_account child classes. Many of the methods between personal and business accounts will be similar, such as methods to withdraw and deposit money, so those can belong to the parent class of
Business_account subclass would have methods specific to it, including perhaps a way to collect business records and forms, as well as an
Animal class may have
sleeping() methods, and a
Snake subclass may include its own specific
Let’s create a
Fish parent class that we will later use to construct types of fish as its subclasses. Each of these fish will have first names and last names in addition to characteristics.
We’ll create a new file called
fish.py and start with the
__init__() constructor method, which we’ll populate with
last_name class variables for each
Fish object or subclass.
class Fish: def __init__(self, first_name, last_name="Fish"): self.first_name = first_name self.last_name = last_name
We have initialized our
last_name variable with the string
"Fish" because we know that most fish will have this as their last name.
Let’s also add some other methods:
class Fish: def __init__(self, first_name, last_name="Fish"): self.first_name = first_name self.last_name = last_name def swim(self): print("The fish is swimming.") def swim_backwards(self): print("The fish can swim backwards.")
We have added the methods
swim_backwards() to the
Fish class, so that every subclass will also be able to make use of these methods.
Since most of the fish we’ll be creating are considered to be bony fish (as in they have a skeleton made out of bone) rather than cartilaginous fish (as in they have a skeleton made out of cartilage), we can add a few more attributes to the
class Fish: def __init__(self, first_name, last_name="Fish", skeleton="bone", eyelids=False): self.first_name = first_name self.last_name = last_name self.skeleton = skeleton self.eyelids = eyelids def swim(self): print("The fish is swimming.") def swim_backwards(self): print("The fish can swim backwards.")
Building a parent class follows the same methodology as building any other class, except we are thinking about what methods the child classes will be able to make use of once we create those.
Child or subclasses are classes that will inherit from the parent class. That means that each child class will be able to make use of the methods and variables of the parent class.
For example, a
Goldfish child class that subclasses the
Fish class will be able to make use of the
swim() method declared in
Fish without needing to declare it.
We can think of each child class as being a class of the parent class. That is, if we have a child class called
Rhombus and a parent class called
Parallelogram, we can say that a
Rhombus is a
Parallelogram, just as a
Goldfish is a
The first line of a child class looks a little different than non-child classes as you must pass the parent class into the child class as a parameter:
Trout class is a child of the
Fish class. We know this because of the inclusion of the word
Fish in parentheses.
With child classes, we can choose to add more methods, override existing parent methods, or simply accept the default parent methods with the
pass keyword, which we’ll do in this case:
... class Trout(Fish): pass
We can now create a
Trout object without having to define any additional methods.
... class Trout(Fish): pass terry = Trout("Terry") print(terry.first_name + " " + terry.last_name) print(terry.skeleton) print(terry.eyelids) terry.swim() terry.swim_backwards()
We have created a
terry that makes use of each of the methods of the
Fish class even though we did not define those methods in the
Trout child class. We only needed to pass the value of
"Terry" to the
first_name variable because all of the other variables were initialized.
When we run the program, we’ll receive the following output:
Output Terry Fish bone False The fish is swimming. The fish can swim backwards.
Next, let’s create another child class that includes its own method. We’ll call this class
Clownfish, and its special method will permit it to live with sea anemone:
... class Clownfish(Fish): def live_with_anemone(self): print("The clownfish is coexisting with sea anemone.")
Next, let’s create a
Clownfish object to see how this works:
... casey = Clownfish("Casey") print(casey.first_name + " " + casey.last_name) casey.swim() casey.live_with_anemone()
When we run the program, we’ll receive the following output:
Output Casey Fish The fish is swimming. The clownfish is coexisting with sea anemone.
The output shows that the
casey is able to use the
swim() as well as its child class method of
If we try to use the
live_with_anemone() method in a
Trout object, we’ll receive an error:
Output terry.live_with_anemone() AttributeError: 'Trout' object has no attribute 'live_with_anemone'
This is because the method
live_with_anemone() belongs only to the
Clownfish child class, and not the
Fish parent class.
Child classes inherit the methods of the parent class it belongs to, so each child class can make use of those methods within programs.
Are you looking for experienced, reliable, and qualified Python developers? If yes, you have reached the right place. At **[HourlyDeveloper.io](https://hourlydeveloper.io/ "HourlyDeveloper.io")**, our full-stack Python development services...
Looking to build robust, scalable, and dynamic responsive websites and applications in Python? At **[HourlyDeveloper.io](https://hourlydeveloper.io/ "HourlyDeveloper.io")**, we constantly endeavor to give you exactly what you need. If you need to...
After analyzing clients and market requirements, TopDevelopers has come up with the list of the best Python service providers. These top-rated Python developers are widely appreciated for their professionalism in handling diverse projects. When...
In the programming world, Data types play an important role. Each Variable is stored in different data types and responsible for various functions. Python had two different objects, and They are mutable and immutable objects.
This article covers A-Z about the mobile and web app development process and answers your question on how long does it take to develop/build an app.