Introduction to Object-Oriented Programming (OOP) in Python

Course: Python Training

Topic: Introduction to Object-Oriented Programming (OOP)

Course Link: Python Training Course – JustAcademy

Demo Registration: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction to Object-Oriented Programming

Object-Oriented Programming (OOP) is a programming approach that organizes code around objects rather than only around individual functions and instructions. An object combines data, called attributes, with behavior, represented by methods.

Python supports multiple programming approaches, including procedural, functional, and object-oriented programming. OOP is particularly useful for applications that contain related entities, reusable components, and complex interactions between different parts of a system.

For example, a school management application may contain objects representing students, teachers, courses, and classrooms. Each object can maintain its own data and provide methods to perform relevant operations.

Learning Objectives

• Understand the meaning and purpose of OOP.
• Learn the difference between classes and objects.
• Understand attributes, methods, and constructors.
• Explore the four major principles of OOP.
• Create and use Python classes and objects.
• Understand inheritance, encapsulation, polymorphism, and abstraction.
• Apply OOP concepts to practical Python programs.
• Identify common OOP errors and follow good programming practices.

2. What Is Object-Oriented Programming?

Object-Oriented Programming is a methodology in which software is designed using classes and objects. A class defines the structure and behavior that its objects can have, while an object is an individual instance created from that class.

Consider a car as an example. A car has attributes such as its brand, color, and speed. It also has behaviors such as starting, accelerating, braking, and stopping.

In an OOP design, these attributes and behaviors can be grouped together in a Car class.

Example: Representing a Car

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def start(self):
        print(self.brand, "is starting")

    def stop(self):
        print(self.brand, "has stopped")

car1 = Car("Toyota", "White")

print(car1.brand)
print(car1.color)
car1.start()
car1.stop()

Output:

Toyota
White
Toyota is starting
Toyota has stopped

In this example, the Car class defines the structure and behavior of a car. The object car1 stores its own brand and color and can call the methods defined in the class.

3. Why Is OOP Important?

As applications grow, writing all code as unrelated functions and variables can make the program difficult to understand and maintain. OOP helps organize related data and operations into logical units.

Major Benefits of OOP

• Code reusability: Classes and inheritance allow developers to reuse existing functionality.
• Modularity: Programs can be divided into separate classes with clear responsibilities.
• Maintainability: Changes can often be made within a specific class without modifying unrelated code.
• Encapsulation: Data and the methods that operate on it can be grouped together, with controlled access where appropriate.
• Extensibility: New classes and behaviors can be introduced as requirements change.
• Polymorphism: Different objects can provide their own implementations of a common operation.
• Real-world modeling: Classes can represent entities such as employees, bank accounts, products, and customers.

Example Applications of OOP

4. Understanding Classes in Python

A class is a blueprint or template used to create objects. It defines attributes that describe an object's data and methods that describe its behavior.

Syntax of a Class

class ClassName:
    # Attributes and methods
    pass

The class keyword declares a class. The class name is usually written in PascalCase, where each word begins with a capital letter.

Example: Creating a Student Class

class Student:
    def display_message(self):
        print("Welcome to Python OOP")

student1 = Student()
student1.display_message()

Output:

Welcome to Python OOP

Explanation

1. class Student: defines a class named Student.
2. display_message() defines a method belonging to the class.
3. student1 = Student() creates an instance of the class.
4. student1.display_message() calls the method using that instance.

The pass statement can be used when a class or method needs to be declared temporarily without an implementation.

5. Understanding Objects in Python

An object is an instance of a class. Creating an object gives you a specific instance that can hold data and use the behavior defined by its class.

A single class can be used to create many objects. Each object can have different attribute values.

Example: Multiple Student Objects

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

student1 = Student("Aarav", 20)
student2 = Student("Priya", 22)

print(student1.name, student1.age)
print(student2.name, student2.age)

Output:

Aarav 20
Priya 22

Both objects belong to the same Student class, but they store different names and ages.

Class vs Object

6. Understanding Attributes

Attributes are variables associated with a class or an object. They represent the data or properties of an object.

Python commonly uses two categories of attributes: instance attributes and class attributes.

6.1 Instance Attributes

Instance attributes belong to individual objects. They are often initialized using self inside the __init__() method.

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

employee1 = Employee("Rohan", 40000)
employee2 = Employee("Ananya", 50000)

print(employee1.name, employee1.salary)
print(employee2.name, employee2.salary)

Output:

Rohan 40000
Ananya 50000

