Object-Oriented Programming

Object-oriented programming (OOP) is a programming paradigm that organizes code around objects. Python provides powerful OOP features that make it easier to build reusable, maintainable, and extensible applications.

Topics Covered

In this module, you’ll learn:

OOP Refresher
Class Members vs Instance Members
Class Methods
Static Methods
Magic (Dunder) Methods
Abstract Base Classes (ABC)
Multiple Inheritance
Method Resolution Order (MRO)
Best Practices

Try Yourself: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

By the end of this module, you’ll understand how Python objects work internally, customize object behavior, design reusable class hierarchies, and apply advanced OOP concepts effectively.

OOP Refresher

Before exploring advanced concepts, let’s quickly revisit the fundamentals of object-oriented programming.

What is OOP?

Object-Oriented Programming (OOP) is a programming paradigm that organizes code around objects. An object combines:

Attributes (data)
Methods (behavior)

Class and Object

A class is a blueprint for creating objects. An object is an instance of a class.

class Student:

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

    def introduce(self):
        print(f"My name is {self.name}")

student = Student("Alice")

student.introduce()

Output ?

Show Output

My name is Alice

The Four Pillars of OOP

Python supports four fundamental principles of OOP.

Principle	Purpose
Encapsulation	Bundle data and methods together
Abstraction	Hide implementation details
Inheritance	Reuse existing classes
Polymorphism	One interface, multiple implementations

In this module, we’ll build upon these fundamentals and explore advanced OOP concepts.

Everything in Python is an Object

Python follows an object-oriented design where everything is an object—numbers, strings, lists, dictionaries, functions, modules, and even classes. Every object has:

Identity (id())
Type (type())
State (data)
Behavior (methods)

Classes are Objects Too

A common misconception is that only instances are objects. In reality, classes themselves are also objects.

class Student:
    pass

print(type(Student))
print(type(int))
print(type(str))
print(type(list))

What Happens When Python Creates a Class?

When Python executes a class definition, it performs these steps internally:

Reads the class statement.
Creates a temporary namespace (dictionary).
Executes every statement inside the class body.
Collects all attributes and methods into the namespace.
Calls type(class_name, bases, namespace).
type creates the new class object.
Assigns the class object to the class name.

When a class inherits from another class, the base classes are passed as the bases argument to type().

Creating a Class Dynamically Using `type()`

Normally, we define classes statically using the class keyword. However, because classes are objects created by type, you can use the type() function as a constructor to create a class dynamically at runtime. The signature of type() for class creation is:

type(class_name, bases, attributes_and_methods_dict)

Example: Static vs. Dynamic Class Creation

Let’s compare the standard static way with the dynamic type() method: 1. The Static Way (Standard):

class Student:
    college = "ABC College"

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

    def introduce(self):
        return f"My name is {self.name} and I study at {self.college}"

2. The Dynamic Way (Using type):

# Define a function to use as a method
def introduce_method(self):
    return f"My name is {self.name} and I study at {self.college}"

# Define the initializer function
def init_method(self, name):
    self.name = name

# Create the class dynamically
DynamicStudent = type(
    "Student",                # Class name
    (object,),                # Base classes (tuple of parent classes)
    {                         # Attributes and methods namespace dictionary
        "college": "ABC College",
        "__init__": init_method,
        "introduce": introduce_method
    }
)

# Instantiate and use the dynamically created class
student = DynamicStudent("Alice")
print(student.introduce())

Output ?

Show Output

My name is Alice and I study at ABC College

<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>

Every class is an instance of the built-in type class. When you define a class, Python is actually creating a new custom type.

student = Student()
print(type(student))

Output:

<class '__main__.Student'>

Class Members vs Instance Members

A class can contain both instance members and class members.

Instance Members

Instance members belong to individual objects. Each object maintains its own copy.

class Student:

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

student1 = Student("Alice")
student2 = Student("Bob")

print(student1.name)
print(student2.name)

Output ?

Show Output

Alice
Bob

Changing one object’s attribute does not affect another object.

student1.name = "Charlie"

print(student1.name)
print(student2.name)

Output ?

Show Output

Charlie
Bob

Class Members

Class members are shared by all objects of a class.

class Student:

    college = "ABC College"

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

student1 = Student("Alice")
student2 = Student("Bob")

print(student1.college)
print(student2.college)

Output ?

Show Output

ABC College
ABC College

Updating the class member affects every object.

Student.college = "XYZ College"

print(student1.college)
print(student2.college)

Output ?

Show Output

XYZ College
XYZ College

When Should You Use Class Members?

Use class members when a value is shared by every object. Examples include:

Company name
College name
Tax rate
Currency
Number of objects created

Exercise 1

Create an Employee class with an instance member name and a class member company. Sample Input

