ACKNOWLEDGEMENT

I would like to owe the sense of gratitude to our Informatics

Practices teacher Ms. Poonam for her consistent guidance,
support and encouragement without which this project
would not be able to exist in present shape.

I would also thank my parents for their blessings and my

friends for their help in order to complete the project.

Special thanks to Principal Mam, MRS. JITENDER KAUR

-Jasmine kaur
 CERTIFICATE
This is to certify that Jasmine kaur of XII (Medical) has
completed the Informatics Practices project entitled,
“SCHOOL MANAGEMENT SYSTEM” under the
guidance of his Informatics Practices teacher
Ms. Poonam for class +2 practical examination of the
CBSE in session 2022-2023.

The progress of the project has been continuously reported

and has been acknowledged consistently.

. . . .
Signature of Internal examiner Signature of External examiner

. .
Signature of principal
 GURU NANAK PUBLIC SR SEC SCHOOL

Jagaatkhana Nalagarh

PROJECT FILE OF
INFORMATICS PRACTICES(065)
SUBMITTED BY: SUBMITTED TO:
Name : Jasmine kaur Mrs. Poonam

Class: XII (Medical)

Rollno. :
 CONTENTS
▪ Introduction
▪ Objectives of the project
▪ Proposed system
▪ Planning phase
▪ Requirement analysis phase
▪ Design phase
▪ Development phase
▪ Integration and Test phase
▪ Implementation phase
▪ Operation and maintenance phase
▪ Requirements
▪ Source code
▪ Outputs
▪ Chart
▪ Bibliography
STUDENT MANAGEMENT SYSTEM

❖ INTRODUCTION
The School management system is basically a database based project done
with help of python language. This project is very useful for the schools to
maintain the data of the students . This project is multifield project ,so that it
can be modified for various purposes.

❖ OBJECTIVES OF THE PROJECT

The objective of this project is to let the students apply the
programming knowledge into a real- world situation/problem and exposed
the students how programming skills helps in developing a good software.

➢ Write programs utilizing modern software tools.

➢ Apply object oriented programming principles effectively when
developing small to medium sized projects.
➢ Write effective procedural code to solve small to medium sized
problems.
➢ Students will demonstrate a breadth of knowledge in Informatics
practices, as exemplified in the areas of systems, theory and software
development.
➢ Students will demonstrate ability to conduct a research or applied
Informatics Practices project, requiring writing and presentation skills
which exemplify scholarly style in informatics Practices.
❖ Proposed system
Today one cannot afford to rely on the fallible human beings of be really
wants to stand against today’s merciless competition where not to wise
saying “to err is human” no longer valid, it’s outdate to rationalize your
mistake. So, to keep pace with time, to bring about the best result without
malfunctioning and greater efficiency so to replace the unending heaps of
flies with a much sophisticated hard disk of the computer .

One has to use the data management software. Software has been an ascent
in atomization various organisations. Many software products working are
now in markets, which have helped in making the organizations work easier
and efficiently. Data management initially had to maintain a lot of ledgers
and a lot of paper work has to be done but now software product on this
organization has made their work faster and easier. Now only this software
has to be loaded on the computer and work can be done.

This prevents a lot of time and money. The work becomes fully automated
and any information regarding the organization can be obtained by clicking
the button. Moreover, now it’s an age of computers of and automating such
an organization gives the better look

❖ PLANNING PHASE
The planning phase is the most critical step in completing development,
acquisition, and maintenance projects. Careful planning, particularly in the
 early stages of a project, is necessary to coordinate activities and manage
project risks effectively. The depth and formality of project plans should be
commensurate with the characteristics and risks of a given project. Project
plans refine the information gathered during the initiation phase by further
identifying the specific activities and resources required to complete a
project.

A critical part of a project manager’ job is to coordinate discussions between

user, audit, security, design, development, and network personnel to identify
and document as many functional, security, and network requirements as
possible. During this phase, a plan is developed that documents the approach
to be used and includes a discussion of methods, tools, tasks, resources,
project schedules, and user input. Personnel assignments, costs, project
schedule, and target dates are established.

A Project Management Plan is created with components related to

acquisition planning, configuration management planning, quality assurance
planning, concept of operations, system security, verification and validation,
and systems engineering management planning.

