Python - Inheritance, encapsulation, and polymorphism

Inheritance, Encapsulation, and Polymorphism in Python

In Python, object-oriented programming is based on the three important pillars which are inheritance, encapsulation, and polymorphism. These ideas facilitate the creation of modular, reusable, and maintainable code.

Inheritance

Inheritance is a process in which an object automatically inherits all the properties and behavior of its parent object in such a way that we can reuse, extend, or modify the properties and behaviors defined in the class.

Code repetition and redundancy can be minimized and facilitated by allowing a class (child class) to inherit methods and attributes from another class (parent class).

Encapsulation

Encapsulation is the process of combining data and functions into a single unit called a class. In encapsulation, the data is not directly accessed; It is accessed through functions inside the class.

Private variables and methods are used to accomplish encapsulation, which limits access to certain parts of an object. This ensures that the external representation of an object is hidden from view.

Polymorphism

In Python, polymorphism is the ability to present the same interface to different underlying forms (data types) with polymorphism. Each of these classes will have different underlying data.

It is possible to consider objects of distinct classes as belonging to the same superclass thanks to polymorphism. It's the capacity to apply a common procedure to many things in various ways.

Python supports mainly two types of polymorphism:

Compile time polymorphism (static polymorphism):

Polymorphism implemented at compile time is known as compile-time polymorphism. This is typically achieved through operator overloading.

Operator overloading: Customizing the behavior of operators (+, -, *, etc.) for user-defined classes. This allows operators to operate differently depending on the context (i.e., the type of operand).

Example

In this example, let's demonstrate the workflow of compile time polymorphism:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"Point({self.x}, {self.y})"

p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2
print(p3)

Run time polymorphism (Dynamic Polymorphism):

Runtime polymorphism is achieved by method overriding, the call to the function is scheduled at runtime which is known as runtime polymorphism, or dynamic polymorphism.

Method Overriding: It is achieved when the child class contains a method that already exists

Parent class. When the child class overrides the method of the parent class then parent and child have the same function in different definitions.

Example

In this example, let's demonstrate the workflow of runtime polymorphism:

class Animal:
    def sound(self):
        return "Some sound"

class Dog(Animal):
    def sound(self):
        return "Bark"

class Cat(Animal):
    def sound(self):
        return "Meow"

def make_sound(animal):
    print(animal.sound())

dog = Dog()
cat = Cat()
make_sound(dog)
make_sound(cat)

Example

In this example, let's use a code sample to demonstrate these ideas. It has a Vehicle class (parent) and two subclasses, Car and Truck.

# Parent class
class Vehicle:
    def __init__(self, make, year):
        self._make = make # Protected variable (encapsulation)
        self._year = year # Protected variable (encapsulation)

    def display_info(self): # Polymorphic method
        print(f"Vehicle Info: {self._year} {self._make}")

# Child class 1
class Car(Vehicle): # Inheritance
    def __init__(self, make, year, model):
        super().__init__(make, year) # Call to parent class constructor

        self._model = model # Protected variable (encapsulation)
    def display_info(self): # Method overriding (polymorphism)
        print(f"Car Info: {self._year} {self._make} {self._model}")

# Child class 2
class Truck(Vehicle): # Inheritance
    def __init__(self, make, year, capacity):
        super().__init__(make, year) # Call to parent class constructor
        self._capacity = capacity # Protected variable (encapsulation)

    def display_info(self): # Method overriding (polymorphism)
        print(f"Truck Info: {self._year} {self._make}, Capacity: {self._capacity} tons")

# Creating objects
vehicle = Vehicle("Generic", 2010)
car = Car("Honda", 2020, "Civic")
truck = Truck("Ford", 2018, 10)

# Demonstrating polymorphism
for v in [vehicle, car, truck]:
    v.display_info()

Explanations

The protected variables _make and _year, which represent encapsulation, are part of the parent class Vehicle.

To demonstrate inheritance, consider the subclasses Car and Truck, which derive from Vehicle.

To show polymorphism, both Truck and Car override the Vehicle's display_info function. For both Car and Truck objects, this method yields distinct behaviors, while being called in the same way.

At the conclusion, a loop iterates over instances of Vehicle, Car, and Truck, invoking their respective display_info methods. This further demonstrates polymorphism by resolving at runtime to the proper method for each object.

Summary

Inheritance, encapsulation, and polymorphism are fundamental concepts in modular and extensible system design, and this code sample successfully exemplifies them.