**Inheritance**
in Python is a feature of **Object-Oriented Programming (OOP)** that allows one
class (called the **child** or **derived class**) to inherit attributes and
methods from another class (called the **parent** or **base class**).
Inheritance promotes code reuse and allows for creating a class hierarchy where
more specialized classes build upon the features of more general ones.
### Key
Concepts of Inheritance:
1.
**Parent/Base Class**: The class whose attributes and methods are inherited.
2.
**Child/Derived Class**: The class that inherits from the parent class and can
extend or override its features.
### Syntax
for Inheritance:
```python
class ParentClass:
# Parent class attributes and methods
def __init__(self, attr):
self.attr = attr
def parent_method(self):
print(f"This is a method in the parent
class. Attr: {self.attr}")
class
ChildClass(ParentClass):
# Child class extends ParentClass
def child_method(self):
print("This is a method in the
child class.")
```
### Example
of Basic Inheritance:
```python
# Parent
class
class
Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a
sound.")
# Child
class (inherits from Animal)
class
Dog(Animal):
def speak(self):
print(f"{self.name} barks.")
# Create
instances of both classes
animal =
Animal("Generic Animal")
dog =
Dog("Buddy")
animal.speak() # Output: Generic Animal makes a sound.
dog.speak() # Output: Buddy barks.
```
### How
Inheritance Works:
1. **Child
classes** can access the methods and attributes of the parent class.
2.
**Overriding Methods**: Child classes can override parent class methods by
defining them with the same name.
3. **Super
Function**: The `super()` function is used to call methods from the parent
class within the child class.
### 1.
**Overriding Parent Methods**:
In a child
class, you can **override** the parent class’s method by redefining it.
```python
class
Bird(Animal):
def speak(self):
print(f"{self.name} chirps.")
# Creating
an object of the Bird class
bird =
Bird("Parrot")
bird.speak() # Output: Parrot chirps.
```
### 2.
**Using the `super()` Function**:
The
`super()` function allows you to call methods from the parent class in the
child class. This is especially useful when you want to extend (rather than
completely override) the functionality of the parent method.
####
Example:
```python
class
Cat(Animal):
def __init__(self, name, breed):
super().__init__(name) # Call the parent class constructor
self.breed = breed
def speak(self):
super().speak() # Call the parent class method
print(f"{self.name} meows and is of
the {self.breed} breed.")
# Creating
an object of the Cat class
cat =
Cat("Whiskers", "Siamese")
cat.speak()
# Output:
# Whiskers
makes a sound.
# Whiskers
meows and is of the Siamese breed.
```
### 3.
**Multiple Inheritance**:
Python
supports **multiple inheritance**, where a class can inherit from more than one
parent class.
####
Example:
```python
class A:
def method_a(self):
print("Method from class A")
class B:
def method_b(self):
print("Method from class B")
# Class C
inherits from both A and B
class C(A,
B):
pass
# Creating
an object of class C
c = C()
c.method_a() # Output: Method from class A
c.method_b() # Output: Method from class B
```
### 4.
**Method Resolution Order (MRO)**:
In the case
of multiple inheritance, Python follows the **Method Resolution Order (MRO)**
to determine which parent’s method should be invoked first. You can check the
MRO of a class using `ClassName.mro()` or `ClassName.__mro__`.
####
Example:
```python
print(C.mro())
# Output:
[<class '__main__.C'>, <class '__main__.A'>, <class
'__main__.B'>, <class 'object'>]
```
### 5.
**Types of Inheritance**:
Python
supports various types of inheritance:
1. **Single
Inheritance**: A single child class inherits from one parent class.
```python
class Parent:
pass
class Child(Parent):
pass
```
2.
**Multiple Inheritance**: A child class inherits from more than one parent
class.
```python
class Parent1:
pass
class Parent2:
pass
class Child(Parent1, Parent2):
pass
```
3.
**Multilevel Inheritance**: A class inherits from another class, which in turn
inherits from another class.
```python
class GrandParent:
pass
class Parent(GrandParent):
pass
class Child(Parent):
pass
```
4.
**Hierarchical Inheritance**: Multiple child classes inherit from a single
parent class.
```python
class Parent:
pass
class Child1(Parent):
pass
class Child2(Parent):
pass
```
5. **Hybrid
Inheritance**: A combination of multiple types of inheritance.
```python
class A:
pass
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
```
### Benefits
of Inheritance:
1. **Code
Reusability**: The parent class's functionality can be reused in child classes.
2.
**Maintainability**: Centralizing functionality in a base class makes it easier
to maintain and extend.
3.
**Extensibility**: Child classes can add or modify functionality, enabling more
specialized behavior without altering the parent class.
4.
**Polymorphism**: Enables objects of different classes to be treated as
instances of the parent class, allowing methods to be overridden and creating
flexible code.
### Summary:
-
**Inheritance** allows child classes to inherit attributes and methods from
parent classes.
- Child
classes can **override** or **extend** parent class methods.
- The
`super()` function enables calling the parent class methods from within the
child class.
- Python
supports **multiple inheritance** and follows the **MRO** to resolve method
calls in the case of multiple parent classes.
Inheritance
is a fundamental concept in Python's OOP model that helps in organizing code,
promoting reusability, and implementing class hierarchies efficiently.