Each employee object has its own name and salary attributes.

6.2 Class Attributes

Class attributes are defined directly inside the class body, outside instance methods. They are available through the class and, when not shadowed, through its instances.

class Employee:
    company = "Tech Solutions"

    def __init__(self, name):
        self.name = name

employee1 = Employee("Rohan")
employee2 = Employee("Ananya")

print(employee1.name)
print(employee2.name)
print(Employee.company)

Output:

Rohan
Ananya
Tech Solutions

Use class attributes for data intended to be shared by instances. Be careful with mutable class attributes such as lists or dictionaries because changes to a shared object may affect multiple instances.

7. Understanding Methods in Python

Methods are functions defined inside a class. They describe actions that objects can perform or operations associated with the class.

Python commonly uses instance methods, class methods, and static methods.

7.1 Instance Methods

An instance method operates on a particular object. Its first parameter is conventionally named self, which refers to the instance on which the method is called.

class Calculator:
    def add(self, a, b):
        return a + b

calculator = Calculator()
print(calculator.add(10, 20))

Output:

30

7.2 Class Methods

A class method receives the class as its first argument, conventionally named cls. It is defined using the @classmethod decorator.

class Employee:
    company = "Tech Solutions"

    @classmethod
    def get_company(cls):
        return cls.company

print(Employee.get_company())

Output:

Tech Solutions

7.3 Static Methods

A static method is defined using @staticmethod. It does not automatically receive an instance or class reference. It is useful for a related utility operation that does not need instance or class state.

class MathUtility:
    @staticmethod
    def square(number):
        return number * number

print(MathUtility.square(5))

Output:

25

Method Types Comparison

8. Understanding the __init__() Constructor

The __init__() method is an initializer that Python calls automatically after creating a new instance. It is commonly used to initialize the object's attributes.

Although it is often called a constructor informally, __new__() is the method responsible for creating the instance, while __init__() initializes it.

Example

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def display(self):
        print("Product:", self.name)
        print("Price:", self.price)

product1 = Product("Keyboard", 1500)
product1.display()

Output:

Product: Keyboard
Price: 1500

Important Points

• __init__() is called automatically when an object is initialized.
• self refers to the current instance.
• Parameters allow each object to receive different initial values.
• __init__() should not return a non-None value.
• Default parameter values can make some constructor arguments optional.

Example with Default Values

class Student:
    def __init__(self, name, course="Python"):
        self.name = name
        self.course = course

student1 = Student("Aarav")
student2 = Student("Priya", "Data Analytics")

print(student1.name, student1.course)
print(student2.name, student2.course)

Output:

Aarav Python
Priya Data Analytics

9. Understanding self in Python

The self parameter represents the current instance inside an instance method. It allows the method to access or modify attributes and call other instance methods.

self is a naming convention rather than a reserved keyword, but using this conventional name makes Python code easier to understand.

Example

class Person:
    def __init__(self, name):
        self.name = name

    def introduce(self):
        print("My name is", self.name)

person1 = Person("Meera")
person1.introduce()

Output:

My name is Meera

When you call person1.introduce(), Python passes person1 as the instance argument automatically.

Why Is self Necessary?

• It connects instance methods to the current object.
• It allows each object to maintain its own attribute values.
• It helps distinguish instance attributes from local variables.
• It allows methods to update the state of an object.

10. The Four Major Principles of OOP

The four commonly taught principles of OOP are encapsulation, inheritance, polymorphism, and abstraction. They help developers design reusable, organized, and maintainable software.

11. Encapsulation

Encapsulation is the practice of grouping data and the methods that operate on it within a class. It also involves designing a clear interface for interacting with that data.

Python does not enforce traditional private access modifiers in the same way as some other languages. Instead, it uses naming conventions and mechanisms such as properties to communicate and manage access.

Example: Bank Account

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self._balance += amount

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Withdrawal must be positive")
        if amount > self._balance:
            raise ValueError("Insufficient balance")
        self._balance -= amount

account = BankAccount("Aarav", 1000)
account.deposit(500)
account.withdraw(200)

print(account.balance)

Output:

1300

Explanation

• owner stores the account holder's name.
• _balance uses a leading underscore to indicate that it is intended for internal use.
• The balance property provides a readable interface for retrieving the balance.
• deposit() and withdraw() validate operations before changing the balance.

A leading underscore is a convention, not strict access control. The purpose of the design is to encourage callers to use the account's methods instead of changing its internal state arbitrarily.

12. Inheritance

