KLUNIVERSITY

FRESH MAN ENGINEERING DEPARTMENT

A Project Based Lab

Report On

Hospital Management System

SUBMITTEDBY:

I.DNUMBER NAME

2200080087 S.JASWANTH SAI

UNDERTHE ESTEEMEDGUIDANCE OF

Dr. R. MEGANATHAN

ASSOCIATE PROFESSOR

KLUNIVERSITY
Green fields,
Vaddeswaram – 522 502
GunturDt., AP, India
 DEPARTMENT OF BASIC ENGINEERING SCIENCES

CERTIFICATE

This is to certify that the project-based laboratory report entitled“

Project title ”submitted by bearing 2200080087 S. Jaswanth sai to the
Department of Basic Engineering Sciences, KL-University in partial
fulfillment of the requirements for the completion of a project in OBJECT
ORIENTED PROGRAMMING SYSTEM –22AD1202 course in I- B-Tech II
Semester ,is a bonafide record of the work carried out by him/he supervision
during the academic year2022-23.

PROJECTSUPERVISOR HEADOFTHEDEPARTMENT

Dr. R. MEGANATHAN Dr. D . HARITHA

 ACKNOWLEDGEMENTS

It is great pleasure format to express my gratitude tour honorable

President Sri. Koneru Satyanarayana, for giving the opportunity and platform
with facilities in accomplishing the project-based laboratory report.

I express the since re-gratitude to our director Dr.A.Jagadeesh for his

administration towards our academic growth.

I express sincere gratitude to our Coordinators and HOD-BES Dr. D.

Haritha for her leadership and constant motivation provided in successful
completion of our academic semester. I record it as my privilege to deeply
thank form providing us the efficient faculty and facilities to make our ideas
into reality.

I express my sincere thanks to our project supervisor Dr. R. Meganathan

for his novel association of ideas, encouragement, appreciation, and intellectual
zeal which motivated us to venture this project successfully.

Finally, it is pleased to acknowledge the indebtedness to all those who

devoted themselves directly or indirectly to make this project report success.

I.DNUMBER NAME

2200080087 S. JASWANTH SAI

 INDEX

S.NO TITLE PAGENO

1 Abstract 1

2 Introduction 2

3 Objectives 3

4 Scope of the project 4

5 Features 5

6 System Requirements 6

7 Class diagram 7

8 Classes 8-9

9 Implementation 10-11

10 Result 12

Conclusion
11
 ABSTRACT

A hospital management system is a software application that is designed by object

oriented programming language to manage the administrative, financial, and
clinical operations of a hospital or medical facility. It is an integrated system that
covers all aspects of hospital operations, including patient registration,
appointment scheduling, billing and invoicing, electronic medical records (EMRs),
laboratory management, pharmacy management, inventory management, and
more.
The system provides a comprehensive and centralized platform that helps
healthcare providers streamline their workflows, reduce administrative overheads,
and improve patient care. By automating routine tasks, the hospital management
system enables healthcare providers to focus on delivering high-quality medical
services to their patients.
Some of the key benefits of a hospital management system include:
1. Improved patient care and safety
2. Enhanced operational efficiency
3. Better financial management and revenue generation
4. Seamless communication and collaboration between different departments
5. Streamlined workflow and reduced paperwork
6. Compliance with regulatory requirements
Overall, a hospital management system is an essential tool for modern healthcare
providers to ensure efficient and effective delivery of medical services.

[1]
 INTRODUCTION

The Hospital Management System project aims to provide a digital

solution for maintaining and organizing data in a hospital. The
system will help in managing and automating various hospital
activities such as patient registration, appointment scheduling,
billing, and maintaining patient records. The project utilizes object-
oriented programming (OOP) concepts in Python, which involves
creating classes and objects to represent different entities such as
patients, doctors, and rooms. The program's main objective is to
manage the hospital information effectively without using a
database, making use of data structures such as lists, dictionaries,
or sets to store the data. The project’s ultimate goal is to develop a
user-friendly program to develop a user-friendly hospital
management system that can be easily used by hospital staff. To
automate various hospital activities to save time and increase
efficiency. To improve patient care by maintaining accurate
patient records. A comprehensive solution for hospital
management.
 [2]

Objectives:

The objectives of the Hospital Management System project are as follows:

 To design a Hospital Management System using object-oriented programming