❖ REQUIREMENT ANALYSIS PHASE

This phase formally defines the detailed functional user requirements using
high level requirements identified in the Initiation, System Concept, and
Planning phases. It also delineates the requirements in terms of data, system
performance, security, and maintainability requirements for the system. The
requirements are defined in this phase to a level of detail sufficient for
systems design to proceed. They need to be measurable, testable, and relate
to the business need or opportunity identified in the Initiation Phase. The
requirements that will be used to determine acceptance of the system are
captured in the Test and Evaluation Master Plan.

The purposes of this phase are to:

➢ Further define and refine the functional and data requirements and
document them in the Requirements documents.

➢ Complete business process reengineering of the functions to be

supported (i.e., verify what information drives the business process,
what information is generated, who generates it, where does the
information go, and who processes it).

➢ Develop detailed data and process models (system inputs, outputs, and
the process).

➢ Develop the test and evaluation requirements that will be used to

determine acceptable system performance.

❖ DESIGN PHASE
The design phase involves converting the informational, functional, and
network requirements identified during the initiation and planning phases
into unified design specifications that developers use to script programs
during the development phase. Program designs are constructed in various
ways. Using a top-down approach, designers first identify and link major
program components and interfaces, then expand design layouts as they
identify and link smaller subsystems and connections. Using a bottom-up
approach, designers first identify and link minor program components and
interfaces, then expand design layouts as they identify and link larger
systems and connections.

Contemporary design techniques often use prototyping tools that build

mock-up designs of items such as application screens, database layouts, and
system architectures. End users, designers, developers, database managers,
and network administrators should review and refine the prototyped designs
in an iterative process until they agree on an acceptable design. Audit,
security, and quality assurance personnel should be involved in the review
and approval process. During this phase, the system is designed to satisfy the
functional requirements identified in the previous phase. Since problems in
the design phase could be very expensive to solve in the later stage of the
software development, a variety of elements are considered in the design to
mitigate risk.

These include:

➢ Identifying potential risks and defining mitigating design features.

➢ Performing a security risk assessment.

➢ Developing a conversion plan to migrate current data to new system.

➢ Determining the operating environment.

➢ Defining major subsystems and their inputs and outputs,

➢ Allocating processes to resources.

 ➢ Preparing detailed logic specifications for each software module. The result
is a draft System Design Document which captures the preliminary design
for the system.

➢ Everything requiring user input or approval is documented and reviewed by

the user. Once these documents have been approved by the Agency CIO and
Business Sponsor, the final System Design Document is created to serve as
the Critical/Detailed Design for the system.

➢ This document receives a rigorous review by Agency technical and functional

representatives to ensure that it satisfies the business requirements.
Concurrent with the development of the system design, the Agency Project
Manager begins development of the Implementation Plan, Operations and
Maintenance Manual, and the Training Plan.

❖ DEVELOPMENT PHASE
The development phase involves converting design specifications
into executable programs. Effective development standards include
requirements that programmers and other project participants
discuss design specifications before programming begins. The
procedures help ensure programmers clearly understand program
designs and functional requirements. Programmers use various
techniques to develop computer programs. The large transaction
oriented programs associated with financial institutions have
traditionally been developed using procedural programming
techniques. Procedural programming involves the line-by-line
scripting of logical instructions that are combined to form a
 program. Effective completion of the previous stages is a key factor
in the success of the Development phase.

The development phase consists of:

➢ Translating the detailed requirements and design into system

components.
➢ Testing individual elements (units) for usability.
➢ Preparing for integration and testing of it system.

❖ INTEGRATION AND TEST PHASE

Subsystem integration, system, security, and user acceptance testing
is conducted during the integration and test phase. The user, with
those responsible for quality assurance, validates that the functional
requirements, as defined in the functional requirements document,
are satisfied by the developed or modified system. OIT Security staff
assesses the system security and issue a security certification and
accreditation prior to installation/implementation.

❖ IMPLEMENTATION PHASE
This phase is initiated after the system has been tested and accepted
by the user. In this phase, the system is installed to support the
intended business functions. System performance is compared to
 performance objectives established during the planning phase.