Inheritance allows a new class, called a child or subclass, to inherit attributes and methods from an existing class, called a parent or superclass. The child class can reuse existing behavior and add or override functionality.

Example: Single Inheritance

class Animal:
    def eat(self):
        print("This animal eats food")

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

dog = Dog()
dog.eat()
dog.bark()

Output:

This animal eats food
The dog barks

The Dog class inherits the eat() method from Animal and defines an additional bark() method.

Types of Inheritance

Example: Method Overriding

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

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

animal = Animal()
dog = Dog()

animal.sound()
dog.sound()

Output:

Animal makes a sound
Dog barks

The child class provides its own implementation of the inherited sound() method. This is called method overriding.

13. Using super() in Inheritance

The super() function provides access to methods in the next class in the method resolution order. It is commonly used to call a parent class's initializer or extend an inherited method.

Example

class Person:
    def __init__(self, name):
        self.name = name

class Student(Person):
    def __init__(self, name, course):
        super().__init__(name)
        self.course = course

    def display(self):
        print("Name:", self.name)
        print("Course:", self.course)

student = Student("Aarav", "Python")
student.display()

Output:

Name: Aarav
Course: Python

The call super().__init__(name) initializes the inherited name attribute through the parent class. The child class then initializes its own course attribute.

14. Polymorphism

Polymorphism means that the same operation or interface can be used with objects of different types, with each object providing suitable behavior.

Python supports polymorphism through method overriding, duck typing, and other mechanisms. Duck typing focuses on whether an object supports the operations needed by the code rather than requiring a specific class.

Example: Different Animals

class Dog:
    def sound(self):
        return "Bark"

class Cat:
    def sound(self):
        return "Meow"

class Cow:
    def sound(self):
        return "Moo"

animals = [Dog(), Cat(), Cow()]

for animal in animals:
    print(animal.sound())

Output:

Bark
Meow
Moo

Explanation

Each object supports the sound() method, but each class implements it differently. The loop does not need separate logic for dogs, cats, and cows.

Benefits of Polymorphism

• Reduces repeated conditional logic.
• Makes it easier to add new object types.
• Supports flexible interfaces.
• Improves extensibility and code reuse.

15. Abstraction

Abstraction means exposing essential operations while hiding unnecessary implementation details. It allows developers to work with a simple interface without needing to know every detail of how an operation is implemented.

Python supports formal abstraction through the abc module, which provides abstract base classes and the @abstractmethod decorator.

Example: Abstract Payment Method

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CardPayment(Payment):
    def pay(self, amount):
        print("Processing card payment of", amount)

class UpiPayment(Payment):
    def pay(self, amount):
        print("Processing UPI payment of", amount)

card = CardPayment()
upi = UpiPayment()

card.pay(1000)
upi.pay(500)

Output:

Processing card payment of 1000
Processing UPI payment of 500

Explanation

• Payment defines a common interface for payment operations.
• @abstractmethod declares a method that concrete subclasses must implement.
• CardPayment and UpiPayment provide their own implementations.
• The abstract Payment class itself cannot be instantiated while it has unresolved abstract methods.

16. Understanding Object State and Behavior

An object's state is represented by its current attribute values. Its behavior is represented by the methods it can perform.

Example

class Light:
    def __init__(self):
        self.is_on = False

    def turn_on(self):
        self.is_on = True

    def turn_off(self):
        self.is_on = False

    def display_status(self):
        print("Light is on:", self.is_on)

light = Light()
light.display_status()

light.turn_on()
light.display_status()

light.turn_off()
light.display_status()

Output:

Light is on: False
Light is on: True
Light is on: False

The value of is_on represents the light's state. The methods change or display that state.

17. Instance Attributes vs Class Attributes

Understanding the difference between instance attributes and class attributes is important when designing classes.

class Employee:
    organization = "JustAcademy"

    def __init__(self, name):
        self.name = name

employee1 = Employee("Aarav")
employee2 = Employee("Priya")

print(employee1.name)
print(employee2.name)
print(employee1.organization)
print(employee2.organization)

Output:

Aarav
Priya
JustAcademy
JustAcademy

The name attribute belongs to each instance, whereas organization is defined on the class and is shared unless an instance shadows it with an attribute of the same name.

18. Composition: Building Objects from Other Objects

Composition is a design technique in which one object contains or uses another object. Instead of relying entirely on inheritance, composition allows classes to work together by delegating tasks to other objects.

Example: Car and Engine

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()

    def start_car(self):
        self.engine.start()
        print("Car is ready")