concepts in Python that can manage and store patient data electronically
according to the needs of and library administrators.

 Patient Class: This class allows the user to check-in, check-out, and view patient
information. Patients can be added to the system by providing their name, age,
illness, and contact information.

 Doctor Class: This class enables doctors to view their schedule, patient
information, and prescribe medication. Doctors can be added to the system by
providing their name, specialization, and contact information.

 Room Class: This class helps users to view room availability and book a room.
Rooms can be added to the system by providing their room number, occupancy
status, and room type

 Appointment Class: This class enables users to schedule appointments, view

upcoming appointments, and cancel appointments. The system maintains
appointment details like the patient name, doctor name, and appointment time.

 To ensure the program is user-friendly and can be easily used by patients, doctors,
working staff.

 To test the program thoroughly to ensure it is working as expected and meets the
requirements of managing Hospital information using OOP concepts, without
using a database.

[3]
Scope of the project

The scope of the library management system project is to develop a

software application that can manage hospital information efficiently The
scope of this mini project for a Hospital Management System using OOP
concepts and not using a database is limited to a simple system that can
handle basic operations related to patient management, doctor
management, room management, appointment management, and billing
management .The project can be used to understand and practice various
OOP concepts such as encapsulation, inheritance, and polymorphism. It
can help you learn how to create and manage classes, objects, and
methods and how they interact with each other in a real-world
scenario .The project can be used by small clinics, hospitals, or medical
centers that have a limited number of patients, doctors, rooms, and
appointments. It can be used to manage patient information, doctor
information, room availability, appointment scheduling, and billing
information .The system can handle operations such as adding new
patients, doctors, and rooms, checking-in and checking-out patients,
scheduling appointments, prescribing medications, viewing patient
information, viewing schedules, viewing room availability, viewing bills,
and paying bills .However, the project has some limitations in terms of
scalability, data management, and data recovery as it does not use any
database. Therefore, it is not suitable for large hospitals or medical
centers that have a large number of patients, doctors, rooms, and
appointments. For a real-world application, it is recommended to use a
database management system to handle data efficiently and ensure
scalability, data management, and data recovery

[4]
 Features
The key features of theLibrary Management System include:
• To design and implement a simple hospital management system using
object-oriented programming concepts such as encapsulation, inheritance,
and polymorphism.
• Patient Class: This class allows the user to check-in, check-out, and view
patient information. Patients can be added to the system by providing their
name, age, illness, and contact information.

• Doctor Class: This class enables doctors to view their schedule, patient information, and
prescribe medication. Doctors can be added to the system by providing their name,
specialization, and contact information.

• Room Class: This class helps users to view room availability and book a room. Rooms can
be added to the system by providing their room number, occupancy status, and room
type

• Appointment Class: This class enables users to schedule appointments, view upcoming
appointments, and cancel appointments. The system maintains appointment details like
the patient name, doctor name, and appointment time.

• To ensure the program is user-friendly and can be easily used by patients, doctors,
working staff.

• To develop methods for adding new patients, doctors, and rooms, checking-in and
checking-out patients, scheduling appointments, prescribing medications, viewing patient
information, viewing schedules, viewing room availability, viewing bills, and paying bills

• Data structures: The project stores hospital information in data structures such as
lists, dictionaries, or sets. These data structures store the patients and doctor
objects and can be saved to a file or memory.

• No database: The project doesn't use a database to store the hospital information,
making it simpler to develop and maintain.

[5]
 SYSTEMREQUIREMENTS

 Requirements

 SOFTWAREREQUIREMENTS:
The major software requirements of the project are as follows
Language : python
Operating system : Windows XP or later.
Complier : IDLE, PyCharm, Spyder, VS Code

 HARDWAREREQUIREMENTS:
The hardware requirements that map towards the software are :

RAM : 4GBor later

Processor : Intelcorei5orlater

 Other Requirements:

 Clear understanding of project requirements and objectives.

 Clear understanding of Python OOPs concepts
 Effective project management tools and method logics to manage project
tasks.
 CollaborationtoolssuchasSlack,Trello,orAsanatofacilitateteamcommunicat
ionandtaskmanagement.
 Qualityassuranceandtestingtoolstoensureprojectfunctionalityandstability.
 Adequate security measures to protect sensitive data and information.
 DocumentationtoolssuchasSphinxorJupyterNotebooktocreateprojectdocu