Implementation includes user notification, user training, installation
of hardware, installation of software onto production computers,
and integration of the system into daily work processes. This phase
continues until the system is operating in production in accordance
with the defined user requirements.

❖ OPERATIONS AND MAINTENANCE PHASE

The system operation is on-going. The system is monitored for
continued performance in accordance with user requirements and
needed system modifications are incorporated. Operations continue
as long as the system can be effectively adapted to respond to the
organization’s needs. When modifications or changes are identified,
the system may re-enter the planning phase.

The purpose of this phase is to:

• Operate, maintain, and enhance the system.

• Certify that the system can process sensitive information.

• Conduct periodic assessments of the system to ensure the

functional requirements continue to be satisfied.
 REQUIREMENTS
✓ Operating system : Windows 10
✓ RAM : 4GB+
✓ Hard disk : 500+
✓ Python : version(3.9.11)
✓ Installed libraries : numpy ,pandas, matplotlib
Source code
# If the user enters 1 then the program will be directed to this admission menu

# We have various sub-options in our Admission-Menu – 1: Fill Admission Details

# 2: Show Admission Details

# 3: Search

# 4: Delete

# 5: Update Admission Details

# 6: Exit

# To store and retrieve our admission details we need a database so we used sql sub-module → sqlite3

Import sqlite3 as sql

Print()

Print()

Print()

Def ADM_MENU():
 While True:

Print(“\t----------------------------------------------------“)

Print(“\t\t\t\t\t\tWELCOME”)

Print(“\t\t\t\t\t\t To”)

Print(“\t\t\t\tSCHOOL MANAGEMENT SYSTEM”)

Print(“\t\t\t\t GNPS School – Admission Menu”)

Print(“\t----------------------------------------------------“)

Print(“\t\t\t\t\t1 : Fill Admission Details”)

Print(“\t\t\t\t\t2 : Show Admission Details”)

Print(“\t\t\t\t\t3 : Search”)

Print(“\t\t\t\t\t4 : Delete”)

Print(“\t\t\t\t\t5 : Update Admission Details”)

Print(“\t\t\t\t\t6 : Exit”)

Choice = int(input(“Enter Your Choice (1 – 6): “))

# Here we are establishing a connection with database named – school_mgmt

Connection = sql.connect(‘school_mgmt.db’)

# Here we created a cursor to make changes in our database by applying operations like insert,

select, delete etc.

Cursor = connection.cursor()

# Here we are creating a table(admission_details) with column names to store our data

Cursor.execute(“””CREATE TABLE IF NOT EXISTS admission_details(

Adm_no integer,

Roll_no integer,

Stu_name text,

Address text,

Phn_num integer)”””)

# Creating functions to implement the sub-categories of content entered by user

Def fill_details():

# Taking data as input from user to store into our database(school_mgmt)

Adm_no = int(input(“Enter Admission number: “))

Roll_no = int(input(“Enter Roll number: “))

Stu_name = input(“Enter Student Name: “)

Address = input(“Enter Address: “)

Phn_num = int(input(“Enter Phone number: “))

 # Inserting the values input from user into our table.

Cursor.execute(“INSERT INTO admission_details VALUES (:Adm_no, :Roll_no, :Stu_name,

:Address, :Phn_num)”,

{‘Adm_no’: adm_no, ‘Roll_no’: roll_no, ‘Stu_name’: stu_name, ‘Address’: address,

‘Phn_num’: phn_num})

# We need to close the database connection after performing tasks.

Connection.commit()

Connection.close()

# Selecting and showing values entered by used

Def show_details():

Cursor.execute(“SELECT * FROM admission_details”)

# Printing data into list format

Print(list(cursor.fetchall()))

Connection.commit()

Connection.close()

# To select, search and show a particular user’s data

Def search():

Stu_name = input(“Enter Student Name: “)

Cursor.execute(“SELECT * FROM admission_details WHERE Stu_name=?”, (stu_name,))

 # cursor.execute(“SELECT * FROM admission_details WHERE Stu_name= stu_name”)

Print(list(cursor.fetchone()))

Connection.commit()

Connection.close()

# To delete data

Def delete():

Roll_no = int(input(“Enter Roll number as your password: “))

Cursor.execute(“DELETE from admission_details WHERE Roll_no= roll_no”)