employee = Employee("Rahul")

Expected Output

Rahul
OpenAI

Solution

class Employee:

    company = "OpenAI"

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

employee = Employee("Rahul")

print(employee.name)
print(employee.company)

Exercise 2

Create two students and demonstrate that changing an instance member affects only one object. Sample Input

student1.name = "Alice"

student2.name = "Bob"

Expected Output

Alice
Bob

Solution

class Student:

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

student1 = Student("Alice")
student2 = Student("Bob")

student1.name = "Alice"

print(student1.name)
print(student2.name)

Properties

Properties provide controlled access to attributes while allowing them to be accessed like normal variables. Instead of calling get_name() and set_name(), properties let you write:

student.name
student.name = "Alice"

using the @property decorator.

Read-only Properties

A property that only defines a getter can be read but not modified.

class Circle:

    @property
    def area(self):
        return 3.14 * self.radius ** 2

Write-only Properties

Although Python does not have true write-only variables, a property can emulate one.

class User:

    @property
    def password(self):
        raise AttributeError("Password cannot be read.")

    @password.setter
    def password(self, value):
        self._hashed = hash(value)

This is commonly used for passwords and other sensitive information.

Class Methods

A class method operates on the class itself rather than individual objects. A class method is declared using the @classmethod decorator. Its first parameter is cls, which refers to the class.

class Student:

    college = "ABC College"

    @classmethod
    def display_college(cls):
        print(cls.college)

Student.display_college()

Output ?

Show Output

ABC College

Class methods are commonly used to:

Access or modify class members.
Create alternative constructors.
Perform operations related to the class.

Alternative Constructor

class Student:

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

    @classmethod
    def from_uppercase(cls, name):
        return cls(name.title())

student = Student.from_uppercase("alice")

print(student.name)

Output ?

Show Output

Alice

Exercise 1

Create a class method that displays the company name. Sample Input

Employee.display_company()

Expected Output

OpenAI

Solution

class Employee:

    company = "OpenAI"

    @classmethod
    def display_company(cls):
        print(cls.company)

Employee.display_company()

Exercise 2

Create an alternative constructor that converts a name to title case. Sample Input

Student.from_title("john")

Expected Output

John

Solution

class Student:

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

    @classmethod
    def from_title(cls, name):
        return cls(name.title())

student = Student.from_title("john")

print(student.name)

Static Methods

A static method belongs to the class but does not access either the class (cls) or the object (self). Static methods are declared using the @staticmethod decorator. They are commonly used for utility functions related to the class.

class Student:

    @staticmethod
    def is_eligible(age):
        return age >= 18

print(Student.is_eligible(20))

Output ?

Show Output

True

Another example.

class Calculator:

    @staticmethod
    def square(number):
        return number ** 2

print(Calculator.square(6))

Output ?

Show Output

When Should You Use Static Methods?

Use a static method when:

The function is related to the class.
It does not use self.
It does not use cls.

Exercise 1

Create a static method that checks whether a number is even. Sample Input

Utility.is_even(10)

Expected Output

True

Solution

class Utility:

    @staticmethod
    def is_even(number):
        return number % 2 == 0

print(Utility.is_even(10))

Exercise 2

Create a static method that converts Celsius to Fahrenheit. Sample Input

Converter.to_fahrenheit(25)

Expected Output

77.0

Solution

class Converter:

    @staticmethod
    def to_fahrenheit(celsius):
        return (celsius * 9 / 5) + 32

print(Converter.to_fahrenheit(25))

Magic (Dunder) Methods

Magic methods, also known as dunder methods (double underscore methods), are special methods that allow you to customize the behavior of Python objects. They are automatically invoked by Python in response to certain operations such as printing an object, comparing objects, or using operators. Some commonly used magic methods are:

Method	Purpose
`__init__()`	Initialize an object
`__str__()`	User-friendly string representation
`__repr__()`	Developer-friendly object representation
`__len__()`	Return the length of an object
`__eq__()`	Compare two objects
`__add__()`	Customize the `+` operator

The `str()` Method

By default, printing an object displays its memory location.

class Student:

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

student = Student("Alice", 20)

print(student)

Output ?

Show Output

<__main__.Student object at 0x...>

The __str__() method provides a readable string representation.

class Student:

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

    def __str__(self):
        return f"Student(Name={self.name}, Age={self.age})"

student = Student("Alice", 20)

print(student)

Output ?

Show Output

Student(Name=Alice, Age=20)

Exercise 1

Implement __str__() for a Book class. Sample Input

book = Book("Python Basics", 450)
print(book)

Expected Output

Book(Title=Python Basics, Price=450)

Solution

class Book:

    def __init__(self, title, price):
        self.title = title
        self.price = price

    def __str__(self):
        return f"Book(Title={self.title}, Price={self.price})"