mentation.
 Regular backups of project data and source code to prevent data loss.
 Trainingorfamiliaritywithproject-specifictechnologiesorframeworks.
 Compliancewithanyrelevantlawsandregulations,suchasdataprotectionand
privacylaws.

[6]

Class diagram
 Class: patient

Name: string

Age: int

illness: string

contact_info: string

Check_in( ) :

Check_out( ) :

View_info():

Class: doctor

name: string

Specialty : string

Contact_info : string

View_schedule( ):

View_appointment( ):

Prescribe_medication( ) :
 Class: room

room_no: int

occupancy_status: str

room_type: str

view_availability():

book_room():

Class:
appointment
patient: str

services: str

doctor: str

time: str

schedule()

view_upcoming()

cancel()

[7]
 Classes

These are two classes that will be designed as part of our project. Here's a
detailed description of each class with its properties, methods, and
relationships with other classes:

Class: patient

Attributes:

 Name : a string representing the name of the patient.

 Age : an integer representing the age of the patient
 illness : a string representing the illness of the patient.
 Contact_info: a string representing the contact information of the
patient.
Methods:

 check_in(): A method that takes an instance of the Patient class as an

argument and checks the patient is in .
 Check_out(): A method that takes an instance of the Patient class as an
argument and checks the patient is in .
 View_info(): A method that displays the name, age, illness and contact
information of the patient.

Relationships with other classes:

 A Patient can have an Appointment, which references a Doctor and a time.

.

Class: doctor

Attributes:

 name: a string representing the name of the doctor.

 specialization: a string representing the specialization of the doctor
 Contact_info: a string representing the contact information of the
doctor
Methods:

 View_schedule(): A method that takes an instance of the doctor class

as an argument and checks the schedules of the doctor
 View_appointment(): A method that takes an instance of the Book
class as an argument and checks the appointments of the doctor
 Prescribe_medication(): A method that displays the medicines
prescribed to the patient.
Relationships with other classes:

 A Doctor can have many Patients and many Appointments. The doctor class
has relation with patient and appointment class

.
Class: room

Attributes:

 Room_no : a string representing the number of the room.

 Occupancy_status : an string representing the occupancy status of the
room
 Room_type : a string representing the type of the room.

Methods:

 View_avilability( ): A method that takes instance of the patient class

and is used to check whether the room is available or not.
 Book_room(): A method that takes the instance of the patient
classand is used to book room
Relationships with other classes:

 A Room can be occupied by a Patient. Room class has relation with patient class

.
Class: appointment

Attributes:

 patient: representing the patient .

 services : an string representing the services needed to the
patient
 doctor : a string representing the doctor.
 Time: a string representing the appointment time

Methods:

• schedule(): A method that is used to check the schedule of the doctor.

• View_upcoming: A method that is used to view upcoming

appointments.
• Cancel: a method used to cancel the appointment
Relationships with other classes:
  A Patient can have an Appointment, which references a Doctor and a time.
 A Doctor can have many Patients and many Appointments

.
Class: bill

Attributes:

 patient : a string representing the patient.

 cost: an integer representing the cost

Methods:

view_bill(): A method that takes instance of the patient class and is used to
check the bill.
pay_bill (): A method that takes the instance of the patient class and is used to
pay bill

Relationships with other classes:

 A Room can be occupied by a Patient. Room class has relation with patient class

[9]

Implementation

class Patient:
 def __init__(self, name, age, illness, contact_info):
self.name = name
self.age = age
self.illness = illness
self.contact_info = contact_info
self.checked_in = False

def check_in(self):
self.checked_in = True

def check_out(self):
self.checked_in = False

def view_info(self):
return f"Name: {self.name}\nAge: {self.age}\nIllness: {self.illness}\nContact Info:
{self.contact_info}\nChecked In: {self.checked_in}"

class Doctor:
def __init__(self, name, specialization, contact_info):
self.name = name
self.specialization = specialization
self.contact_info = contact_info

def view_schedule(self):
# some logic for displaying the doctor's schedule
pass

def view_patient_info(self, patient):

# some logic for displaying the patient's information
pass

def prescribe_medication(self, patient, medication):

# some logic for prescribing medication to a patient
pass

class Room:
def __init__(self, room_number, occupancy_status, room_type):
self.room_number = room_number
self.occupancy_status = occupancy_status
self.room_type = room_type

def view_availability(self):
return f"Room {self.room_number} is currently {'occupied' if self.occupancy_status
else 'vacant'}."