Print(“Data Successfully Deleted”)

Connection.commit()

Connection.close()

# To update data

Def update():

Roll_no = int(input(“Enter Roll number as your password: “))

Print(“Enter Updated Details:- “)

Adm_no = int(input(“Enter Admission number: “))

Stu_name = input(“Enter Student Name: “)

 Address = input(“Enter Address: “)

Phn_num = int(input(“Enter Phone number: “))

Cursor.execute(“UPDATE admission_details set Adm_no= adm_no where Roll_no= roll_no”)

Print(“Data Successfully Updated”)

Connection.commit()

Connection.close()

# Applied conditions and calling above created functions

If choice == 1:

Print(“Successfully Connected to Database”)

Fill_details()

Print(“Record Successfully Created”)

Break

Elif choice == 2:

Print(“Successfully Connected to Database”)

Print(show_details())
 Break

Elif choice == 3:

Print(“Successfully Connected to Database”)

Search()

Break

Elif choice == 4:

Print(“Successfully Connected to Database”)

Delete()

Break

Elif choice == 5:

Print(“Successfully Connected to Database”)

Update()

Break

# If user enters 6(exit) the code will be redirected to Main-Menu

Elif choice == 6:

Import main_menu
 Else:

Print(“Invalid Input!!”)

ADM_MENU()

# If the user enters 3 then the program will be directed to - fee menu
# We have various sub-options in our Fee-Menu - 1: Fee Deposit
# 2: Fee Details
# 3: Exit

# Here we need another database to store the fee details

import sqlite3 as sql

print()
print()
print()
def FEE_MENU():
while True:
print("\t----------------------------------------------------")
print("\t\t\t\t\t\tWELCOME")
print("\t\t\t\t\t\t To")
print("\t\t\t\tSCHOOL MANAGEMENT SYSTEM")
print("\t\t\t\t GNPS School - FEE DETAILS ")
print("\t----------------------------------------------------")
print("\t\t\t\t\t1 : Fee Deposit")
print("\t\t\t\t\t2 : Fee Details")
print("\t\t\t\t\t3 : Exit")
choice = int(input("Enter Your Choice (1 - 3): "))

# Connecting to our new database - school_mgmt_fee

connect = sql.connect('school_mgmt_fee.db')
cursor = connect.cursor()

# Created table into database - fee_details

cursor.execute("""CREATE TABLE IF NOT EXISTS fee_details(Roll_no integer,Stu_name
text,Fee_amount integer)""")

# Created functions to store and retrieve fee details

def fee_deposit():
roll_no = int(input("Enter your Roll Number: "))
stu_name= input("Enter Student Name: ")
fee_amount = int(input("Enter Fee Amount: "))
cursor.execute("INSERT INTO fee_details VALUES (:Roll_no, :Stu_name,
:Fee_amount)",{'Roll_no': roll_no, 'Stu_name' : stu_name, 'Fee_amount' :
fee_amount})
print("Fee Successfully Paid")
connect.commit()
connect.close()

def show_fee_details():
print()
print("Your Fee Details: ")
cursor.execute("SELECT * FROM fee_details")
print(list(cursor.fetchall()))
connect.commit()
connect.close()

# Applied conditions on user choice and called above created functions

if choice == 1:
print("Successfully Connected to Database")
fee_deposit()
break

if choice == 2:
print("Successfully Connected to Database")
show_fee_details()
break

if choice == 3:
import main_menu

else:
print("Invalid Input!!")

FEE_MENU()

# If the user enters 4 then the program will be directed to - library details
# We have various sub-options in our Library-Menu - 1: Book Issue
# 2: Book Return
# 3: Exit

def LIB_MENU():
print()
print()
print()
while True:
print("\t----------------------------------------------------")
print("\t\t\t\t\t\tWELCOME")
print("\t\t\t\t\t\t To")
print("\t\t\t\tSCHOOL MANAGEMENT SYSTEM")
print("\t\t\t\t GNPS School - LIBRARY DETAILS ")
print("\t----------------------------------------------------")
print("\t\t\t\t\t1 : Book Issue")
print("\t\t\t\t\t2 : Book Return")
print("\t\t\t\t\t3 : Exit")
choice = int(input("Enter Your Choice (1 - 3): "))

