Python OOP Concepts with Real-World Examples

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

Object-Oriented Programming (OOP) is a programming paradigm that relies on the concept of classes and objects. It is used to structure a software program into simple, reusable pieces of code blueprints (usually called classes), which are then used to create individual instances of objects. OOP focuses on using objects as the fundamental building blocks of the program.

Table of Contents

1. Classes and Objects
2. Inheritance
3. Polymorphism
4. Encapsulation
5. Abstraction

1. Classes and Objects

• Class: A class is a blueprint for creating objects. It defines a set of attributes and methods that the created objects will have.
• Object: An object is an instance of a class. It is a real-world entity that has attributes and behaviors defined by its class.

Real-World Example: School System

Example

class Student: def __init__(self, name, roll_no, grade): self.name = name self.roll_no = roll_no self.grade = grade def display_info(self): return f"Student: {self.name}, Roll No: {self.roll_no}, Grade: {self.grade}" # Creating objects of the Student class student1 = Student("Ravi", 101, "A") student2 = Student("Anjali", 102, "B") # Using the display_info method print(student1.display_info()) # Output: Student: Ravi, Roll No: 101, Grade: A print(student2.display_info()) # Output: Student: Anjali, Roll No: 102, Grade: B 

2. Inheritance

• Inheritance: Inheritance is a way to create a new class that is based on an existing class. The new class (child class) inherits attributes and methods from the existing class (parent class).

Real-World Example: Company Hierarchy

Example

class Employee: def __init__(self, name, employee_id): self.name = name self.employee_id = employee_id def display_info(self): return f"Employee: {self.name}, ID: {self.employee_id}" class Manager(Employee): def __init__(self, name, employee_id, department): super().__init__(name, employee_id) self.department = department def display_info(self): return f"Manager: {self.name}, ID: {self.employee_id}, Department: {self.department}" # Creating an object of the Manager class manager = Manager("Sita", "M123", "HR") # Using the display_info method print(manager.display_info()) # Output: Manager: Sita, ID: M123, Department: HR 

3. Polymorphism

• Polymorphism: Polymorphism allows methods to be used interchangeably between different classes. It allows the same method to be defined in different classes, with each class having its own implementation.

Real-World Example: Payment System

Example

class Payment: def make_payment(self, amount): pass class CreditCardPayment(Payment): def make_payment(self, amount): return f"Paid {amount} using Credit Card" class PayPalPayment(Payment): def make_payment(self, amount): return f"Paid {amount} using PayPal" def process_payment(payment_method, amount): print(payment_method.make_payment(amount)) # Creating objects of CreditCardPayment and PayPalPayment classes credit_card_payment = CreditCardPayment() paypal_payment = PayPalPayment() # Using the process_payment function process_payment(credit_card_payment, 1000) # Output: Paid 1000 using Credit Card process_payment(paypal_payment, 500) # Output: Paid 500 using PayPal 

4. Encapsulation

• Encapsulation: Encapsulation is the practice of hiding the internal state and functionality of an object and only exposing a limited interface. This is usually done by making attributes private (prefixing them with an underscore) and providing public methods to access and modify them.

Real-World Example: Bank Account

Example

class BankAccount: def __init__(self, owner, balance): self.owner = owner self.__balance = balance # Private attribute def deposit(self, amount): if amount > 0: self.__balance += amount else: print("Deposit amount must be positive") def withdraw(self, amount): if amount <= self.__balance: self.__balance -= amount else: print("Insufficient funds") def get_balance(self): return self.__balance # Creating an object of the BankAccount class account = BankAccount("Ravi", 1000) # Using public methods to interact with the private attribute account.deposit(500) print(account.get_balance()) # Output: 1500 account.withdraw(200) print(account.get_balance()) # Output: 1300 

5. Abstraction

• Abstraction: Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object. This can be achieved using abstract classes and methods.

Real-World Example: Animal Sounds

Example

from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def make_sound(self): pass class Dog(Animal): def make_sound(self): return "Bark" class Cat(Animal): def make_sound(self): return "Meow" # Creating objects of Dog and Cat classes dog = Dog() cat = Cat() # Using the make_sound method print(dog.make_sound()) # Output: Bark print(cat.make_sound()) # Output: Meow 

Conclusion

Object-Oriented Programming (OOP) in Python provides a powerful and flexible way to organize and manage code. By understanding and utilizing concepts such as classes, objects, inheritance, polymorphism, encapsulation, and abstraction, you can design and implement more robust and maintainable software. This tutorial covered the main OOP concepts in Python with real-world examples to help you understand how these concepts can be applied in practical scenarios.