Python - Inheritance, encapsulation, and polymorphism

Inheritance, Encapsulation, and Polymorphism in Python

Introduction

Object-Oriented Programming (OOP) is a foundational concept in Python that allows developers to structure software in a way that is easy to manage and scale. Three of the most essential principles of OOP are Inheritance, Encapsulation, and Polymorphism. These principles provide the mechanisms for reusability, data hiding, and behavior customization.

Understanding these concepts enables developers to write cleaner, more modular, and reusable code. Python, being a highly versatile language, supports all these OOP principles with concise and expressive syntax.

Inheritance

What is Inheritance?

Inheritance allows one class (called the child or subclass) to inherit the properties and behaviors (methods) from another class (called the parent or superclass). This promotes code reuse and logical hierarchy.

Syntax of Inheritance

class Parent:
    def method1(self):
        print("Parent method")

class Child(Parent):
    def method2(self):
        print("Child method")

Creating Instances

obj = Child()
obj.method1()  # Inherited from Parent
obj.method2()  # Defined in Child

Types of Inheritance

Single Inheritance

In single inheritance, a child class inherits from one parent class.

class Animal:
    def move(self):
        print("Animal moves")

class Dog(Animal):
    def bark(self):
        print("Dog barks")

Multiple Inheritance

A class can inherit from more than one parent class.

class Father:
    def skills(self):
        print("Gardening, Programming")

class Mother:
    def skills(self):
        print("Cooking, Art")

class Child(Father, Mother):
    pass

obj = Child()
obj.skills()  # Inherits from the first parent listed

Multilevel Inheritance

A class is derived from a class which is also derived from another class.

class Grandparent:
    def house(self):
        print("Owns a house")

class Parent(Grandparent):
    def car(self):
        print("Owns a car")

class Child(Parent):
    def bike(self):
        print("Owns a bike")

Hierarchical Inheritance

Multiple child classes inherit from the same parent class.

class Vehicle:
    def engine(self):
        print("Engine exists")

class Car(Vehicle):
    def wheels(self):
        print("4 wheels")

class Bike(Vehicle):
    def wheels(self):
        print("2 wheels")

Method Overriding

A subclass can override a method from the superclass.

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

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

Using super()

The super() function is used to call methods from the parent class.

class A:
    def show(self):
        print("A's show")

class B(A):
    def show(self):
        super().show()
        print("B's show")

Encapsulation

What is Encapsulation?

Encapsulation is the practice of bundling the data (variables) and methods that operate on the data into a single unit, typically a class. It also involves restricting direct access to some components, which is a means of preventing accidental interference and misuse.

Access Modifiers in Python

Python doesn’t enforce access restrictions as strictly as languages like Java or C++, but it provides naming conventions to indicate the intended scope.

• Public Members: Accessible from anywhere.
• Protected Members (_name): Should not be accessed outside the class and its subclasses.
• Private Members (__name): Accessible only within the class.

Example of Encapsulation

class Employee:
    def __init__(self, name, salary):
        self.name = name          # public
        self._department = "IT"   # protected
        self.__salary = salary    # private

    def display(self):
        print(f"Name: {self.name}, Salary: {self.__salary}")

Accessing Private Members

emp = Employee("Alice", 70000)
emp.display()

# print(emp.__salary) → This will raise an error
print(emp._Employee__salary)  # Name mangling to access private variable

Getter and Setter Methods

To safely access and modify private attributes, you use getters and setters.

class Product:
    def __init__(self):
        self.__price = 100

    def get_price(self):
        return self.__price

    def set_price(self, price):
        if price > 0:
            self.__price = price

Encapsulation Benefits

• Improves code modularity
• Restricts unauthorized access
• Makes code easier to maintain
• Protects internal object state

Polymorphism

What is Polymorphism?

Polymorphism means “many forms.” In Python, it allows methods to perform different tasks depending on the object calling them. This can happen through method overriding or operator overloading.

Polymorphism Through Method Overriding

class Bird:
    def fly(self):
        print("Birds can fly")

class Penguin(Bird):
    def fly(self):
        print("Penguins cannot fly")

Polymorphism with Functions and Objects

class Cat:
    def speak(self):
        print("Meow")

class Dog:
    def speak(self):
        print("Bark")

def animal_sound(animal):
    animal.speak()

animal_sound(Cat())
animal_sound(Dog())

Duck Typing

In Python, duck typing allows polymorphism by relying on the presence of certain methods and properties rather than the object's type.

class File:
    def read(self):
        print("Reading file")

class NetworkStream:
    def read(self):
        print("Reading from network")

def process(obj):
    obj.read()

Operator Overloading

You can define custom behavior for operators by overloading magic methods.

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)

p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2  # Internally calls p1.__add__(p2)

Polymorphism Benefits

• Enables flexibility and extensibility in code
• Encourages code reuse
• Reduces code complexity

Combining All Three Concepts

Example: A Banking System

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds")

    def get_balance(self):
        return self.__balance

class SavingsAccount(Account):
    def __init__(self, owner, balance, interest_rate):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def add_interest(self):
        interest = self.get_balance() * self.interest_rate
        self.deposit(interest)

class CurrentAccount(Account):
    def withdraw(self, amount):
        print("Overriding withdrawal for Current Account")
        super().withdraw(amount)

Using Polymorphism

def print_balance(account):
    print(f"{account.owner}'s balance is: {account.get_balance()}")

a = SavingsAccount("Alice", 1000, 0.05)
b = CurrentAccount("Bob", 2000)

print_balance(a)
print_balance(b)

Real-World Applications

• Web Frameworks: Use classes and inheritance to model request/response cycles.
• Games: Entities like players, enemies, and items use polymorphism to perform actions.
• Data Science Pipelines: Encapsulate preprocessing and modeling steps in classes.

Best Practices

• Use inheritance when classes are logically related.
• Do not overuse inheritance; prefer composition if possible.
• Keep instance variables private or protected unless necessary.
• Use getters and setters for controlled access.
• Rely on polymorphism to reduce conditional code and simplify function logic.

Mastering inheritance, encapsulation, and polymorphism is essential for writing clean and scalable object-oriented Python programs. Inheritance enables code reuse, encapsulation protects object integrity, and polymorphism makes code flexible and extensible. These three pillars form the foundation of object-oriented programming in Python and are crucial for building professional-grade software systems. By understanding and applying these principles effectively, you can design systems that are robust, modular, and easy to maintain.