# Aplying condition on user choice

if choice == 1:
print("Fill Details: ")
roll_no = int(input("Enter Student Roll Number: "))
stu_name = input("Enter Student Name: ")
book_name = input("Enter Book Name: ")
# Formatted print statement in such a way we can show the user input in the
corresponding output, so we used variables(book_name, stu_name, roll_no)
in our print statement
print(book_name, "Book Successfully Issued by:", stu_name, "with Roll Number:",
roll_no)
break

if choice == 2:
book_name = input("Enter Book Name: ")
print(book_name, "Book Successfully Returned")
break

if choice == 3:
import main_menu

LIB_MENU()

# This is the Main-Menu (front page) of School App

# We have various contents in our Main-Menu - 1: Admission
# 2: Student Data
# 3: Fee Details
# 4: Library Details
# 5: Student Performance Chart
# To get further into these contents user need to enter the corresponding
number (eg - Press 1 for admission and so on.)

# Firstly, we defined a function to write our code more efficiently and get
# So, Let's create our Main_Menu - called if required in the entire project.

def MAIN_MENU():
# Here we are doing some formatting using print() to make our output more
attractive.
# The entire formatting is done inside a while loop to keep the Main Menu(Output)
continue until the user selects any option.
print()
print()
print()
while True:
print("\t----------------------------------------------------")
print("\t\t\t\t\t\tWELCOME")
print("\t\t\t\t\t\t To")
print("\t\t\t\tSCHOOL MANAGEMENT SYSTEM")
print("\t\t\t\t GNPS School - MAIN MENU")
print("\t----------------------------------------------------")
print("\t\t\t\t\t1 : Admission")
print("\t\t\t\t\t2 : Student Data")
print("\t\t\t\t\t3 : Fee Details")
print("\t\t\t\t\t4 : Library Details")
print("\t\t\t\t\t5 : Student Performance Chart")
# Taking input from user
choice = int(input("Enter Your Choice (1 - 5): "))

# Conditions Applied if the user enters any number

# Here we have imported self-created python modules (like - admission,
student_data.....) to get into the corresponding content.
if choice == 1:
import admission
break
elif choice == 2:
import student_data
break
elif choice == 3:
import fee_details
break
elif choice == 4:
import library_details
break

elif choice == 5:
import student_performance

# Finally we have called our function to execute it.

MAIN_MENU()
# If the user enters 2 then the program will be directed to – student data menu

# We have various sub-options in our Admission-Menu – 1: Fill Student Details

# 2: Show Student Details

# 3: Search

# 4: Delete

# 5: Update Student Details

# 6: Exit

# Here we need another database to store the student details

Import sqlite3 as sql

Print()

Print()

Print()

Def STU_MENU():

While True:

Print(“\t----------------------------------------------------“)

Print(“\t\t\t\t\t\tWELCOME”)

Print(“\t\t\t\t\t\t To”)

Print(“\t\t\t\tSCHOOL MANAGEMENT SYSTEM”)

Print(“\t\t\t\t GNPS School – Student Data”)

Print(“\t----------------------------------------------------“)

Print(“\t\t\t\t\t1 : Add Student Record”)

Print(“\t\t\t\t\t2 : Show Student Details”)

Print(“\t\t\t\t\t3 : Search”)

Print(“\t\t\t\t\t4 : Delete”)
Print(“\t\t\t\t\t5 : Update Student Details”)

Print(“\t\t\t\t\t6 : Exit”)

Choice = int(input(“Enter Your Choice (1 – 6): “))

# Here we are connecting to a new database – school_mgmt2

Connection = sql.connect(‘school_mgmt2.db’)

Cursor = connection.cursor()

# Created a new table into our database – student_details

Cursor.execute(“””CREATE TABLE IF NOT EXISTS student_details(

Roll_no integer,

Stu_name text,

Address text,

Std integer,

Stream text)”””)

# Below created functions to store, retrieve, delete, update student details

# Student Details input from user

Def fill_details():

Roll_no = int(input(“Enter Roll number: “))

 Stu_name = input(“Enter Student Name: “)

Address = input(“Enter your Address: “)

Std = int(input(“Enter Standard: “))

Stream = input(“Enter Stream: “)

