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.
#python #oop #developer
Welcome to my Blog , In this article, you are going to learn the top 10 python tips and tricks.
#python #python hacks tricks #python learning tips #python programming tricks #python tips #python tips and tricks #python tips and tricks advanced #python tips and tricks for beginners #python tips tricks and techniques #python tutorial #tips and tricks in python #tips to learn python #top 30 python tips and tricks for beginners
Welcome to my Blog, In this article, we will learn python lambda function, Map function, and filter function.
Lambda function in python: Lambda is a one line anonymous function and lambda takes any number of arguments but can only have one expression and python lambda syntax is
Syntax: x = lambda arguments : expression
Now i will show you some python lambda function examples:
#python #anonymous function python #filter function in python #lambda #lambda python 3 #map python #python filter #python filter lambda #python lambda #python lambda examples #python map
The struggle for a clean code is a battle joined by all the programmers. And that battle can be conquered with a proper armour of object-oriented programming concepts. And proper utilization of OOP concepts helps us to improve code reusability, readability, optimal time and space complexity.
Inheritance is one of the most utilized object-oriented features and implementing it in python is an enthusiastic task. So, let’s start now!
First things first let’s understand the definition of inheritance.
#data science #inheritance #inheritance in python #python #types of inheritance #types of inheritance in python
Python is awesome, it’s one of the easiest languages with simple and intuitive syntax but wait, have you ever thought that there might ways to write your python code simpler?
In this tutorial, you’re going to learn a variety of Python tricks that you can use to write your Python code in a more readable and efficient way like a pro.
Swapping value in Python
Instead of creating a temporary variable to hold the value of the one while swapping, you can do this instead
>>> FirstName = "kalebu" >>> LastName = "Jordan" >>> FirstName, LastName = LastName, FirstName >>> print(FirstName, LastName) ('Jordan', 'kalebu')
#python #python-programming #python3 #python-tutorials #learn-python #python-tips #python-skills #python-development
Today you’re going to learn how to use Python programming in a way that can ultimately save a lot of space on your drive by removing all the duplicates.
In many situations you may find yourself having duplicates files on your disk and but when it comes to tracking and checking them manually it can tedious.
Heres a solution
Instead of tracking throughout your disk to see if there is a duplicate, you can automate the process using coding, by writing a program to recursively track through the disk and remove all the found duplicates and that’s what this article is about.
But How do we do it?
If we were to read the whole file and then compare it to the rest of the files recursively through the given directory it will take a very long time, then how do we do it?
The answer is hashing, with hashing can generate a given string of letters and numbers which act as the identity of a given file and if we find any other file with the same identity we gonna delete it.
There’s a variety of hashing algorithms out there such as
#python-programming #python-tutorials #learn-python #python-project #python3 #python #python-skills #python-tips