Technological University of the Philippines – Manila

College of Engineering
Electronics Engineering Department

Name: Angeles, Madrict Anjelo L. Date Started: April 1, 2025

ID Number: TUPM-24-0571 Date Submitted: April 10, 2025
Section: BSECE -1A Instructor: Engr. Gilfred Allen M. Madrigal

Activity 5
OBJECT-ORIENTED PROGRAMMING (OOP)

I. INTRODUCTION

Object-Oriented Programming (OOP) is a programming paradigm that organizes code into reusable objects that
represent real-world entities. In Python, OOP enhances code modularity, maintainability, and scalability by defining
classes as blueprints for objects. A class encapsulates attributes (data) and methods (functions) that define the
object's behavior, allowing for more structured and reusable code.

Key OOP principles include encapsulation, which restricts direct access to an object’s data, ensuring controlled
modification; inheritance, which enables new classes to reuse and extend the functionality of existing ones; and
polymorphism, which allows different objects to be used interchangeably while maintaining consistent behavior.
Python also supports method overriding and advanced OOP features, allowing developers to tailor class behaviors
for specific use cases.

This lab will introduce students to creating and working with classes and objects, implementing core OOP
principles, and utilizing Python’s built-in object-oriented libraries. Through hands-on exercises, students will
develop a deeper understanding of OOP design patterns, improving their ability to write scalable, efficient, and
well-structured programs.

Key Concepts Covered:

1. Classes and Objects – Blueprint for Data Organization
● A class defines a reusable structure that groups related data (attributes) and behavior (methods).
● An object is an instance of a class, created to represent real-world entities.
class ClassName:
def init (self, attribute1, attribute2):
self.attribute1 = attribute1
self.attribute2 = attribute2

def method(self):
print("This is a method.")

# Creating an object
object_name = ClassName(value1, value2)
object_name.method() # Calling a method

2. Encapsulation – Data Hiding and Controlled Access

● Encapsulation restricts direct access to an object's internal attributes, allowing controlled interaction
via methods.

Evaluation Copy 1
Strictly for TUP ECE students only
 ● Private attributes (denoted by attribute) prevent unintended modification from outside the class.
class ClassName:
def init (self, value):
self. private_attribute = value # Private attribute

def get_value(self):
return self. private_attribute # Controlled access method

def set_value(self, new_value):

self. private_attribute = new_value # Controlled modification

# Creating an object
obj = ClassName(initial_value)
print(obj.get_value()) # Accessing private data via method
obj.set_value(new_value)

3. Inheritance – Code Reusability Through Hierarchy

● Inheritance allows a new class (child class) to inherit properties and behaviors from an existing parent
class. This promotes code reusability and reduces duplication.
class ParentClass:
def method(self):
print("This method is inherited.")

class ChildClass(ParentClass):
pass # Inherits all methods from ParentClass

# Creating an object of the child class

child_object = ChildClass()
child_object.method() # Calling inherited method

4. Polymorphism – Unified Method Handling Across Classes

● Polymorphism allows different classes to define methods with the same name but with different
behaviors.
● Enables flexibility in handling different objects using the same function or method.
class ClassA:
def action(self):
print("Action from ClassA.")

class ClassB:
def action(self):
print("Action from ClassB.")

# Polymorphic function
def execute_action(obj):
[Link]() # Calls the respective action method

# Creating objects
obj1 = ClassA()
Evaluation Copy 2
Strictly for TUP ECE students only
 obj2 = ClassB()

execute_action(obj1) # Output depends on object type

execute_action(obj2)

5. Method Overriding – Modifying Parent Class Behavior

● Method overriding allows a child class to redefine a method inherited from the parent class.
● Ensures custom behavior while maintaining a shared method structure.
class ParentClass:
def method(self):
print("Original method from ParentClass.")

class ChildClass(ParentClass):
def method(self): # Overriding the parent method
print("Overridden method from ChildClass.")

# Creating an object of the child class

child_object = ChildClass()
child_object.method() # Calls overridden method

6. Working with Object-Oriented Libraries – Leveraging Prebuilt Classes

● Python provides built-in OOP-based libraries for common tasks such as handling dates, threading,
and data structures.
● Developers can use these libraries to simplify programming without reinventing the wheel.
# Example of using an OOP-based built-in library
import module_name # Importing a module