car = Car()
car.start_car()

Output:

Engine started
Car is ready

The Car object uses an Engine object to perform part of its work. This is an example of a has-a relationship: a car has an engine.

Inheritance vs Composition

19. Special Methods in Python Classes

Python provides special methods, often called dunder methods because their names begin and end with double underscores. These methods let objects interact with built-in language operations.

Example: Using __str__()

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return f"{self.title} by {self.author}"

book = Book("Python Basics", "A. Sharma")
print(book)

Output:

Python Basics by A. Sharma

The print() function uses the object's string representation. Defining __str__() makes the output more informative than the default object representation.

20. OOP vs Procedural Programming

Procedural programming organizes code around procedures or functions, while OOP organizes related data and behavior around objects. Both approaches are useful, and Python allows them to be combined within the same application.

21. Practical Mini Project: Student Management System

This mini project demonstrates how classes, objects, attributes, methods, and encapsulation can work together in a simple student management program.

Project Requirements

• Create a class named Student.
• Store the student's name, roll number, and marks.
• Provide a method to display student details.
• Provide a method to calculate the average marks.
• Validate the marks to ensure each value is between 0 and 100.

Python Implementation

class Student:
    def __init__(self, name, roll_number, marks):
        if not all(0 <= mark <= 100 for mark in marks):
            raise ValueError("Marks must be between 0 and 100")

        self.name = name
        self.roll_number = roll_number
        self.marks = list(marks)

    def display_details(self):
        print("Name:", self.name)
        print("Roll Number:", self.roll_number)
        print("Marks:", self.marks)

    def calculate_average(self):
        if not self.marks:
            return 0
        return sum(self.marks) / len(self.marks)

    def get_result(self):
        average = self.calculate_average()
        if average >= 40:
            return "Pass"
        return "Needs improvement"

student1 = Student("Aarav", 101, [75, 80, 85])

student1.display_details()
print("Average:", student1.calculate_average())
print("Result:", student1.get_result())

Output:

Name: Aarav
Roll Number: 101
Marks: [75, 80, 85]
Average: 80.0
Result: Pass

Project Explanation

1. The Student class defines the structure of a student record.
2. The __init__() method validates the marks and initializes attributes.
3. The display_details() method prints the student's information.
4. The calculate_average() method calculates the average of the marks.
5. The get_result() method returns a result based on the average.
6. The student1 object represents one specific student.

Possible Enhancements

• Add methods to update marks.
• Support multiple student objects.
• Store and retrieve student records from a file or database.
• Introduce a separate Course class.
• Add unit tests for validation and average calculation.

22. Common OOP Errors and Troubleshooting

22.1 Forgetting self

Problem: An instance method is defined without its expected instance parameter.

class Student:
    def display():
        print("Student details")

Solution: Define the method with self when it is intended to be an instance method.

class Student:
    def display(self):
        print("Student details")

22.2 Forgetting to Create an Object

Problem: An instance method is called on the class without providing the required instance.

Solution: Create an object first or use a class method or static method when that better matches the operation.

22.3 Incorrect Attribute Names

Problem: Python raises AttributeError because the requested attribute does not exist on the object or its class.

Solution: Check spelling, initialization, and whether the attribute belongs to the instance or class.

22.4 Incorrect Constructor Arguments

Problem: The object is created with a missing or extra argument.

Solution: Compare the arguments passed during object creation with the parameters defined in __init__().

22.5 Overusing Inheritance

Problem: A class hierarchy becomes difficult to understand because inheritance is used only to reuse a small piece of functionality.

Solution: Consider composition, helper functions, or separate components when there is no genuine is-a relationship.

22.6 Modifying Shared Mutable Class Attributes

Problem: Multiple objects unexpectedly share a list or dictionary defined on the class.

Solution: Initialize mutable data separately for each instance when each object needs its own copy.

class Team:
    def __init__(self):
        self.members = []

team1 = Team()
team2 = Team()

team1.members.append("Aarav")

print(team1.members)
print(team2.members)

Output:

['Aarav']
[]

23. Best Practices for Writing OOP Code

• Give classes clear names using PascalCase, such as BankAccount.
• Use descriptive method and attribute names.
• Keep each class focused on a clear responsibility.
• Use instance attributes for data that varies between objects.
• Use class attributes only for data intended to be shared.
• Validate input before changing important object state.
• Use properties or methods when controlled access to data is helpful.
• Prefer composition when one object uses another object rather than being a specialized form of it.
• Use inheritance when there is a meaningful is-a relationship.
• Follow established Python conventions and document complex behavior.
• Write tests for important methods and edge cases.
• Avoid adding classes when a simple function or data structure is clearer.

