What is Object-Oriented Programming (OOP)?

Object-Oriented Programming (OOP) is a way of designing and writing programs

using objects. Objects are like real-world things that have properties (data)
and actions (functions or behaviors). It makes programs easier to manage, reuse,
and scale.
Think of it this way:
 Object: A real-world thing or concept, like a car, phone, or student.
 Class: A blueprint or template to create objects. It defines what properties
and actions an object can have.
 Properties (also called attributes): Characteristics of an object (e.g., a car
has a color, brand, and speed).
 Methods (also called functions): Things an object can do (e.g., a car can
start, stop, or honk).
Real-Life Example: A Car
Imagine you are writing a program to represent cars in a game or app. Here’s
how OOP works:
1. Class (Blueprint): Think of a car's blueprint. Every car has similar
properties and can perform similar actions.
2. Object (Instance): A specific car created from that blueprint (like your
actual car).

Code Example (Python)

Here’s a simple Python code example to show you how this works:
# Defining a class (blueprint for a Car)
class Car:
def __init__(self, brand, color):
self.brand = brand # Property (attribute)
self.color = color # Property (attribute)

def drive(self): # Method (action)

print(f"The {self.color} {self.brand} is driving!")

def stop(self): # Method (action)

print(f"The {self.color} {self.brand} has stopped.")
# Creating objects (instances of the Car class)
car1 = Car("Toyota", "red")
car2 = Car("Honda", "blue")

# Using the objects

car1.drive() # Output: The red Toyota is driving!
car2.stop() # Output: The blue Honda has stopped.

Breaking Down the Example:

 Class Car: This is the template that defines what a car can do (drive,
stop) and what it has (brand, color).
 Objects car1 and car2: These are actual cars created from the Car class.
o car1 is a red Toyota.

o car2 is a blue Honda.

 Methods: drive() and stop() are actions the cars can perform.

Simple Analogy:
Think of a "Student" class:
 Properties: name, age, grade
 Actions (Methods): study(), take_exam(), graduate()
Every specific student is an object of the Student class. You can create multiple
students, each with different names, ages, and grades, but they all can study,
take exams, and graduate.

Sure! Let’s explore Object-Oriented Programming (OOP) in more detail,

focusing on Python.

What is OOP in Programming?

OOP is a programming approach that structures code around objects and
classes. It allows you to bundle data (attributes) and functions (methods) into
a single unit called an object. This makes your code more modular, reusable,
and easier to maintain.
Instead of writing functions and variables separately, OOP allows you to create
blueprints (classes) and then generate multiple instances (objects) from
those blueprints. These instances can store unique data and perform specific
actions.
4 Key Principles of OOP
1. Encapsulation
o Hides the internal details of an object and only exposes what’s
necessary.
o Think of a TV remote3: you press a button to change channels, but
you don’t need to know how the circuit works inside.
Example in Python:
class Student:
def __init__(self, name, age):
self.name = name # Public attribute
self.__age = age # Private attribute (hidden with `__`)

def get_age(self):
return self.__age # Access the hidden attribute using a method

student = Student("John", 20)

print(student.name) # Output: John
print(student.get_age()) # Output: 20
2. Inheritance
o Allows a class (child) to inherit the properties and methods of
another class (parent).
o Think of a Car class and a SportsCar class. SportsCar can inherit
everything from Car but also have its own unique features.
Example in Python:
class Car:
def drive(self):
print("The car is driving.")

class SportsCar(Car): # Inherits from Car

def turbo(self):
print("The car is in turbo mode!")
my_car = SportsCar()
my_car.drive() # Output: The car is driving.
my_car.turbo() # Output: The car is in turbo mode!
3. Polymorphism
o Means "many forms." It allows methods in different classes to have
the same name but behave differently.
o Example: A Dog and a Cat class can both have a speak() method,
but their outputs are different.
Example in Python:
class Dog:
def speak(self):
print("Woof!")

class Cat:
def speak(self):
print("Meow!")

def animal_sound(animal):
animal.speak()

dog = Dog()
cat = Cat()

animal_sound(dog) # Output: Woof!

animal_sound(cat) # Output: Meow!
4. Abstraction
o Hides complexity and shows only the relevant details to the user.

