Python OOPs Concepts: A Complete Guide

Core Principles of Python’s Object-Oriented Programming

1. Class
A class is a blueprint for creating objects. It contains the object’s data as well as the methods for working with it. A class does not consume memory on its own; memory is allocated when an object is created from the class.

Example:

class Employee:
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.salary = salary
    def show_details(self):
        print(f"Name: {self.name}, Age: {self.age}, Salary: {self.salary}")

2. Object
Objects are instances of a class. A class creates an object and allots memory for its data members when it is instantiated. Objects represent real-world entities with states and behaviors.

Example:

emp1 = Employee("John", 28, 50000)
emp1.show_details()
# Output: Name: John, Age: 28, Salary: 50000

3. Method
Python methods are routines that work on class instances. They have the ability to view and change the object’s properties.

4. Inheritance
A class (child) can inherit the attributes and functions of a parent class through inheritance. This promotes reusability and a hierarchical structure.

Example:

class Vehicle:
    def __init__(self, brand):
        self.brand = brand
    def show_brand(self):
        print(f"Brand: {self.brand}")

class Car(Vehicle):
    def __init__(self, brand, model):
        super().__init__(brand)
        self.model = model
    def show_model(self):
        print(f"Model: {self.model}")

car1 = Car("Toyota", "Corolla")
car1.show_brand()
car1.show_model()
# Output: Brand: Toyota
#         Model: Corolla

5. Polymorphism
A single interface can represent multiple types thanks to polymorphism. It permits objects of several classes to be regarded as belonging to the same superclass.

Example:

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Woof!")

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

animals = [Dog(), Cat()]
for animal in animals:
    animal.speak()
# Output: Woof!
#         Meow!

6. Encapsulation
Encapsulation binds data (attributes) and methods (functions) together and restricts direct access to them, protecting the object’s integrity. A double underscore prefix (__) can be used to make attributes secret.

Example:

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

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

7. Abstraction
Only the key characteristics are shown by abstraction, which conceals the implementation specifics. Abstract classes and interfaces are used to achieve this in more complex applications.