# Inserting these details into student

Cursor.execute(“INSERT INTO student_details VALUES (:Roll_no, :Stu_name, :Address, :Std, :Stream)”,

{‘Roll_no’: roll_no, ‘Stu_name’: stu_name, ‘Address’:address, ‘Std’:std, ‘Stream’:stream})

Connection.commit()

Connection.close()

Def show_details():

Cursor.execute(“SELECT * FROM student_details”)

Print(list(cursor.fetchall()))

Connection.commit()

Connection.close()

Def search():
 Stu_name = input(“Enter Student Name: “)

Cursor.execute(“SELECT * FROM student_details WHERE Stu_name=?”, (stu_name,))

Print(list(cursor.fetchone()))

Connection.commit()

Connection.close()

Def delete():

Roll_no = int(input(“Enter Roll number as your password: “))

Cursor.execute(“DELETE from student_details WHERE Roll_no= roll_no”)

Print(“Data Successfully Deleted”)

Connection.commit()

Connection.close()

Def update():

Roll_no = int(input(“Enter Roll number as your password: “))

Print(“Enter Updated Details:- “)

Stu_name = input(“Enter Student Name: “)

Address = input(“Enter Address: “)

 Std = int(input(“Enter Standard: “))

Stream = input(“Enter Stream: “)

Cursor.execute(“UPDATE student_details set Stu_name= stu_name where Roll_no= roll_no”)

Print(“Data Successfully Updated”)

Connection.commit()

Connection.close()

# Applied conditions on user choice and called above functions

If choice == 1:

Print(“Successfully Connected to Database”)

Fill_details()

Print(“Record Successfully Created”)

Break

Elif choice == 2:

Print(“Successfully Connected to Database”)

Print(show_details())

Break
Elif choice == 3:

Print(“Successfully Connected to Database”)

Search()

Break

Elif choice == 4:

Print(“Successfully Connected to Database”)

Delete()

Break

Elif choice == 5:

Print(“Successfully Connected to Database”)

Update()

Break

Elif choice == 6:

Import main_menu

Else:
 Print(“Invalid Input!!”)

STU_MENU()

# If the user enters 5 then the program will be directed to – student performance chart
# To create array using mathematical operation we used numpy library as short name – np(just to make
it easy to remember)
Import numpy as np

# We need to show the array created by numpy as a chart(bar graph) so we used matplotlib as short
name – plt
Import matplotlib.pyplot as plt

# Here we created a time array to show our time gap between each term marks x-axis
Time = np.array([2, 4, 6, 8, 10])

# Taken input from user for total marks in each term to plot it on a bar graph on y-axis
Marks1 = int(input(“Enter First-Term Marks: “))
Marks2 = int(input(“Enter Second-Term Marks : “))
Marks3 = int(input(“Enter Third-Term Marks: “))
Marks4 = int(input(“Enter Fourth-Term Marks: “))
Marks5 = int(input(“Enter Fifth-Term Marks: “))

# converting the user inputs in an array to keep in a particular order and effectively plot on bar graph
Marks = [marks1, marks2, marks3, marks4, marks5]

# Here we created a bar graph based on time duration – student marks in each term
Bar = plt.bar(time, marks,color=[‘b’,’r’,’c’,’y’,’m’] label= “Student Performance Chart”)

# Here we defined labels on x-axis and y-axis to make it more clear to the user
Plt.xlabel(“Duration (In months)”)
Plt.ylabel(“Marks Obtained”)

# Legend() function is used to print the labels

Plt.legend()

# show() function is used to display the bar graph

Plt.show()
 OUTPUT
TO GET OUTPUT: PRESS F5
➢ Main menu:

➢ To fill admission details:

➢ To see the details of admission:

➢ To search the details:

➢ To delete the detail of student:

➢ To add the new data of the student:

➢ To add student details:

➢ To see the details:

➢ To search the details of a student:

➢ To delete the detail of a student:

➢ To add the detail of a student:

➢ To fill the fee details:

 ➢ To see the fee details:

➢ Library details:
Books issued and returned
➢ Student performance data:
CHART
 BIBLIOGRAPHY
o Informative practices (Sumita Arora)
o Informative practices with python (Preeti Arora)