Python Inheritance
Tags: tutorial, beginners, python, programming
Published: 2022-03-07 14:38:32

> [Sign up to my newsletter!](https://baransel.dev/newsletter/).

## What is Python Inheritance?

When you work in large projects, you will see that the project consists of submodules, subparticles, and many features of these submodules are already in the main module. For this, you will have to create the features and functions for the submodules each time, which will literally turn into a torture for you. This is where the concept of inheritance emerges.

Inheritance, is a concept that comes with object-oriented programming (OOP). If you don't know object-oriented programming logic, you can have a [look here](https://baransel.dev/post/python-object-oriented-programming-oop/). While describing object-oriented programming, we were creating a new class for each object and specifying the properties and functions of each object. Here, with inheritance, which is a much more practical method, you no longer need to specify properties and functions for each object. You use features that you create once, over and over again.

Let's give an example from daily life. For example, you have a vehicle object; You will create objects such as cars, motorcycles. Here you don't need to write properties again for car and engine because the properties of car and motorcycle object already exist in vehicle object. The reason is that car and motorcycle objects are subsets of vehicle objects. If you are confused, don't worry, you will understand much better when we do the examples.

Many of us have student information or parent information systems that we see at university or high school. These systems have more than one user login system. As an example, I took the student information system of a university.

<img alt="University login page" src="https://baransel.dev/post/python-inheritance/university-login.png" style="height:75%;width:75%;"/>

As you can see, there are more than one different user login to the system and most of the actions of these users are almost the same. Now let's write the codes for these users.

```python
class Academician:
    def __init__(self, name, surname, number):
        self.name = name
        self.surname = surname
        self.number = number
 
    def login(self):
        print("Signed In")
 
    def logout(self):
        print("Signed Out")
 
 
class Staff:
    def __init__(self, name, surname, number):
        self.name = name
        self.surname = surname
        self.number = number
 
    def login(self):
        print("Signed In")
 
    def logout(self):
        print("Signed Out")
 
 
class Student:
    def __init__(self, name, surname, number):
        self.name = name
        self.surname = surname
        self.number = number
 
    def login(self):
        print("Signed In")
 
    def logout(self):
        print("Signed Out")
```

If you have noticed, even though we use OOP, we had to write the same codes over and over again. Now let's do it with the concept of inheritance.

## Use of Inheritance

Inheritance method is very easy. The general usage is as follows.

>```python
> class class_name(inherit_class_name):
>    ...
>```

Now let's write our codes;

```python
class User:
    def __init__(self, name, surname, number):
        print("User class function")
        self.name = name
        self.surname = surname
        self.number = number
 
    def login(self):
        print("Signed In")
 
    def logout(self):
        print("Signed Out")
 
 
 
class Academician(User):
    pass
class Staff(User):
    pass
class Student(User):
    pass
```

We created our class with `User` and inherited other objects from this class. We did not add properties and functions for subclasses because we will inherit properties and functions from the `User` class.

Now let's create and call the object.

```python
academician = Academician("Baransel", "Arslan", 14092000)
staff = Staff("Oscar", "Olson", 16527187)
student = Student("Holger", "Maack", 167281112)
 
print("Academician")
print(academician.name)
print(academician.surname)
print(academician.number)

print("Staff")
print(staff.name)
print(staff.surname)
print(staff.number)

print("Student")
print(student.name)
print(student.surname)
print(student.number)
```

Output:

```
Academician
Baransel
Arslan
14092000

Staff
Oscar
Olson
16527187

Student
Holger
Maack
167281112
```

As you can see, you can call and use the properties and functions in the user object as you wish. Now, a question has come to our mind as follows; I can use the properties of the object I inherited, but what do I do when I want to add additional properties and functions.

## Python Overriding

When we processed the classes, we said that the constructor function `__init__()` was the reference of the class we created, and this function was running automatically. Therefore, when we want to use the new features, not the features of the function we inherited in our new class, we need to define the `__init__()` function for the new class. Let's show it now.

```python
class User:
    def __init__(self, name, surname, number):
        print("User class function")
        self.name = name
        self.surname = surname
        self.number = number
 
    def login(self):
        print("Signed In")
 
    def logout(self):
        print("Signed Out")
 
 
 
class Academician(User):
    def __init__(self, name, surname, number, birth_date):
        print("Academic class function")
        self.name = name
        self.surname = surname
        self.number = number
        self.birth_date = birth_date
 
academician = Academician("Baransel", "Arslan", 14092000, 2000)
print(academician.name)
academician.login()
```

Let's run our code;

```
Academic class function
Baransel
Signed In
```

We got an output like We no longer use the `__init__()` function of the `User` class, but the `__init__()` function of the `Academician` class. But we can also use other functions of the `User`. Now you will say that we used OOP and inheritance to avoid code duplication and write less code.

We recreated the features we created in the `User`. Of course there is a solution for this.

## `super()`

This function, ensures that the class it is in is inherited from a higher class, and you can use the features there.

Let's show it now;

Its general usage is as follows;

>```python
> super().__init__(parent_class_parameters)
>```

Let's do our example right now;

```python
class User:
    def __init__(self, name, surname, number):
        print("User class function")
        self.name = name
        self.surname = surname
        self.number = number
 
    def login(self):
        print("Signed In")
 
    def logout(self):
        print("Signed Out")
 
 
 
class Academician(User):
    def __init__(self, name, surname, number, birth_date):
        print("Academic class function")
        super().__init__(name, surname, number)
        self.birth_date = birth_date
 
academician = Academician("Baransel", "Arslan", 14092000, 2000)
```

Here, we did not recreate the `name`, `surname` and `number` properties that we created above. We inherit it with the `super()` function. 

Let's run the codes;

```
Academic class function
User class function
```

As you can see, both the `__init__()` function of the `User` class and the constructor method `__init__()` of the `Academician` class worked.

## You might also like

[Python Functions](https://baransel.dev/post/python-functions/)
[Python File Operations](https://baransel.dev/post/python-file-operations/)
[Python Set and Frozenset](https://baransel.dev/post/python-set-and-frozenset/)
[Python dictionary and dictionary methods](https://baransel.dev/post/python-dictionary-and-dictionary-methods/)
[Python tuple and tuple methods](https://baransel.dev/post/python-tuple-and-tuple-methods/)