book = Book("Python Basics", 450)

print(book)

Exercise 2

Implement __str__() for an Employee class. Sample Input

employee = Employee("Rahul", "Developer")

print(employee)

Expected Output

Employee(Name=Rahul, Role=Developer)

Solution

class Employee:

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

    def __str__(self):
        return f"Employee(Name={self.name}, Role={self.role})"

employee = Employee("Rahul", "Developer")

print(employee)

The `repr()` Method

The __repr__() method returns an official string representation of an object. It is mainly intended for developers and debugging.

class Student:

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

    def __repr__(self):
        return f"Student('{self.name}')"

student = Student("Alice")

print(repr(student))

Output ?

Show Output

Student('Alice')

Exercise 1

Implement __repr__() for a Product class. Sample Input

product = Product("Laptop")

repr(product)

Expected Output

Product('Laptop')

Solution

class Product:

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

    def __repr__(self):
        return f"Product('{self.name}')"

product = Product("Laptop")

print(repr(product))

Exercise 2

Implement __repr__() for a Course class. Sample Input

course = Course("Python")

repr(course)

Expected Output

Course('Python')

Solution

class Course:

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

    def __repr__(self):
        return f"Course('{self.title}')"

course = Course("Python")

print(repr(course))

Operator Overloading

Magic methods can also customize the behavior of Python operators.

The `len()` Method

The len() function internally calls __len__().

class ShoppingCart:

    def __init__(self):
        self.items = [
            "Laptop",
            "Mouse",
            "Keyboard"
        ]

    def __len__(self):
        return len(self.items)

cart = ShoppingCart()

print(len(cart))

Output ?

Show Output

The `eq()` Method

The == operator internally calls __eq__().

class Employee:

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

    def __eq__(self, other):
        return self.employee_id == other.employee_id

employee1 = Employee(101)
employee2 = Employee(101)

print(employee1 == employee2)

Output ?

Show Output

True

The `add()` Method

The + operator internally calls __add__().

class BankAccount:

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

    def __add__(self, other):
        return self.balance + other.balance

account1 = BankAccount(5000)
account2 = BankAccount(7000)

print(account1 + account2)

Output ?

Show Output

Exercise 1

Implement __len__() for a Library class that returns the number of books. Sample Input

library = Library()

len(library)

Expected Output

Solution

class Library:

    def __init__(self):
        self.books = [
            "Python",
            "Java",
            "C++",
            "SQL"
        ]

    def __len__(self):
        return len(self.books)

library = Library()

print(len(library))

Exercise 2

Implement __add__() for a Wallet class to combine balances. Sample Input

wallet1 + wallet2

Expected Output

Solution

class Wallet:

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

    def __add__(self, other):
        return self.amount + other.amount

wallet1 = Wallet(500)
wallet2 = Wallet(1000)

print(wallet1 + wallet2)

Abstract Base Classes (ABC)

An Abstract Base Class (ABC) defines a common interface that derived classes must implement. Python provides the abc module to create abstract classes.

from abc import ABC, abstractmethod

Why Use ABC?

Enforces a common interface.
Prevents incomplete implementations.
Encourages consistent class design.

Example

from abc import ABC, abstractmethod

class Payment(ABC):

    @abstractmethod
    def pay(self, amount):
        pass

class CreditCard(Payment):

    def pay(self, amount):
        print(f"Paid ₹{amount} using Credit Card")

payment = CreditCard()

payment.pay(2500)

Output ?

Show Output

Paid ₹2500 using Credit Card

Exercise 1

Create an abstract class Vehicle with an abstract method start(). Implement it in a Car class.

Solution

from abc import ABC, abstractmethod

class Vehicle(ABC):

    @abstractmethod
    def start(self):
        pass

class Car(Vehicle):

    def start(self):
        print("Car Started")

car = Car()

car.start()

Exercise 2

Create an abstract class Shape with an abstract method area(). Implement it in a Rectangle class.

Solution

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):

    def area(self):
        return 20 * 10

rectangle = Rectangle()

print(rectangle.area())

What Happens During Inheritance?

When Python creates a derived class, it performs these steps:

Resolves the parent classes.
Validates each base class.
Computes the Method Resolution Order (MRO).
Creates the child class namespace.
Calls type() to create the new class object.
Stores the inheritance hierarchy.
Uses the MRO whenever attributes or methods are searched.

Multiple Inheritance

Python allows a class to inherit from more than one base class.

class Camera:

    def capture(self):
        print("Capturing Photo")

class Phone:

    def call(self):
        print("Calling")

class SmartPhone(Camera, Phone):
    pass

phone = SmartPhone()

phone.capture()
phone.call()

Output ?