# Creating an object from a built-in class

object_name = module_name.ClassName(arguments)

# Calling a method from the built-in class

object_name.method()

II. MATERIALS AND EQUIPMENT

● A computer with Python 3 installed
● A text editor or IDE (e.g., VS Code, PyCharm, or IDLE)
● Access to online Python documentation

III. PROCEDURES
1. Creating a Class and Object in Python
# Step 1: Define a class named Car
class Car:
def init (self, brand, model, year):
[Link] = brand
[Link] = model
[Link] = year

def display_info(self):
return f"{[Link]} {[Link]} {[Link]}"

Evaluation Copy 3
Strictly for TUP ECE students only
 # Step 2: Create an object of the Car class
my_car = Car("Toyota", "Corolla", 2022)

# Step 3: Print the car details using the method

print(my_car.display_info())

Task:
 Create a class Laptop with attributes brand, processor, and ram.
 Define a method get_specs() that returns a formatted string of the laptop's specifications.
 Create an object of Laptop, assign values, and print the specifications.

2. Implementing Encapsulation in Python

# Step 1: Define a class with private attributes
class BankAccount:
def init (self, account_holder, balance):
self.account_holder = account_holder
self. balance = balance # Private attribute

def deposit(self, amount):

self. balance += amount
return f"New balance: ${self. balance}"

def get_balance(self):
return f"Balance: ${self. balance}"

# Step 2: Create an object and test encapsulation

account = BankAccount("Alice", 5000)

# Step 3: Deposit money and display the updated balance

print([Link](1500))
print(account.get_balance())

Task:
 Create a class StudentRecord with a private attribute grades.
 Implement methods to add a grade and retrieve the list of grades.
 Test encapsulation by adding grades and printing the list.

3. Applying Inheritance in Python

# Step 1: Define a base class
class Person:
def init (self, name):
[Link] = name

def introduce(self):
return f"Hi, I'm {[Link]}."

# Step 2: Define a subclass that inherits from Person

class Student(Person):
def introduce(self):
return f"Hi, I'm {[Link]}, and I'm a student."

# Step 3: Create objects and call methods

person = Person("Allen")

Evaluation Copy 4
Strictly for TUP ECE students only
 student = Student("Mark")

print([Link]())
print([Link]())

Task:
 Create a base class Device with an attribute device_name and a method power_on().
 Create a subclass Smartphone that overrides power_on() to display a custom message.
 Create objects of both classes and call their methods.

4. Utilizing Polymorphism in Python

# Step 1: Define a base class
class Shape:
def area(self):
return "Calculating area..."

# Step 2: Define subclasses with their implementations

class Circle(Shape):
def init (self, radius):
[Link] = radius

def area(self):
return 3.14 * [Link] * [Link]

class Rectangle(Shape):
def init (self, length, width):
[Link] = length
[Link] = width

def area(self):
return [Link] * [Link]

# Step 3: Create objects and call their methods

circle = Circle(5)
rectangle = Rectangle(4, 6)

print(f"Circle area: {[Link]()}")

print(f"Rectangle area: {[Link]()}")

Task:
● Create a base class Device with a method power_on().
● Create two subclasses: Smartphone and Laptop, both overriding power_on() to display
different startup messages.
● Write a function start_device(device) that takes a Device object and calls its
power_on() method.
● Create objects of Smartphone and Laptop, then pass them to start_device() to
demonstrate polymorphism.

5. Using Object-Oriented Libraries

# Step 1: Import the datetime module
import datetime

# Step 2: Create an object for the current date and time

current_time = [Link]()

Evaluation Copy 5
Strictly for TUP ECE students only
 # Step 3: Print the formatted date and time
print("Current Date and Time:", current_time.strftime("%Y-%m-%d %H:%M:%S"))

Task:
● Import the random module and generate a random floating-point number between 0 and
1.
● Import the os module and print the name of the operating system.

6. Working with Class and Static Methods

# Step 1: Define a class with a static method
class MathOperations:
@staticmethod
def square(num):
return num * num

# Step 2: Get user input

user_input = int(input("Enter a number to square: "))

# Step 3: Call the static method with user input

result = [Link](user_input)

