Problem Based Learning

E-Commerce Cart

System Use Case:

An online shopping site needs a simple shopping cart feature.

Modules:

 product.py: Manage products (name, price, stock).

 cart.py: Add/remove products, view cart total.

 discounts.py: Apply coupon codes and discounts.

 payment.py: Simulate payment processing.

Ans:

product.py

class Product:

def init (self, name, price, stock):

self.name = name

self.price = price

self.stock = stock

def str (self):

return f"{self.name} - ₹{self.price} (Stock: {self.stock})"

cart.py

from product import Product

class Cart:

def init (self):

self.items = {}

def add_product(self, product, quantity):

if product.stock >= quantity:

self.items[product] = self.items.get(product, 0) + quantity

product.stock -= quantity
 print(f"Added {quantity} x {product.name} to cart.")

else:

print("Not enough stock available.")

def remove_product(self, product, quantity):

if product in self.items and self.items[product] >= quantity:

self.items[product] -= quantity

product.stock += quantity

if self.items[product] == 0:

del self.items[product]

print(f"Removed {quantity} x {product.name} from cart.")

else:

print("Item not in cart or invalid quantity.")

def total_price(self):

return sum(product.price * quantity for product, quantity in self.items.items())

def view_cart(self):

for product, quantity in self.items.items():

print(f"{product.name} x {quantity} - ₹{product.price * quantity}")

print(f"Total: ₹{self.total_price()}")

discounts.py

class Discount:

coupons = {"SAVE10": 0.10, "OFF20": 0.20}

@staticmethod

def apply_discount(total, coupon_code):

if coupon_code in Discount.coupons:

discount = total * Discount.coupons[coupon_code]

return total - discount

payment.py

class Payment:

@staticmethod

def process_payment(amount):

