Python Object Oriented Programming(OOP)

Object Oriented Programming(OOP) is a way of writing programs by modelling real-world things as "objects". Instead of writing code as a long list of instructions that act on separate variables, OOP groups related data(attributes) and behaviour (methods) together into a single object called an object.

Real world Analogy
Think about a real world car.

A car has attributes(color, fuel type, brand, max-speed) it can do things like(accelerate, braking, honk).
In OOP we would create a Car object that bundles those attributes and behaviours together, instead of tracking color, brand, fuel type, max-speed acceleration,braking etc as disconnected variables.

Four Pillars of OOP

• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

Classes and Object

What is a class?

• A class is a blueprint or template for creating objects. It defines what attributes(data) and methods(functions) the objects created from it will have. Note: A class does not hold any actual data itself, it only describes the shape that objects of that type will take.

a. Class Attributes
Defined directly inside the class body, outside of any method(function). They are shared by all objects of that class unless an individual object overrides them.

Example

class Dog:
    species = "Canis familiaris" # class attribute (Shared by all Dogs)

b. Instance attributes
Defined inside init(or any method) using self.attribute_name = value.
Each object gets its own independent copy.

class Dog:
    def __init__(self, name, breed):
        self.name = name # Instance attribute, unique per dog/instance of the class
        self.breed = breed # Instance attribute, unique per dog/instance of the class

Methods

• Methods are functions defined inside a class. They define/describe the behaviours an object can perform. Like init, regular methods take 'self' as their first parameter so they can access and modify the object's own attributes.

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print(f"{self.name} says: Woof!")

    def play(self, minutes):
        print(f"{self.name} played for {minutes} minutes")

    def fact(self, top_speed):
        print(f"The dog '{self.name}' of breed '{self.breed}' can reach a maximum speed of {top_speed}km/h.")

dog1 = Dog("Bosco", "African Shepherd")

dog1.bark()
dog1.play(30)
dog1.fact(72)

Output:

Bosco says: Woof!
Bosco played for 30 minutes
The dog 'Bosco' of breed 'African Shepherd' can reach a maximum speed of 72km/h.

# German Shepherd Instance
german_shepherd = Dog("Max", "German Shepherd")

german_shepherd.bark()
german_shepherd.play(60)
german_shepherd.fact(56)

Output:

Max says: Woof!
Max played for 60 minutes
The dog 'Max' of breed 'German Shepherd' can reach a maximum speed of 56km/h.

MPESA Example

class MpesaAccount:
    def __init__(self, phone_number, owner_name, balance):
        self.phone_number = phone_number
        self.owner_name = owner_name
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount # self.balance = self.balance + amount
        print(f"You have successfully deposited KES {amount}, new acc balance KES {self.balance}")

    def withdraw(self, amount):
        self.balance -= amount # self.balance = self.balance - amount
        print(f"You have successfully withdrawn KES {amount}, new acc balance KES {self.balance}")

    def check_balance(self):
        print(f"Balance: KES {self.balance}")

emmanuel_acc = MpesaAccount("[phone]", "Emmanuel", 0)
emmanuel_acc.deposit(500)

Output:

You have successfully deposited KES 500, new acc balance KES 500

emmanuel_acc.withdraw(250)

Output:

You have successfully withdrawn KES 250, new acc balance KES 250

emmanuel_acc.check_balance()

Output:

Balance: KES 250

Four Pillars Of Object Oriented Programming

1. Encapsulation

• Encapsulation means bundling an object's data(attributes) and the methods that operate on that data into a single class, and restricting direct access to some of that data from outside the class. This protects the object's internal state from being change in unexpected or invalid ways.

In Python encapsulation is a convention rather a strict:

• name - public, accessible from anywhere.
• _name - protected, a signal to other developers "Don't touch this directly".
• __name - private, Python renames it internally(name mangling) to discourage outside access.

class MpesaAccount:
    def __init__(self, owner_name, phone_number, balance=0):
        self.owner_name = owner_name
        self.phone_number = phone_number
        self.__balance = balance

    def deposit(self, amount):
        if amount <= 49:
            print("Deposit must be a minimum of KES 50.")
        else:
            self.__balance += amount
            print(f"You have successfully deposited {amount} ne acc bal is KES {self.__balance}")

    def withdraw(self, amount):  
        if amount > self.__balance:
            print("Insufficient Funds")
        else:
            self.__balance -= amount
            print(f"You have successfully withdrawn {amount} ne acc bal is KES {self.__balance}")

    def check_balance(self):
        return f"You account balance is KES {self.__balance}"

emmanuel_mpesa = MpesaAccount("Emm", "0701000000")
emmanuel_mpesa.deposit(150)

Output:

You have successfully deposited 150 ne acc bal is KES 150

2. Inheritance

• Inheritance allows a new class to(child class/subclass/derived class) reuse the attributes and methods of an existing class(parent class/super class/base class).

# Parent Class
class PublicService:
    def __init__(self, reg_number, route):
        self.reg_number = reg_number
        self.route = route   

    def describe(self):
        return f"Vehicle registaration number {self.reg_number} plies the {self.route} route."

    def collect_fare(self, amount):
        return f"KES {amount} fare collected on {self.reg_number}."


