Object Oriented Programming in Python

Class Definition Syntax

class ClassName:
    # class body
    def method_name(self):
        # method body
        pass

• The class keyword defines a class.
• Class names follow PascalCase (each word capitalised) by convention.
• The class body is indented.
• pass is used as a placeholder for an empty class or method body.

Creating an Object (Instantiation)

An object is created by calling the class name as if it were a function:

class Student:
    def greet(self):
        print("Hello, I am a Student!")

# Creating objects (instances)
s1 = Student()   # s1 is an object of class Student
s2 = Student()   # s2 is another independent object

s1.greet()       # Output: Hello, I am a Student!
s2.greet()       # Output: Hello, I am a Student!

Note: s1 and s2 are two separate objects — changes to one do not affect the other.

The self Parameter

• self is the first parameter of every instance method in a class.
• It refers to the current object on which the method is being called.
• Python passes self automatically — you do not pass it manually when calling a method.
• The name self is a convention, not a keyword — but deviating from it is strongly discouraged.

class Circle:
    def area(self):
        return 3.14 * self.radius * self.radius

c = Circle()
c.radius = 5
print(c.area())   # Output: 78.5
# Internally Python calls: Circle.area(c)

The constructor is a special method called automatically when an object is created. In Python, the constructor is __init__().

• Used to initialise instance attributes when the object is first created.
• Always takes self as its first argument.
• Does NOT return any value (implicitly returns None).
• If not defined, Python provides a default empty constructor.

class Student:
    def __init__(self, name, roll, marks):
        self.name = name       # instance attribute
        self.roll = roll
        self.marks = marks

    def display(self):
        print(f"Name: {self.name}, Roll: {self.roll}, Marks: {self.marks}")

    def grade(self):
        if self.marks >= 90:
            return 'A'
        elif self.marks >= 75:
            return 'B'
        else:
            return 'C'

# Creating objects — __init__ is called automatically
s1 = Student("Aarav", 101, 92)
s2 = Student("Priya", 102, 78)

s1.display()          # Name: Aarav, Roll: 101, Marks: 92
s2.display()          # Name: Priya, Roll: 102, Marks: 78
print(s1.grade())     # A
print(s2.grade())     # B

Instance Attributes vs Class Attributes

class Student:
    school = "DPS"        # class attribute — shared by all Student objects

    def __init__(self, name):
        self.name = name  # instance attribute — unique per object

s1 = Student("Aarav")
s2 = Student("Priya")

print(Student.school)   # DPS  (accessed via class name)
print(s1.school)        # DPS  (accessed via object — looks up class)
print(s1.name)          # Aarav
print(s2.name)          # Priya

Encapsulation is the bundling of data (attributes) and methods that operate on the data within a single unit (class), while restricting direct access from outside. This is achieved using access modifiers:

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner          # public
        self._branch = "Main"       # protected
        self.__balance = balance    # private — name mangled to _BankAccount__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):          # getter method — controlled access
        return self.__balance

acc = BankAccount("Aarav", 10000)
print(acc.owner)          # Aarav         (public — works fine)
print(acc._branch)        # Main          (protected — works but not recommended)
# print(acc.__balance)    # AttributeError — private, cannot access directly
print(acc.get_balance())  # 10000         (accessed through getter method)

Name Mangling: Python transforms __attr to _ClassName__attr internally. So acc.__balance fails but acc._BankAccount__balance technically works — though using it defeats the purpose of privacy.

Inheritance allows a class (child/derived class) to acquire the attributes and methods of another class (parent/base class). It promotes code reusability.

class ParentClass:
    # parent body

class ChildClass(ParentClass):
    # child body — inherits all public/protected members of Parent

Types of Inheritance in Python

Single Inheritance — Full Example

class Animal:                        # Parent class
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

    def breathe(self):
        print(f"{self.name} breathes air.")

class Dog(Animal):                   # Child class — inherits Animal
    def __init__(self, name, breed):
        super().__init__(name)       # call parent __init__
        self.breed = breed

    def speak(self):                 # method overriding
        print(f"{self.name} barks!")

d = Dog("Bruno", "Labrador")
d.speak()           # Bruno barks!     (overridden method)
d.breathe()         # Bruno breathes air.  (inherited method)
print(d.name)       # Bruno
print(d.breed)      # Labrador

The super() Function

super() returns a proxy object of the parent class, allowing the child class to call the parent's methods. It is most commonly used to call the parent's __init__() to ensure proper initialisation of inherited attributes.

class Vehicle:
    def __init__(self, brand, speed):
        self.brand = brand
        self.speed = speed

class Car(Vehicle):
    def __init__(self, brand, speed, fuel):
        super().__init__(brand, speed)   # initialise parent's attributes
        self.fuel = fuel                 # additional child attribute

    def describe(self):
        print(f"{self.brand} | Speed: {self.speed} km/h | Fuel: {self.fuel}")

c = Car("Toyota", 180, "Petrol")
c.describe()     # Toyota | Speed: 180 km/h | Fuel: Petrol

Multiple Inheritance

class Father:
    def skills(self):
        print("Cooking, Gardening")

class Mother:
    def skills(self):
        print("Painting, Singing")

class Child(Father, Mother):        # inherits from both
    def own_skills(self):
        print("Coding, Gaming")

c = Child()
c.own_skills()    # Coding, Gaming
c.skills()        # Cooking, Gardening
                  # Python uses MRO — Father is checked before Mother

MRO (Method Resolution Order): When a method is called, Python searches classes in a specific order defined by the C3 Linearisation Algorithm. Use ClassName.mro() or ClassName.__mro__ to view the order.