# Step 4: Print the result

print("Square of", user_input, ":", result)

Task:
● Create a class TemperatureConverter with a static method
celsius_to_fahrenheit(celsius).
● Prompt the user to input a temperature in Celsius.
● Use the method to convert the user-provided Celsius temperature to Fahrenheit.
● Print the converted temperature.

7. Operator Overloading in Python

# Step 1: Define a class with overloaded operators
class BankAccount:
def init (self, balance):
[Link] = balance

def add (self, other):

return BankAccount([Link] + [Link])

# Step 2: Create account objects and add their balances

account1 = BankAccount(5000)
account2 = BankAccount(3000)
total_balance = account1 + account2 # Combines the balances

# Step 3: Print the result

print(f"Total Balance: P{total_balance.balance}")

Task:
● Create a class Vector with overloaded + and - operators.

Evaluation Copy 6
Strictly for TUP ECE students only
 ● Perform vector addition and subtraction using instances of the class.

8. Abstract Classes and Methods in Python

from abc import ABC, abstractmethod

# Step 1: Define an abstract class

class Appliance(ABC):
@abstractmethod
def turn_on(self):
pass

# Step 2: Define a subclass implementing the abstract method

class WashingMachine(Appliance):
def turn_on(self):
return "Washing machine is now running."

# Step 3: Create an object of the subclass and call the method

wm = WashingMachine()
print(wm.turn_on())

Task:
● Create another subclass Refrigerator that inherits from Appliance.
● Implement the turn_on() method to return "Refrigerator is now cooling."
● Create an object of Refrigerator and call its turn_on() method.

9. Implementing Method Resolution Order (MRO)

# Step 1: Define multiple classes
class A:
def show(self):
return "Class A"

class B(A):
def show(self):
return "Class B"

class C(A):
def show(self):
return "Class C"

class D(B, C):

pass # Inherits show() based on MRO

# Step 2: Create an object of class D and call the method

obj = D()
print([Link]()) # Output depends on MRO

Task:
● Create four classes that follow multiple inheritance.
● Implement show() in each and observe the output of MRO using print([Link]()).
10. Debugging Exercises
Each code snippet contains an error. Debug and correct them.

Evaluation Copy 7
Strictly for TUP ECE students only
 1. class Person:
def init (self, name):
name = name

p = Person("Allen")
print([Link])

2. class Vehicle:
def init (self, brand):
[Link] = brand

class Car(Vehicle):
def init (self, brand, model):
[Link] = model

my_car = Car("Toyota", "Corolla")

print(my_car.brand, my_car.model)

3. class Animal:
def speak(self):
return "Some sound"

class Dog(Animal):
def speak(self):
"Bark!"

d = Dog()
print([Link]())

4. class BankAccount:
def init (self, balance):
[Link] = balance

def add (self, other):

return [Link] + [Link]

account1 = BankAccount(500)
account2 = BankAccount(300)
total = account1 + account2
print([Link])

5. class Store:
def calculate_discount(price, discount):
return price - (price * discount / 100)

store_instance = Store()
print(Store.calculate_discount(100, 10))

Evaluation Copy 8
Strictly for TUP ECE students only
 IV. DATA AND OBSERVATION

Fill in the table below based on your experiment results.

Trial Code Snippet Output Error Type (if any) Remarks
1 class Car: Car: Toyota Corolla the code initializes
def init (self, brand, model): a Car object and
[Link] = brand prints its details
[Link] = model correctly.
def display_info(self):
return f"Car: {[Link]} {[Link]}"

my_car = Car("Toyota", "Corolla")

print(my_car.display_info())
2 class Student: TypeError Student.get_info(
def init (self, name, grade): ) takes 0
[Link] = name positional
[Link] = grade arguments but 1
was given
def get_info():
return f"Student: {[Link]}, Grade:
{[Link]}"

student1 = Student("Allen", "A")

print(student1.get_info())
3 class BankAccount: New Balance: 1500 Private attributes
def init (self, account_holder, balance): Balance: 1500 work correctly;
self. balance = balance # Private deposit and balance
attribute retrieval function
self.account_holder = account_holder
as expected.
def deposit(self, amount):
self. balance += amount
return f"New Balance: {self. balance}"