o Example: When you drive a car, you don’t worry about how the
engine works; you just use the pedals and steering wheel.
In Python, abstraction can be achieved using abstract base classes (ABC):
from abc import ABC, abstractmethod

class Animal(ABC):
 @abstractmethod
def sound(self):
pass

class Dog(Animal):
def sound(self):
print("Woof!")

dog = Dog()
dog.sound() # Output: Woof!

OOP Concepts in Python Explained:

Python makes it easy to use OOP with its built-in class keyword and flexible
syntax. Let’s explore how you can implement OOP step by step.
1. Creating Classes and Objects
A class is like a blueprint for an object. You can create multiple objects
(instances) from a class.
class Student:
def __init__(self, name, age):
self.name = name # Attribute (property)
self.age = age # Attribute (property)

def introduce(self): # Method (behavior)

print(f"My name is {self.name}, and I am {self.age} years old.")

# Creating an object of the Student class

student1 = Student("Alice", 18)
student1.introduce() # Output: My name is Alice, and I am 18 years old.

2. Inheritance Example in Python

class Person:
def __init__(self, name):
self.name = name
 def greet(self):
print(f"Hello, my name is {self.name}.")

class Teacher(Person): # Teacher inherits from Person

def teach(self):
print(f"{self.name} is teaching.")

teacher = Teacher("Mr. Smith")

teacher.greet() # Output: Hello, my name is Mr. Smith.
teacher.teach() # Output: Mr. Smith is teaching.

3. Encapsulation Example
class BankAccount:
def __init__(self, balance):
self.__balance = balance # Private attribute

def deposit(self, amount):

self.__balance += amount

def get_balance(self):
return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance()) # Output: 1500

Why Use OOP in Python?

1. Code Reusability: Classes can be reused and extended without rewriting
everything.
2. Modularity: Breaks down the program into smaller parts.
3. Easier Maintenance: Easier to update and debug.
 4. Scalability: Suitable for large projects (e.g., building mobile apps, games,
or websites).
1. Code Reusability
Explanation:
OOP allows you to create a class once and reuse it multiple times, even in
different programs. You don’t need to rewrite the same code. Instead, you can
extend an existing class by creating new ones that inherit its properties and
methods.
Example:
Imagine you’re building a game, and you already have a Character class. Later,
you want to create different types of characters like Hero and Villain. Instead of
writing new code for these, you can reuse the Character class and just add
unique features.
class Character:
def __init__(self, name, health):
self.name = name
self.health = health

def attack(self):
print(f"{self.name} attacks!")

# Reuse Character class by inheriting it in Hero and Villain classes

class Hero(Character):
def defend(self):
print(f"{self.name} is defending!")

class Villain(Character):
def taunt(self):
print(f"{self.name} is taunting!")

hero = Hero("Superman", 100)

villain = Villain("Joker", 80)

hero.attack() # Output: Superman attacks!

villain.taunt() # Output: Joker is taunting!
Why this helps:
 You don’t need to write attack() for every new character type.
 Easily extend the class with additional features (like defend() for Hero).

2. Modularity
Explanation:
OOP breaks the program into smaller, manageable pieces (classes and
objects). This makes it easier to organize and understand complex code. Each
class represents a specific part of your program.
Example:
In a school management system, you might break the program into modules like
Student, Teacher, and Course.
class Student:
def __init__(self, name, student_id):
self.name = name
self.student_id = student_id

class Teacher:
def __init__(self, name, subject):
self.name = name
self.subject = subject

class Course:
def __init__(self, course_name, teacher):
self.course_name = course_name
self.teacher = teacher
Why this helps:
 Organized code: Each part (Student, Teacher, Course) is in its own class.
 Easy to update: You can modify one class without affecting the others.

3. Easier Maintenance
Explanation:
OOP reduces complexity and makes code easier to update, debug, and
manage over time. When a bug or an update is needed, you can easily trace
and modify specific classes or methods without rewriting the entire codebase.
Example:
Suppose your banking app has a BankAccount class, and you want to add a new
feature for VIP accounts. You can extend your code without affecting the existing
accounts.
class BankAccount:
def __init__(self, balance):
self.balance = balance

def deposit(self, amount):

self.balance += amount

def get_balance(self):
return self.balance

# Add a new feature for VIP accounts

class VIPBankAccount(BankAccount):
def add_bonus(self):
self.balance += 100
print("Bonus added!")