24. Practice Exercises

Exercise 1: Create a Car Class

Create a Car class with attributes for brand, model, and year. Add a method that displays the details of the car.

Exercise 2: Create a Bank Account

Create a BankAccount class with deposit and withdrawal methods. Validate the transaction amount and prevent withdrawals that exceed the available balance.

Exercise 3: Practice Inheritance

Create a parent class named Employee and child classes named Developer and Designer. Give each child class a method that describes its role.

Exercise 4: Practice Polymorphism

Create three classes that each implement a calculate_area() method for a different shape. Store objects in a list and call the method on each object.

Exercise 5: Practice Abstraction

Use ABC and @abstractmethod to define an abstract Notification class. Create subclasses that implement an appropriate notification method.

Exercise 6: Practice Composition

Create a Computer class that contains a Processor object. Add a method that uses the processor's behavior.

Exercise 7: Build a Library System

Create Book, Member, and Library classes. Add functionality to register books, track borrowing, and return books.

25. Interview Questions and Answers

Q1. What is OOP?

Answer: Object-Oriented Programming is a programming approach that organizes related data and behavior using classes and objects.

Q2. What is a class?

Answer: A class is a blueprint that defines the attributes and methods its instances can have.

Q3. What is an object?

Answer: An object is an instance of a class that can maintain state and use the behavior defined by the class.

Q4. What is self in Python?

Answer: self is the conventional first parameter of an instance method and refers to the current instance.

Q5. What is __init__()?

Answer: __init__() is an initializer called after an instance is created. It commonly sets up the object's initial attributes.

Q6. What are the four main principles of OOP?

Answer: Encapsulation, inheritance, polymorphism, and abstraction.

Q7. What is inheritance?

Answer: Inheritance allows a child class to reuse or specialize behavior from a parent class.

Q8. What is polymorphism?

Answer: Polymorphism allows different object types to respond to the same operation or interface with their own behavior.

Q9. What is encapsulation?

Answer: Encapsulation groups related data and behavior and provides an interface for interacting with an object's state.

Q10. What is abstraction?

Answer: Abstraction exposes essential operations while hiding unnecessary implementation details.

Q11. What is method overriding?

Answer: Method overriding occurs when a subclass provides its own implementation of a method inherited from a parent class.

Q12. What is the purpose of super()?

Answer: super() provides access to methods in the next class in the method resolution order, often to extend inherited initialization or behavior.

Q13. What is the difference between a class attribute and an instance attribute?

Answer: A class attribute is defined on the class and can be shared by instances, while an instance attribute belongs to an individual object.

Q14. What is composition?

Answer: Composition is a design approach in which an object contains or uses other objects to perform its responsibilities.

Q15. When should you avoid OOP?

Answer: OOP may be unnecessary for very small scripts or simple transformations where a few functions and data structures provide a clearer solution.

26. Quick Revision Checklist

• OOP organizes code around classes and objects.
• A class defines attributes and methods.
• An object is an instance of a class.
• self refers to the current instance in instance methods.
• __init__() initializes an instance after creation.
• Instance attributes store object-specific data.
• Class attributes are defined on the class.
• Instance, class, and static methods serve different purposes.
• Encapsulation groups data and behavior behind a suitable interface.
• Inheritance supports specialization and reuse.
• Polymorphism allows a common operation to work with different object types.
• Abstraction exposes essential operations while hiding implementation details.
• Composition allows objects to collaborate with other objects.
• Special methods customize how objects work with Python operations.
• Good class design emphasizes clarity, focused responsibilities, and testability.

27. Conclusion

Object-Oriented Programming is an important part of Python because it provides a structured way to model entities, manage state, and organize application behavior. Understanding classes, objects, attributes, methods, and initializers provides the foundation for learning more advanced OOP techniques.

The four major principles—encapsulation, inheritance, polymorphism, and abstraction—help developers design software that is easier to reuse, extend, test, and maintain. Composition and appropriate use of special methods provide additional tools for building well-structured Python applications.

Practise by building small projects such as a student management system, bank account application, or library system. These exercises help connect OOP concepts to real programming problems.

Explore more Python learning resources through the following JustAcademy links:

• Explore the Python Training Course
• Register for a Course Demo
• Visit the JustAcademy Website