# Child class 1   
class Matatu(PublicService):
    def __init__(self, reg_number, route, sacco_name, capacity):
        super().__init__(reg_number, route)
        self.sacco_name = sacco_name
        self.capacity = capacity

    def describe(self):
        return f"Vehicle registaration number {self.reg_number}, of the sacco {self.sacco_name} plies the {self.route} route."

kabuku = Matatu("KDQ 221Z", "Nairobi-Thika", "Super-Metro", 33)
kabuku.collect_fare(100)

Output:

'KES 100 fare collected on KDQ 221Z.' 

# Child Class 2
class BodaBoda(PublicService):
    def __init__(self, reg_number, route, rider_name):
        super().__init__(reg_number, route)
        self.rider_name = rider_name

    # def describe(self):
    #     return f"Boda Boda {self.reg_number}, rider {self.rider_name} is on the {self.route} route" 

bodaboda = BodaBoda("KMZT 300Z", "CBD-Upper-Hill", "Emmanuel")
bodaboda.describe()

Output:

'Vehicle registaration number KMZT 300Z plies the CBD-Upper-Hill route.'

Multi-level inheritance

• Multilevel inheritance in Python is an object-oriented programming feature where a derived (child) class inherits from another derived class, forming a sequential, multi-generational chain (e.g., Grandparent → Parent → Child). This structure allows the deepest child class to automatically access all attributes and methods across the entire ancestor hierarchy
• Also inherited attributes and methods without super() function - another way of inheriting attributes and methods besides using super() function.

class company:

    title:str = "consultancy"

    def __init__(self, company_name:str):
        self.company_name:str = company_name

    def info(self):
        print(f"Company Name: {self.company_name}")
        return f"Company Name: {self.company_name}"


class manager(company):

    def __init__(self, manager_name:str, company_name:str):

        self.manager_name = manager_name
        self.company_name = company_name

    def info(self):
        response = company.info(self)
        print(f"The manager : {self.manager_name}, {response} ")
        return f"The manager : {self.manager_name}, {response} "

class employee(manager):

    def __init__(self,employee_name:str, manager_name:str, company_name:str):

        self.employee_name = employee_name
        self.manager_name = manager_name
        self.company_name = company_name

    def info(self):
        response = manager.info(self)
        print(f"The employee : {self.employee_name}, {response} ")
        return f"The employee : {self.employee_name}, {response} "

obj = employee("John Doe", "Alice Johnson", "Tech Solutions")
obj.info()

Multiple Inheritance

• Multiple inheritance is an object-oriented programming feature where a class inherits behaviors and attributes from more than one parent class

class company:

    title:str = "consultancy"

    def __init__(self, company_name:str):
        self.company_name:str = company_name

    def info(self):
        print(f"Company Name: {self.company_name}")
        return f"Company Name: {self.company_name}"


class employee(company):

    def __init__(self,employee_name:str, company_name:str):

        self.employee_name = employee_name
        self.company_name = company_name

    def info(self):
        response = company.info(self)
        print(f"The employee : {self.employee_name}, {response} ")


class contractor(company):

    def __init__(self, contractor_name:str, company_name:str):

        self.contractor_name = contractor_name
        self.company_name = company_name

    def info(self):
        response = company.info(self)
        print(f"The contractor : {self.contractor_name}, {response} ")


obj = employee("John Doe", "Tech Solutions")
obj.info()

obj2 = contractor("Jane Smith", "Tech Solutions")
obj2.info()

3. Polymorphism

• Polymorphism(Greek word for "many forms") means objects of different classes can respond to the same method call in their own way. You call the same method name on different objects, and each one behaves according to its own class's implementation.

Python supports polymorphism naturally through method overriding(child classses redefine a parent's method as seen in the Delivery() and VanDelivery()).

4. Abstraction

• Abstraction means hiding complicated implementation details and exposing only the essential features that a user of the class actually needs. IN python, abstraction is commonly implemented using the abc module to define abstract base classes. (Classes that define required methods but cannot be instantiated directly, forcing the subclasses/child classes to provide the actual implentation)

from abc import ABC, abstractmethod

# Parent Class
class Shape(ABC):  # Inherits from ABC, it cannot be instantiated

    @abstractmethod
    def area(self):
        pass            # No implementation on purpose

    @abstractmethod
    def perimeter(self):
        pass          # No implementation on purpose 

# Child Class
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        area = self.width * self.height

        return area

    def perimeter(self):
        perimeter = 2 * (self.height + self.width)
        return perimeter

rect = Rectangle(10, 6)

rect.area()

Output:

60

rectange = Shape()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[69], line 1
----> 1 rectange = Shape()

TypeError: Can't instantiate abstract class Shape without an implementation for abstract methods 'area', 'perimeter'

Conclusion

Object-Oriented Programming (OOP) in Python is a powerful paradigm that shifts the programming focus from functions to structured objects, making software more modular, scalable, and maintainable. Because "everything in Python is an object," OOP is not just an optional tool; it forms the core DNA of the language and its most popular libraries.