def get_balance(self):
return f"Balance: {self. balance}"

account = BankAccount("John Doe", 1000)

print([Link](500))
print(account.get_balance())

Evaluation Copy 9
Strictly for TUP ECE students only
 4 class Animal: Bark! Method overriding
def speak(self): works properly in
return "Some sound"
the subclass Dog.
class Dog(Animal):
def speak(self):
return "Bark!"

dog = Dog()
print([Link]())
5 class Vehicle: Vehicle is moving Inheritance is
def move(self): Uses electricity correctly
return "Vehicle is moving" implemented, and
method overriding
class Car(Vehicle):
def fuel_type(self):
in ElectricCar
return "Uses gasoline" works fine.

class ElectricCar(Car):
def fuel_type(self):
return "Uses electricity"

tesla = ElectricCar()
print([Link]())
print(tesla.fuel_type())
6 class Device: Smartphone is Method overriding
def power_on(self): booting up in Smartphone
return "Device is turning on" works as expected.
class Smartphone(Device):
def power_on(self):
return "Smartphone is booting up"

phone = Smartphone()
print(phone.power_on())
7 class Box: AttributeError 'int' object has
def init (self, weight): no attribute
[Link] = weight 'weight'
def add (self, other):
return [Link] + [Link]

Evaluation Copy 10
Strictly for TUP ECE students only
 box1 = Box(5)
box2 = Box(10)
box3 = box1 + box2
print(f"Total weight: {[Link]} kg")
8 from abc import ABC, abstractmethod Fan is spinning Abstract class
Appliance is
class Appliance(ABC):
properly used with
@abstractmethod
def turn_on(self): an implemented
pass method in Fan.

class Fan(Appliance):
def turn_on(self):
return "Fan is spinning"

fan = Fan()
print(fan.turn_on())
9 class Engine: Engine started Multiple
def start(self): Wheels rolling inheritance works
return "Engine started" Car is moving correctly, calling
methods from
class Wheels:
def roll(self): Engine and Wheels.
return "Wheels rolling"

class Car(Engine, Wheels):

def drive(self):
return "Car is moving"

my_car = Car()
print(my_car.start())
print(my_car.roll())
print(my_car.drive())
10 class MathOperations: Enter a number: 5 The static method
@staticmethod Square: 25 square() correctly
def square(num): computes the square
return num * num
of an input number.
number = int(input("Enter a number: "))
print("Square:", [Link](number))

Evaluation Copy 11
Strictly for TUP ECE students only
 11 class Book: TypeError Book. init ()
def init (self, title, author): missing 1
[Link] = title required
[Link] = author positional
argument:
def get_info(self): 'author'
return f"{[Link]} by {[Link]}"

book1 = Book("1984")
print(book1.get_info())
12 class Product: Laptop costs $1200 Product details
def init (self, name, price): display correctly.
[Link] = name
[Link] = price

def get_details(self):
return f"{[Link]} costs ${[Link]}"

product1 = Product("Laptop", 1200)

print(product1.get_details())
13 class Person: TypeError [Link]()
def init (self, name): takes 0
[Link] = name positional
arguments but 1
def greet(): was given
return f"Hello, {[Link]}"

p = Person("Alice")
print([Link]())
14 class ATM: Withdrawn 200, Withdraw
def init (self, balance): Remaining balance: functionality works
[Link] = balance 800 correctly.
def withdraw(self, amount):
if amount > [Link]:
return "Insufficient balance"
[Link] -= amount
return f"Withdrawn {amount}, Remaining
balance: {[Link]}"

atm = ATM(1000)
print([Link](200))

Evaluation Copy 12
Strictly for TUP ECE students only
 15 class Employee: AttributeError 'Employee' object
def init (self, name, salary): has no attribute
[Link] = name 'display'
[Link] = salary

emp1 = Employee("Michael", 5000)

print([Link]())
16 class Patient: Patient: John Cruz, The patient details
def init (self, name, age, disease): Age: 45, Disease: are correctly
[Link] = name Diabete printed.
[Link] = age
[Link] = disease

def get_info(self):
return f"Patient: {[Link]}, Age:
{[Link]}, Disease: {[Link]}"

patient1 = Patient("John Cruz", 45, "Diabetes")