vip_account = VIPBankAccount(1000)
vip_account.add_bonus() # Output: Bonus added!
print(vip_account.get_balance()) # Output: 1100
Why this helps:
 Easy to fix bugs in one class without touching others.
 Future-proof: Easily add new features to existing code.

4. Scalability
Explanation:
OOP makes your code scalable, meaning you can expand your program as your
project grows. It’s easier to handle large projects by organizing them into
multiple classes and modules.
Example:
Let’s say you’re developing a mobile app for an online store. You’ll need to
manage products, users, orders, payments, and more. Each of these can be
represented by a class.
class Product:
def __init__(self, name, price):
self.name = name
self.price = price

class User:
def __init__(self, username, email):
self.username = username
self.email = email

class Order:
def __init__(self, user, product):
self.user = user
self.product = product

def place_order(self):
print(f"Order placed by {self.user.username} for {self.product.name}.")
As your app grows, you can add new features like payment methods, reviews,
and delivery tracking without affecting existing code.

Why this helps:

 Handle large programs: Each class handles a different part of the
program.
 Easier to collaborate: Multiple developers can work on different classes
simultaneously.
 Future expansion: Add new features or modules without breaking the
existing code.

Summary:
 Code Reusability: Save time and avoid duplicating code by reusing and
extending classes.
 Modularity: Organize code into small, manageable pieces for better
readability.
 Easier Maintenance: Find and fix bugs easily, and future-proof your
programs.
 Scalability: Build larger, more complex programs that can grow over
time.

I got you covered! Let’s break down Unit 1: Introduction to Object-

Oriented Programming (OOP) in a detailed but simple way, along with
examples for each sub-topic. I’ll also explain how each part connects with
your Intended Learning Outcomes (ILOs).

Unit 1: Introduction to Object-Oriented Programming (OOP)

1. Literals
Literals are fixed values in a program. They are the most basic form of data
in programming and include:
 Integer literals: 10, 20, -5
 Float literals: 3.14, -0.99
 String literals: "Hello", 'Python'
 Boolean literals: True, False
Example:
age = 20 # Integer literal
pi = 3.1416 # Float literal
name = "Alice" # String literal
is_active = True # Boolean literal

2. Variables and Constants

 Variables are used to store data that can change during program
execution.
o Syntax: variable_name = value

 Constants are values that don’t change throughout the program (in
Python, constants are written in UPPERCASE by convention).
Example:
# Variable
score = 100

# Constant (by convention)

PI = 3.1416
MAX_SCORE = 100

3. Input and Output

 Input: Get data from the user using input() function.
 Output: Display data using the print() function.
Example:
name = input("Enter your name: ") # Input
print(f"Hello, {name}!") # Output
Explanation:
 The input() function takes a value from the user as a string.
 The print() function displays the value.

4. Data Types
Python has several built-in data types, such as:
 int – integers like 10, -20
 float – decimal numbers like 3.14, -0.5
 str – strings like "hello"
 bool – boolean values True or False
 list, tuple, set, dict – for collections of data
Example:
age = 25 # int
price = 19.99 # float
name = "John" # str
is_valid = True # bool

5. Arithmetic Operators
Arithmetic operators are used for mathematical operations:
 + (Addition)
 - (Subtraction)
 * (Multiplication)
 / (Division)
 // (Floor Division)
 % (Modulo)
 ** (Exponentiation)
Example:
x = 10
y=3

print(x + y) # Output: 13
print(x - y) # Output: 7
print(x * y) # Output: 30
print(x / y) # Output: 3.3333
print(x ** y) # Output: 1000

6. Decision Statements
Decision statements allow your program to make choices based on
conditions. The main types in Python are:
 if
 if-else
 if-elif-else
Example:
age = 18

if age >= 18:

print("You are an adult.")
else:
print("You are a minor.")

7. Functions
Functions are blocks of reusable code that perform a specific task. In Python,
they are defined using the def keyword.
Example:
def greet(name):
print(f"Hello, {name}!")

greet("Alice") # Output: Hello, Alice!

Functions allow you to avoid repeating code and make your program more
organized and readable.

Intended Learning Outcomes (ILOs)

ILO 1: Differentiate Procedural from Object-Oriented Programming
 Procedural Programming:
o Focuses on functions and procedures to perform tasks.