def book(self):
self.occupancy_status = True
class Appointment:
def __init__(self, patient, doctor, time):
self.patient = patient
self.doctor = doctor
self.time = time

def schedule(self):
# some logic for scheduling an appointment
pass

def view_upcoming(self):
# some logic for displaying upcoming appointments
pass

def cancel(self):
# some logic for cancelling an appointment
pass

class Bill:
def __init__(self, patient, services, cost):
self.patient = patient
self.services = services
self.cost = cost

def view_bill(self):
return f"Patient: {self.patient}\nServices: {self.services}\nTotal Cost: {self.cost}"

def pay(self):
# some logic for processing payment
pass

class Main:
def __init__(self):
self.patients = []
self.doctors = []
self.rooms = []
self.appointments = []
self.bills = []

def add_patient(self, patient):

self.patients.append(patient)

def add_doctor(self, doctor):

self.doctors.append(doctor)

def add_room(self, room):

self.rooms.append(room)

def view_patients(self):
 for patient in self.patients:
print(patient.view_info())

def view_doctors(self):
for doctor in self.doctors:
print(f"Name: {doctor.name}\nSpecialization: {doctor.specialization}\nContact
Info: {doctor.contact_info}")

def view_rooms(self):
for room in self.rooms:
print(room.view_availability())

def view_appointments(self):
for appointment in self.appointments:
print(f"Patient: {appointment.patient}\nDoctor: {appointment.doctor}\nTime:
{appointment.time}")

def view_bills(self):
for bill in self.bills:
print(bill.view_bill())
patient1 = Patient("John Smith", 35, "Flu", "555-1234")
patient1.check_in()
patient2 = Patient("Jane Doe", 50, "Pneumonia", "555-5678")

doctor1 = Doctor("Dr. Smith", "Cardiology", "555-1111")

doctor2 = Doctor("Dr. Doe", "Oncology", "555-2222")

room1 = Room(101, False, "Single")

room2 = Room(102, True, "Double")

appointment1 = Appointment(patient1, doctor1, "2023-04-01 10:00")

appointment2 = Appointment(patient2, doctor2, "2023-04-02 11:00")

bill1 = Bill(patient1.name, "Consultation", 100)

bill2 = Bill(patient2.name, "Tests", 500)
hospital = Main()
hospital.add_patient(patient1)
hospital.add_patient(patient2)
hospital.add_doctor(doctor1)
hospital.add_doctor(doctor2)
hospital.add_room(room1)
hospital.add_room(room2)
hospital.appointments.append(appointment1)
hospital.appointments.append(appointment2)
hospital.bills.append(bill1)
hospital.bills.append(bill2)

hospital.view_patients()
hospital.view_doctors()
hospital.view_rooms()
hospital.view_appointments()
hospital.view_bills()

[11]

RESULT

Name: John Smith

Age: 35
Illness: Flu
Contact Info: 555-1234
Checked In: True
Name: Jane Doe
Age: 50
Illness: Pneumonia
Contact Info: 555-5678
Checked In: False
Name: Dr. Smith
Specialization: Cardiology
Contact Info: 555-1111
Name: Dr. Doe
Specialization: Oncology
Contact Info: 555-2222
Room 101 is currently vacant.
Room 102 is currently occupied.
Time: 2023-04-01 10:00
Time: 2023-04-02 11:00
Patient: John Smith
Services: Consultation
Total Cost: 100
Patient: Jane Doe
Services: Tests
Total Cost: 500

CONCLUSION:

Hospital management systems can streamline administrative tasks, improve patient

care, and enhance operational efficiency. These systems can automate many routine
tasks, such as patient registration and appointment scheduling, allowing healthcare
providers to focus on patient care. They can also provide real-time access to patient
records, test results, and other critical information, which can improve patient
safety and quality of care.

However, implementing a hospital management system can be challenging and

costly. It requires a significant investment in technology, infrastructure, and staff
training. It can also be difficult to integrate with existing systems, such as electronic
health records, and may require substantial changes to workflows and processes.
Additionally, the implementation of such systems can pose security and privacy
risks, particularly with respect to patient data.

Overall, hospital management systems have the potential to transform healthcare

delivery by improving efficiency and patient outcomes. However, careful planning,
implementation, and ongoing monitoring are necessary to ensure success and
mitigate potential risks.

[12]