print(patient1.get_info())
17 class Teacher: Mr. Smith is The teacher's
def init (self, name, subject): teaching method works fine
[Link] = name Mathematics
[Link] = subject

def teach(self):
return f"{[Link]} is teaching
{[Link]}"

teacher1 = Teacher("Mr. Smith", "Mathematics")

print([Link]())
18 class Flight: TypeError Flight. init ()
def init (self, flight_number, destination): missing 1
self.flight_number = flight_number required
[Link] = destination positional
argument:
def book_ticket(self): 'destination'
return f"Ticket booked for flight
{self.flight_number} to {[Link]}"

flight1 = Flight(101)
print(flight1.book_ticket())

Evaluation Copy 13
Strictly for TUP ECE students only
 19 class SmartDevice: Living Room Light The smart device
def init (self, device_name, status="Off"): is now On turns on as
self.device_name = device_name expected.
[Link] = status

def turn_on(self):
[Link] = "On"
return f"{self.device_name} is now
{[Link]}"

light = SmartDevice("Living Room Light")

print(light.turn_on())
20 class Library: Book 'Python Books are added to
def init (self): Programming' added the library and
[Link] = [] to the library displayed
Available Books: correctly.
def add_book(self, title): Python Programmin
[Link](title)
return f"Book '{title}' added to the
library"

def show_books(self):
return f"Available Books: {',
'.join([Link])}"

library = Library()
print(library.add_book("Python Programming"))
print(library.show_books())

Evaluation Copy 14
Strictly for TUP ECE students only
V. ANALYSIS AND INTERPRETATION
1. How does encapsulation help in data security and code maintainability in Python's object-oriented
programming? Provide an example to illustrate its importance.
Encapsulation enhances security by restricting direct access to object attributes, ensuring controlled modifications
through methods. This maintains data integrity and simplifies debugging. For example, a bank account class uses
private attributes with deposit() and withdraw() methods to prevent unauthorized balance changes.
2. In what scenarios would you prefer composition over inheritance when designing a Python application?
Explain your reasoning with a real-world example.
Composition is preferred when flexibility is needed, avoiding rigid inheritance structures. Instead of inheriting, a
class contains objects of other classes, promoting modularity. For instance, a Car class can have an Engine object,
allowing different cars to use various engines without modifying the main class.
3. How does method overriding in polymorphism improve code flexibility, and how does it differ from method
overloading in other programming languages?
Method overriding allows subclasses to redefine inherited methods, improving flexibility. Unlike method
overloading in other languages, Python uses default and variable-length arguments to achieve similar results.
Overriding ensures objects behave appropriately based on their actual type, essential for polymorphism.

VI. DISCUSSION
Method overriding supports polymorphism, ensuring subclass methods can modify inherited behavior for better
customization. Together, these principles improve software design, making applications more scalable and easier
to manage. Encapsulation, composition, and method overriding are fundamental object-oriented programming
principles that enhance security, flexibility, and maintainability in Python applications. Encapsulation protects data
by restricting direct access and enforcing controlled interactions, reducing errors and improving debugging.
Composition promotes modularity by allowing objects to contain other objects, making code reusable and adaptable
to changes without modifying the main class structure.

VII. CONCLUSION
Mastering these concepts helps developers write cleaner, reusable, and well-structured code, essential for building
scalable applications. Understanding and applying encapsulation, composition, and method overriding in Python
leads to more secure, maintainable, and flexible software development. Encapsulation safeguards sensitive data,
composition enhances code modularity, and overriding methods improve object-specific behavior, ensuring
efficient and adaptable programs.

VIII. REFERENCES
[Link]. (n.d.). [Link]

IX. EXERCISES

1. Library Book Management System

Functionality:
Develop a program that allows a library to manage books, including adding new books,
borrowing, and returning them.

Input:
Evaluation Copy 15
Strictly for TUP ECE students only
 ● The user enters the number of books to add.
● For each book, the user provides a title, author, and availability status.
● The user can borrow a book by entering its title.
● The user can return a borrowed book.

Calculations:
● Keep track of which books are available, and which are borrowed.
● Ensure that a book cannot be borrowed if it is checked out.

Output:
● Display the list of books with their status (available/borrowed).
● Confirm when a book is successfully borrowed or returned.

