Python OOP Concepts with 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 based on the concept of objects, which can contain data in the form of attributes (fields or properties) and code in the form of methods (functions). Python is an object-oriented programming language that allows you to create and manipulate objects. This tutorial covers the main OOP concepts in Python, including classes, objects, inheritance, polymorphism, encapsulation, and abstraction.

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.

Example

class Car: def __init__(self, brand, model, year): self.brand = brand self.model = model self.year = year def display_info(self): return f"Car: {self.brand} {self.model}, Year: {self.year}" # Creating objects of the Car class car1 = Car("Toyota", "Corolla", 2020) car2 = Car("Honda", "Civic", 2019) # Using the display_info method print(car1.display_info()) # Output: Car: Toyota Corolla, Year: 2020 print(car2.display_info()) # Output: Car: Honda Civic, Year: 2019 

2. 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).

Example

class Vehicle: def __init__(self, brand, model): self.brand = brand self.model = model def display_info(self): return f"Vehicle: {self.brand} {self.model}" class Car(Vehicle): def __init__(self, brand, model, year): super().__init__(brand, model) self.year = year def display_info(self): return f"Car: {self.brand} {self.model}, Year: {self.year}" # Creating an object of the Car class car = Car("Tesla", "Model S", 2022) # Using the display_info method print(car.display_info()) # Output: Car: Tesla Model S, Year: 2022 

3. 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.

Example

class Bird: def make_sound(self): return "Tweet" class Dog: def make_sound(self): return "Bark" def animal_sound(animal): print(animal.make_sound()) # Creating objects of Bird and Dog classes bird = Bird() dog = Dog() # Using the animal_sound function animal_sound(bird) # Output: Tweet animal_sound(dog) # Output: Bark 

4. 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.

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 # Attempting to access the private attribute directly (will raise an AttributeError) # print(account.__balance) # AttributeError: 'BankAccount' object has no attribute '__balance' 

5. 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.

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 examples to help you get started with OOP in Python.