Python is a versatile language that supports both procedural and object-oriented programming (OOP). OOP is a programming paradigm that organizes code using objects and classes, making it more modular, reusable, and easier to maintain.

In this blog, we will explore the four main OOP principles in Python with simple explanations and examples.

1. What is Object-Oriented Programming (OOP)?

Object-Oriented Programming (OOP) is a way of structuring code using objects, which are instances of classes. These objects store data (attributes) and behavior (methods), making it easier to manage complex programs.

2. Key OOP Concepts in Python

1. Class and Object

• A class is a blueprint for creating objects.

• An object is an instance of a class with its own data and behavior.

Example: Creating a Class and Object in Python

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
    
    def show_info(self):
        print(f"Car: {self.brand} {self.model}")

# Creating an object
car1 = Car("Tesla", "Model S")
car1.show_info()  # Output: Car: Tesla Model S

2. Encapsulation (Data Hiding)

Encapsulation means restricting direct access to object data and only allowing modification through methods. In Python, we use private variables (prefix _ or __) to achieve this.

Example: Encapsulation in Python

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private variable
    
    def deposit(self, amount):
        self.__balance += amount
    
    def get_balance(self):
        return self.__balance

# Creating an object
account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # Output: 1500

Here, __balance is hidden from direct access, enforcing data security.

3. Inheritance (Reusability)

Inheritance allows a class to inherit attributes and methods from another class. This promotes code reuse and avoids duplication.

Example: Inheritance in Python

class Animal:
    def speak(self):
        print("Animal makes a sound")

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

# Creating objects
a = Animal()
a.speak()  # Output: Animal makes a sound

d = Dog()
d.speak()  # Output: Dog barks

Here, Dog inherits from Animal but also overrides the speak() method.

4. Polymorphism (Multiple Forms of a Function)

Polymorphism allows different classes to have methods with the same name but different behavior.

Example: Polymorphism in Python

class Bird:
    def sound(self):
        print("Bird chirps")

class Cat:
    def sound(self):
        print("Cat meows")

# Function using polymorphism
def make_sound(animal):
    animal.sound()

# Calling the function with different objects
b = Bird()
c = Cat()
make_sound(b)  # Output: Bird chirps
make_sound(c)  # Output: Cat meows

Conclusion

OOP in Python makes code more organized, reusable, and scalable. The four key OOP principles are:

✅ Encapsulation – Hides sensitive data.
✅ Inheritance – Allows code reuse.
✅ Polymorphism – Lets functions work with different objects.
✅ Classes & Objects – Form the building blocks of OOP.

By mastering these concepts, you’ll write cleaner and more efficient Python code! 🚀