o Example: C, Pascal

o Code is written step by step.

 Object-Oriented Programming:
o Focuses on objects (which combine data and functions).

o Example: Python, Java, C++

o More modular and scalable.

Example of Procedural vs OOP:

Procedural:
def add(x, y):
return x + y

result = add(10, 20)

print(result) # Output: 30
OOP:
class Calculator:
def add(self, x, y):
return x + y

calc = Calculator()
result = calc.add(10, 20)
print(result) # Output: 30

ILO 2: Identify Ways to Define Variables and Objects in OOP

In OOP, variables can be:
 Instance variables: Unique to each object.
 Class variables: Shared among all objects of the class.
Example:
class Student:
school = "XYZ High School" # Class variable

def __init__(self, name, age):

self.name = name # Instance variable
self.age = age

student1 = Student("Alice", 18)

student2 = Student("Bob", 17)

print(student1.name) # Output: Alice

print(student2.school) # Output: XYZ High School

ILO 3: Explain Principles of OOP

The principles of OOP include:
1. Encapsulation – Hiding internal details.
2. Inheritance – Reusing code from a parent class.
3. Polymorphism – Methods with the same name but different behaviors.
4. Abstraction – Hiding complexity, showing only essential features.

ILO 4: Demonstrate Procedural to OOP Conversion

Let’s convert a simple procedural program to an OOP approach.
Procedural Approach:
def greet(name):
print(f"Hello, {name}!")
 greet("Alice")
OOP Approach:
class Greeter:
def greet(self, name):
print(f"Hello, {name}!")

greeter = Greeter()
greeter.greet("Alice")

When I say "mimic real-world objects", it means that in Object-Oriented

Programming (OOP), you design programs by creating objects that represent
things from the real world. These objects have properties (attributes) and
actions (methods)—just like real things do.
Real-World Example: Car
In real life, a car has:
 Attributes (Properties): color, brand, speed, fuel level
 Actions (Methods): start, stop, accelerate, brake
In OOP, you can create a Car class to represent this concept, and then make
actual Car objects (specific cars) from that class.
Code Example (Python):
class Car:
def __init__(self, brand, color):
self.brand = brand
self.color = color

def start(self):
print(f"The {self.color} {self.brand} is starting.")

def stop(self):
print(f"The {self.color} {self.brand} has stopped.")
# Creating real-world car objects
car1 = Car("Toyota", "red")
car2 = Car("Honda", "blue")

car1.start() # Output: The red Toyota is starting.

car2.stop() # Output: The blue Honda has stopped.
Explanation:
 Class (Blueprint): Car is a blueprint that defines what a car is—its
attributes and behaviors.
 Objects (Instances): car1 and car2 are specific cars created from the Car
class. They "mimic" real cars with unique colors and brands.

Another Example: Student

In real life, a student has:
 Attributes: name, age, student ID
 Actions: study, take exams, graduate
In Python:
class Student:
def __init__(self, name, age):
self.name = name
self.age = age

def study(self):
print(f"{self.name} is studying.")

student1 = Student("Alice", 20)

student1.study() # Output: Alice is studying.
Why is this useful?
 It makes programming easier to understand because it reflects how
things work in real life.
 Objects can interact with each other just like in real life (e.g., a
Student object can enroll in a Course object).
 Reusability: Once you have a Car class or Student class, you can create
multiple objects from them without writing new code.
Addition to Your Presentation: "The Father of Object-Oriented
Programming"
You can add a slide or section with the following information:

The Father of Object-Oriented Programming

Alan Kay is often considered the father of OOP for his pioneering work in the
1970s. Although the concept originated earlier, Kay coined the term "object-
oriented programming" and refined its principles while developing Smalltalk, an
influential OOP language.
Why Was OOP Developed?
 Alan Kay and other researchers wanted to create a more natural and
modular way to build complex systems.
 OOP was designed to mimic real-world objects, making code easier to
understand, maintain, and reuse.
 The goal was to create programs that were scalable and adaptable,
especially in environments like graphical user interfaces (GUIs) and
simulations.
Influences and Impact:
 Inspired by the concept of "objects" in real life, Kay introduced OOP to
make programming more intuitive.
 OOP revolutionized modern programming, forming the foundation for
languages like Python, Java, C++, and Ruby.