print(f"Processing payment of ₹

{amount}...") print("Payment successful!")

main.py

from product import Product

from cart import Cart

from discounts import Discount

from payment import Payment

p1 = Product("Laptop", 50000, 5)

p2 = Product("Phone", 25000, 10)

cart = Cart()

cart.add_product(p1, 1)

cart.add_product(p2, 2)

cart.view_cart()

total = cart.total_price()

total_after_discount = Discount.apply_discount(total, "SAVE10")

print(f"Total after discount: ₹{total_after_discount}")

Payment.process_payment(total_after_discount)
Library Management System

Use Case:

A school/college library wants to automate book issue/return management.

Modules:

 book.py: Functions to add, remove, search for books.

 member.py: Functions to add members, check borrowing limits.

 transaction.py: Issue, return, calculate overdue fines.

 reports.py: Generate reports (issued books, fines due).

Ans:

book.py

class Book:

def init (self, title, author, book_id, copies):

self.title = title

self.author = author

self.book_id = book_id

self.copies = copies

def str (self):

return f"{self.book_id}: {self.title} by {self.author} (Copies: {self.copies})"

class Library:

def init (self):

self.books = {}
 def add_book(self, book):

self.books[book.book_id] = book

print(f"Book '{book.title}' added.")

def remove_book(self, book_id):

if book_id in self.books:

del self.books[book_id]

print("Book removed.")

else:

print("Book not found.")

def search_book(self, title):

for book in self.books.values():

if book.title.lower() == title.lower():

return book

return "Book not found."

member.py

class Member:

def init (self, member_id, name, max_books=3):

self.member_id = member_id

self.name = name

self.borrowed_books = []

self.max_books = max_books

def can_borrow(self):

return len(self.borrowed_books) < self.max_books

def str (self):

return f"Member {self.member_id}: {self.name} (Borrowed:

from datetime import datetime, timedelta

class Transaction:

def init (self):

self.issued_books = {} # {book_id: (member_id, issue_date)}

def issue_book(self, book, member):

if book.copies > 0 and member.can_borrow():

issue_date = datetime.now()

self.issued_books[book.book_id] = (member.member_id, issue_date)

book.copies -= 1

member.borrowed_books.append(book)

print(f"Book '{book.title}' issued to {member.name}.")

else:

print("Cannot issue book. Either out of stock or limit reached.")

def return_book(self, book, member):

if book.book_id in self.issued_books:

issue_date = self.issued_books.pop(book.book_id)[1]

return_date = datetime.now()

overdue_days = (return_date - issue_date).days - 14 # 14-day limit

fine = max(0, overdue_days * 10) # ₹10 per overdue day

book.copies += 1

member.borrowed_books.remove(book)

print(f"Book '{book.title}' returned by {member.name}. Fine: ₹{fine}")

else:

print("Book not found in issued records.")

class Reports:

@staticmethod

def issued_books(transaction, library):

print("\nIssued Books Report:")

for book_id, (member_id, issue_date) in transaction.issued_books.items():

book = library.books.get(book_id)

print(f"{book.title} issued to Member {member_id} on {issue_date}")

@staticmethod

def calculate_fines(transaction):

print("\nFines Due Report:")

from datetime import datetime

for book_id, (member_id, issue_date) in transaction.issued_books.items():

overdue_days = (datetime.now() - issue_date).days - 14

if overdue_days > 0:

fine = overdue_days * 10

print(f"Member {member_id} has ₹{fine} fine for Book ID {book_id}.")

main.py

from book import Book, Library

from member import Member

from transaction import Transaction

from reports import Reports

library = Library()

transaction = Transaction()

book1 = Book("Python Basics", "John Doe", 101, 5)

book2 = Book("Data Science", "Jane Smith", 102, 3)

library.add_book(book1)
library.add_book(book2)

member1 = Member(1, "Alice")

member2 = Member(2, "Bob")

transaction.issue_book(book1, member1)

transaction.issue_book(book2, member2)

Reports.issued_books(transaction, library)

transaction.return_book(book1, member1)

Reports.calculate_fines(transaction)

Hotel Reservation System

Use Case:

A hotel booking application where users book rooms, check availability, and manage
payments.

Modules:

 rooms.py: Manage room types, availability.

 booking.py: Reserve/cancel bookings.

 billing.py: Calculate charges, generate bills.

 customer.py: Customer registration and login.

rooms.py

class Room:

def init (self, room_number, room_type, price, available=True):

self.room_number = room_number

self.room_type = room_type

self.price = price

self.available = available

def str (self):

status = "Available" if self.available else "Booked"

return f"Room {self.room_number}: {self.room_type} - ₹{self.price} ({status})"

class Hotel:

def init (self):

self.rooms = {}

def add_room(self, room):

self.rooms[room.room_number] =

room

def check_availability(self):

return [room for room in self.rooms.values() if room.available]

booking.py

from rooms import Room, Hotel

class Booking:

def init (self):

self.bookings = {} # {room_number: customer_id}

def reserve_room(self, customer_id, hotel, room_number):

hotel.rooms[room_number].available = False

self.bookings[room_number] = customer_id

print(f"Room {room_number} booked for Customer {customer_id}.")

else:

print("Room not available.")

def cancel_booking(self, hotel, room_number):

if room_number in self.bookings:

del self.bookings[room_number]

hotel.rooms[room_number].available = True

print(f"Booking for Room {room_number} canceled.")

else:

print("No booking found for this room.")

billing.py

class Billing:

def init (self):

self.bills = {} # {customer_id: total_amount}

def generate_bill(self, customer_id, hotel, room_number, nights):

if room_number in hotel.rooms:

total_cost = hotel.rooms[room_number].price * nights

self.bills[customer_id] = total_cost

print(f"Bill for Customer {customer_id}: ₹{total_cost} for {nights} nights.")

else:

print("Invalid room number.")

customer.py

class Customer:

def init (self, customer_id, name, contact):

self.name = name

self.contact = contact

def str (self):

return f"Customer {self.customer_id}: {self.name}, Contact: {self.contact}"

main.py

from rooms import Room, Hotel

from booking import Booking

from billing import Billing

from customer import Customer

hotel = Hotel()

booking =

Booking() billing =

Billing()

hotel.add_room(Room(101, "Deluxe", 5000))

hotel.add_room(Room(102, "Suite", 8000))

customer1 = Customer(1, "Alice", "9876543210")

available_rooms = hotel.check_availability() print("\

nAvailable Rooms:")

for room in available_rooms:

print(room)

booking.reserve_room(customer1.customer_id, hotel, 101)

billing.generate_bill(customer1.customer_id, hotel, 101, 3)

available_rooms = hotel.check_availability()

print("\nAvailable Rooms After Cancellation:")

for room in available_rooms:

print(room)

Student Grading System

Use Case:

A teacher needs an app to calculate grades, store student info, and generate reports.

Modules:

 student.py: Student details (name, roll number).

 marks.py: Add marks, calculate total and average.

 grading.py: Assign grades based on total marks.

 report.py: Generate report cards.

Ans:

student.py

class Student:

def init (self, roll_no, name):

self.roll_no = roll_no

self.name = name

def str (self):

return f"Roll No: {self.roll_no}, Name: {self.name}"

class Marks:

def init (self):

self.student_marks = {} # {roll_no: [marks]}

def add_marks(self, roll_no, marks):

self.student_marks[roll_no] = marks

print(f"Marks added for Roll No {roll_no}")

def calculate_total(self, roll_no):

return sum(self.student_marks.get(roll_no, []))

def calculate_average(self, roll_no):

marks = self.student_marks.get(roll_no, [])

return sum(marks) / len(marks) if marks else 0

grading.py

class Grading:

@staticmethod

def assign_grade(total):

if total >= 90:

return "A+"

elif total >= 80:

return "A"

elif total >= 70:

return "B"

elif total >=

60:

return "C"

elif total >=

50:

return "D"

else:
 return "F (Fail)"

report.py

from grading import Grading

class Report:

@staticmethod

def generate_report(student, marks_module):

total = marks_module.calculate_total(student.roll_no)

average = marks_module.calculate_average(student.roll_no)

grade = Grading.assign_grade(average)

print("\nStudent Report:")

print(f"{student}")

print(f"Total Marks: {total}")

print(f"Average Marks: {average:.2f}")

print(f"Grade: {grade}")

main.py

from student import Student

from marks import Marks

from grading import Grading

from report import Report

marks_module = Marks()

student1 = Student(101, "Alice")

student2 = Student(102, "Bob")

marks_module.add_marks(student1.roll_no, [85, 90, 78, 92, 88]) # 5 subjects

marks_module.add_marks(student2.roll_no, [60, 70, 55, 65, 75])

Report.generate_report(student2, marks_module)