Handle Invalid Inputs:

● Reject borrowing a book that doesn’t exist or is already borrowed.
● Ensure book titles are entered as strings.

2. Employee Payroll System

Functionality:
Create a payroll system that calculates the monthly salary of employees based on their hourly
rate and hours worked.

Input:
● The user enters the number of employees.
● For each employee, the user provides a name, hourly wage, and total hours worked.

Calculations:
● Compute the monthly salary as:
Salary = Hourly Rate × Hours Worked
● If an employee works over 160 hours, calculate overtime pay at 1.5× the hourly rate for
extra hours.

Output:
● Display each employee’s name, total hours worked, base salary, and overtime pay if
applicable.

Handle Invalid Inputs:

● Reject negative hours or wages.
● Ensure at least one employee is entered.

3. Online Shopping Cart System

Functionality:
Develop a shopping cart system where users can add products, remove them, and view the
total price.

Input:
● The user selects products to add from a predefined list.

Evaluation Copy 16
Strictly for TUP ECE students only
 ● Each product has a name, price, and stock quantity.
● The user can remove items from the cart before checkout.
Calculations:
● Keep track of total cost as items are added/removed.
● Ensure stock availability before adding a product.

Output:
● Display the cart’s content with the total price.
● Confirm when an item is successfully added or removed.

Handle Invalid Inputs:

● Prevent adding more items than available stock.
● Reject invalid product selections.

Evaluation Copy 17
Strictly for TUP ECE students only
X. APPENDICES
Appendix A: Screenshots of Program Outputs
(Attach sample screenshots of your outputs here.)

Evaluation Copy 18
Strictly for TUP ECE students only
Evaluation Copy 19
Strictly for TUP ECE students only
Evaluation Copy 20
Strictly for TUP ECE students only
Evaluation Copy 21
Strictly for TUP ECE students only
Evaluation Copy 22
Strictly for TUP ECE students only
Evaluation Copy 23
Strictly for TUP ECE students only
Evaluation Copy 24
Strictly for TUP ECE students only
Evaluation Copy 25
Strictly for TUP ECE students only
Evaluation Copy 26
Strictly for TUP ECE students only
Evaluation Copy 27
Strictly for TUP ECE students only
Evaluation Copy 28
Strictly for TUP ECE students only
Appendix B: Complete Python Code for All Procedures

Evaluation Copy 29
Strictly for TUP ECE students only
Evaluation Copy 30
Strictly for TUP ECE students only
Evaluation Copy 31
Strictly for TUP ECE students only
Evaluation Copy 32
Strictly for TUP ECE students only
Evaluation Copy 33
Strictly for TUP ECE students only
Evaluation Copy 34
Strictly for TUP ECE students only
Appendix C: Complete Python Code for All Exercises

Evaluation Copy 35
Strictly for TUP ECE students only
Evaluation Copy 36
Strictly for TUP ECE students only
Evaluation Copy 37
Strictly for TUP ECE students only
Evaluation Copy 38
Strictly for TUP ECE students only
Evaluation Copy 39
Strictly for TUP ECE students only
Evaluation Copy 40
Strictly for TUP ECE students only
Evaluation Copy 41
Strictly for TUP ECE students only
Evaluation Copy 42
Strictly for TUP ECE students only
Evaluation Copy 43
Strictly for TUP ECE students only
Evaluation Copy 44
Strictly for TUP ECE students only
Evaluation Copy 45
Strictly for TUP ECE students only
Evaluation Copy 46
Strictly for TUP ECE students only
Evaluation Copy 47
Strictly for TUP ECE students only
Evaluation Copy 48
Strictly for TUP ECE students only
Evaluation Copy 49
Strictly for TUP ECE students only
Evaluation Copy 50
Strictly for TUP ECE students only
Evaluation Copy 51
Strictly for TUP ECE students only
Evaluation Copy 52
Strictly for TUP ECE students only
Evaluation Copy 53
Strictly for TUP ECE students only
Evaluation Copy 54
Strictly for TUP ECE students only
Evaluation Copy 55
Strictly for TUP ECE students only
Evaluation Copy 56
Strictly for TUP ECE students only
Evaluation Copy 57
Strictly for TUP ECE students only