Show Output

Capturing Photo
Calling

Method Resolution Order (MRO)

When multiple parent classes define the same method, Python follows the Method Resolution Order (MRO) to determine which method to invoke.

class A:

    def show(self):
        print("Class A")

class B(A):

    def show(self):
        print("Class B")

class C(A):

    def show(self):
        print("Class C")

class D(B, C):
    pass

obj = D()

obj.show()

Output ?

Show Output

Class B

View the MRO using:

print(D.__mro__)

Output ?

Show Output

(<class '__main__.D'>,
 <class '__main__.B'>,
 <class '__main__.C'>,
 <class '__main__.A'>,
 <class 'object'>)

Exercise 1

Create a class that inherits from two parent classes and invoke methods from both.

Solution

class Printer:

    def print_document(self):
        print("Printing")

class Scanner:

    def scan_document(self):
        print("Scanning")

class MultiFunctionPrinter(Printer, Scanner):
    pass

device = MultiFunctionPrinter()

device.print_document()
device.scan_document()

Exercise 2

Print the MRO of a class that inherits from two parent classes.

Solution

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

print(D.__mro__)

Best Practices

Prefer instance members for object-specific data.
Use class members for shared information.
Use class methods to work with class-level data.
Use static methods for utility functions.
Override only the magic methods you actually need.
Use abstract base classes to define common interfaces.
Keep inheritance hierarchies simple and easy to understand.
Avoid deep multiple inheritance unless necessary.

Practice

To reinforce what you’ve learned in this section, practice with the interactive follow-along notebook:

Follow-Along Practice

Practice class/instance variables, class/static methods, custom properties, dunder methods, abstract classes, and multiple inheritance.💻 VS Code | 🚀 Colab | 📥 Download

Summary

In this module, you learned advanced object-oriented programming concepts in Python.

Key Concepts Covered

OOP Refresher
Class Members vs Instance Members
Class Methods
Static Methods
Magic (Dunder) Methods
Operator Overloading
Abstract Base Classes (ABC)
Multiple Inheritance
Method Resolution Order (MRO)
Best Practices

These concepts help you design reusable, maintainable, and extensible applications while taking advantage of Python’s powerful object-oriented features.

​Object-Oriented Programming

​Topics Covered

​OOP Refresher

​What is OOP?

​Class and Object

​The Four Pillars of OOP

​Everything in Python is an Object

​Classes are Objects Too

​What Happens When Python Creates a Class?

​Creating a Class Dynamically Using type()

​Example: Static vs. Dynamic Class Creation

​Class Members vs Instance Members

​Instance Members

​Class Members

​When Should You Use Class Members?

​Exercise 1

​Exercise 2

​Properties

​Read-only Properties

​Write-only Properties

​Class Methods

​Alternative Constructor

​Exercise 1

​Exercise 2

​Static Methods

​When Should You Use Static Methods?

​Exercise 1

​Exercise 2

​Magic (Dunder) Methods

​The __str__() Method

​Exercise 1

​Exercise 2

​The __repr__() Method

​Exercise 1

​Exercise 2

​Operator Overloading

​The __len__() Method

​The __eq__() Method

​The __add__() Method

​Exercise 1

​Exercise 2

​Abstract Base Classes (ABC)

​Why Use ABC?

​Example

​Exercise 1

​Exercise 2

​What Happens During Inheritance?

​Multiple Inheritance

​Method Resolution Order (MRO)

​Exercise 1

​Exercise 2

​Best Practices

​Practice

Follow-Along Practice

​Summary

​Key Concepts Covered

Object-Oriented Programming

Topics Covered

OOP Refresher

What is OOP?

Class and Object

The Four Pillars of OOP

Everything in Python is an Object

Classes are Objects Too

What Happens When Python Creates a Class?

Creating a Class Dynamically Using `type()`

Example: Static vs. Dynamic Class Creation

Class Members vs Instance Members

Instance Members

Class Members

When Should You Use Class Members?

Exercise 1

Exercise 2

Properties

Read-only Properties

Write-only Properties

Class Methods

Alternative Constructor

Exercise 1

Exercise 2

Static Methods

When Should You Use Static Methods?

Exercise 1

Exercise 2

Magic (Dunder) Methods

The `str()` Method

Exercise 1

Exercise 2

The `repr()` Method

Exercise 1

Exercise 2

Operator Overloading

The `len()` Method

The `eq()` Method

The `add()` Method

Exercise 1

Exercise 2

Abstract Base Classes (ABC)

Why Use ABC?

Example

Exercise 1

Exercise 2

What Happens During Inheritance?

Multiple Inheritance

Method Resolution Order (MRO)

Exercise 1

Exercise 2

Best Practices

Practice

Summary

Key Concepts Covered