INTRODUCTION

The real meaning of educational administration has undergone a radical

transformation in recent years, with an increasing reliance on
technology to streamline student management processes. The provided
Python script embodies a Student Management System that leverages
the capabilities of MySQL as the backend database. This system caters
to the diverse needs of administrators and users, offering
functionalities ranging from student details search to updates, views,
additions, and deletions.
Evolution of Student Management Systems
Traditionally, student management involved intricate manual
processes, making it susceptible to errors, delays, and
inefficiencies. The emergence of digital solutions has ushered in
an era of efficiency and accuracy, allowing educational
institutions to manage student data seamlessly. Our project
aligns with this evolution, providing an interactive and dynamic
Student Management System that caters to the specific
requirements of administrators and users alike.
Objectives of the Project
1. Administrative Empowerment
The primary objective of the Student Management
System is to empower administrators with tools that
facilitate efficient student data management. The system
encompasses key administrative functionalities,
including:

###Student Search
The `search_student()’ function allows administrators to
search for student details based on the student’s name.
This ensures quick access to comprehensive information,
such as admission number, name, gender, class, section,
phone number, email ID, and stream.

###Update Student Details

The `update_details()` function provides administrators
with a versatile interface to update various student
details, such as name, gender, class, section, phone
number, email ID, and stream. The system’s flexibility
ensures adaptability to changing student information.
###View Student Details
The `view_Marks()` function facilitates the display of
student details, with a particular focus on showcasing
student marks. This functionality caters to the academic
aspect of student management, allowing administrators
to assess and communicate student performance.

###Add Student
The `add_student()` function streamlines the process of
adding new students to the system, ensuring that vital
details are captured efficiently. This contributes to the
completeness and accuracy of the student database.

###Delete Student
The `delete_student()` function enables administrators to
remove student records from the system, providing a
mechanism for data clean up and management.
2. User-Friendly Interface
The project recognizes the importance of user experience for
both administrators and end-users. Two distinct panels, namely
the Admin Panel and the User Panel, cater to the unique needs
of these user groups.

####Admin Panel
The `admin()` function serves as the gate way to the Admin
Panel, offering a menu-driven interface for administrators to
access and utilize the various functionalities provided by the
system.

####User Panel
The `user()` function represents the User Panel, providing as
implified interface for end-users to search for their details, view
academic information, and exit the system.
##Key Code Function alities Integrated ### Search and Display
Operations #### Search Student
The `search_student()` function utilizes SQL queries to search for
student details based on the provided name, returning a detailed
display of relevant information.

####View Student Details

The `view_Marks()` function employs SQL queries to fetch and
display student details, with a specific focus on academic
performance.

###Update Operations
####Update Student Details
The `update_details()` function integrates user input and SQL
queries to selectively update student information, offering
granular control over the data modification process.
###Data Manipulation Operations

#### Add Student

The `add_student()` function combines user input and SQL
queries to insert new student records into the system, ensuring
data completeness.
####Delete Student
The `delete_student()` function utilizes SQL queries to delete
student records based on the provided name, contributing to
data management and cleanup.
###User and Admin Panels #### Admin Panel
The `admin()` function orchestrates the Admin Panel, providing
administrators with a menu-driven interface to navigate through
the system’s functionalities.
####User Panel
The `user()` function represents the User Panel, offering end-
users a simplified menu to search for their details, view academic
information, and exit the system.
##Integration of MySQL and Python
###MySQL–The Relational Database Management System
MySQL serves as the back end data base for the Student
Management System, storing and managing student-related
information. The structured schema ensures efficient to rage,
retrieval, and manipulation of data.
###Python–The Programming Language
Python, with its versatility and read ability, powers the logic and
user interface of the Student Management System. The script
employs Python’s database connectivity features to seamlessly
integrate with MySQL, providing a cohesive and interactive
experience for users and administrators.
##Significance of the Project

The significance of our Student Management System transcends

its technical intricacies. In an era where educational institutions
are grappling with vast
amounts of student data, a robust and user-friendly system is
indispensable. Our project addresses this need, offering a
solution that not only streamlines administrative tasks but also
enhances user experience and contributes to the overall
efficiency of student management processes.

In the subsequent sections of this project report, we will delve

into the detailed functionalities of the system, explore the
database schema, discuss the integration of Python and MySQL,
and shed light on the future enhancements and scalability of the
Student Management System. Through this comprehensive
exploration, we aim to show case not only the technical prowess
of the implemented solution but also the thoughtfulness
invested in creating a system that aligns seamlessly with the
evolving landscape of educational administration.
Python Source Code
import mysql.connector as con
print(“--------------------------------------------------------------- “)
#To search students from student
details
#table.
def search_student():
print(“*****************STUDENT
DETAILS***********************”)
K=input(“Enter name to search student Name:“)

D=con.connect(host=”localhost”,user=”root”,password=”a
dmin”,database=”STUDENT_MANAGEMENT_SYSTEM”)
C=d.cursor()
c.execute(“select*from STUDENT_DETAILS where NAME
like ‘%{}%’”.format(k))
a=c.fetchall() if len(a)>=1: for i in a:
print(“Admission no:”,i[0]) print(“Name is:”,i[1])
 print(“Sex:”,i[2])
print(“Class=”,i[3])
print(“Sec:”,i[4])
print(“Phone number is=”,i[5])
print(“Email_id:”,i[6])
print(“Stream is:”,i[7])
print(“-----------------------------------------------“)
else:
print(“Student Details Not Found”)

d.commit()

#To update details of students from student details table.

def update_details():

D=con.connect(host=”localhost”,user=”root”,passwor
d=”admin”,database=”STUDENT_MANAGEMENT_SYST
EM”)
C=d.cursor()

print(“1. Update Name”) print(“2. Update Gender”)

print(“3. Update class”) print(“4. Update Section”)
print(“5.UpdatePhoneno.”) print(“6. Update E-mail id”)
print(“7. Update Stream”)
Opt=int(input(“Enteryourchoicetoupdate”))

Ifopt==1:
print(“-----------------------------------------------“)
print(“Youareinsideupdatingname.”)
Q=input(“Enter ADMISSION_NUMBERwhose data
you want to update: “)
L=input(“Enteryourupdatedname:“)
 c.execute(“updateSTUDENT_DETAILSset NAME=’{}’
where
ADDMISSION_NUMBER={}”.format(l,q))
d.commit()

elif opt==2:
print(“-----------------------------------------------“)
print(“YouareinsideupdatingGender.”)
p=input(“Enternamewhosedatayouwantto update: “)
l=input(“EnteryourupdatedGender:“)
c.execute(“updateSTUDENT_DETAILSsetSEX=’{}’
where name=’{}’”.format(l,p))
d.commit()

elif opt==3:
print(“-----------------------------------------------“)
print(“Youareinsideupdatingclass.”)
 m=input(“Enternamewhosedatayouwantto update: “)
n=input(“Enter your updated class: “)
c.execute(“updateSTUDENT_DETAILSset
CLASS={}wherename=’{}’”.format(n,m))
d.commit()

elif opt==4:
print(“-----------------------------------------------“)
print(“Youareinsideupdatingsection.”)
y=input(“Enternamewhosedatayouwantto update: “)
e=input(“Enteryourupdatedsection:“)
c.execute(“updateSTUDENT_DETAILSsetSEC=’{}’
where name=’{}’”.format(e,y))
d.commit()

elif opt==5:
print(“-----------------------------------------------“)
print(“Youareinsideupdatingphonenumber.”)
 h=input(“Enternamewhosedatayouwantto update: “)
r=input(“Enteryourupdatedphonenumber:“)
c.execute(“update STUDENT_DETAILS set
PHONE_NUMBER={}wherename=’{}’”.format(r,h))
d.commit()

elif opt==6:
print(“-----------------------------------------------“)
print(“Youareinsideupdatingemail_id.”)
j=input(“Enternamewhosedatayouwantto update: “)
k=input(“Enteryourupdatedemail_id:“)
c.execute(“update STUDENT_DETAILS set
EMAIL_ID=’{}’wherename=’{}’”.format(k,j))
d.commit()

elif opt==7:
print(“-----------------------------------------------“)
print(“Youareinsideupdatingstream.”)
 f=input(“Enternamewhosedatayouwantto update: “)
z=input(“Enter your updated stream : “)
c.execute(“updateSTUDENT_DETAILSset
STREAM=’{}’whereNAME=’{}’”.format(z,f))
d.commit() else:
update_details()

#Todisplaythemarksofstudentsfrom student
details table .

defview_Marks():
print(“*******************VIEWSTUDENT
DETAILS******************”)
K=input(“Enternametoviewstudentdetails: “)

D=con.connect(host=”localhost”,user=”root”,passwor
d=”admin”,database=”student_management_system”
)
 C=d.cursor()
c.execute(“select*fromSTUDENT_DETAILSwhere NAME
like ‘%{}%’”.format(k))
s=c.fetchall() for i in s:
print(“MARKS:”,i[8])

print(“------------------------------------------------“)

d.commit()

#Toinsertdetailstostudentdetailstable

defadd_student():
print(“..................ADDSTUDENT
DETAILS......................”)

N=input(“Enterstudentname: “)
A=int(input(“Enterstudentadmissionnumber:“))
R=input(“Enter gender of student: “)
I=int(input(“Enterclassofstudent:”))
 P=input(“Enterstudentsection:“)
T=int(input(“Enterstudentphonenumber:”))
W=input(“Enter student stream: “)
U=input(“Enter your mail id:”)
M=int(input(“Enteryourmarks:”))

D=con.connect(host=”localhost”,user=”root”,passwor
d=”admin”,database=”STUDENT_MANAGEMENT_SYST
EM”)
C=d.cursor()
Sq=”insertintoSTUDENT_DETAILS
values({},’{}’,’{}’,{},’{}’,{},’{}’,’{}’,{})”.format(a,n,r,i,p,t,u,
w,m)
c.execute(sq) d.commit()
print(“studentdataaddedsuccessfully”)
#Todeleteitemsfromstudentdetailstable def
delete_student():
print(“********************DELETESTUDENT
DETAILS*******************”)
K=input(“EnternametoDELETEstudentdetails:“)
D=con.connect(host=”localhost”,user=”root”,passwor
d=”admin”,database=”STUDENT_MANAGEMENT_SYST
EM”)
C=d.cursor()
c.execute(“deletefromSTUDENT_DETAILSwhere
name=’{}’”.format(k))
print(“.........Datadeletedsuccessfully............”)
d.commit()

def admin(): whileTrue:

print(“***************WELCOMETOSTUDENT
MANAGEMENT *****************”)
print(“----------------------------------------------------------
-- -“)

print(“1.search student details”)

print(“2.updatestudentdetails”) print(“3.view student
details”)
print(“4.add student details”)
print(“5.deletestudentdetails”) print(“6.exit”)
ch=int(input(“yourchoice:“)) if ch==1:
search_student() elif ch==2:
update_details() elif ch==3:
view_Marks() elif ch==4:
add_student() elif ch==5:
delete_student() elif ch==6:
break else :
print(“invalidinput”)
def user(): whileTrue:
print(“***************WELCOMETOSTUDENT
MANAGEMENT **************”)
print(“1.searchyourDetails”) print(“2.view Details”)
print(“3.exit”)
ch=int(input(“whatisyourchoice:“)) if ch==1:
search() elifch==2:
view_Marks() elif ch==3:
break else:
print(“invalidinput”)

#Tosearchstudentsfromstudentdetails
table.
defsearch():
print(“*****************STUDENT
DETAILS***********************”)
K=input(“Enternametosearchstudentdetails:“)

D=con.connect(host=”localhost”,user=”root”,passwor
d=”admin”,database=”STUDENT_MANAGEMENT_SYST
EM”)
C=d.cursor()
c.execute(“select*fromSTUDENT_DETAILSwhere NAME
like ‘%{}%’”.format(k))
a=c.fetchall() if len(a)>=1: for i in a:
print(“Addmissionno:”,i[0]) print(“Name is:”,i[1])
print(“Sex:”,i[2])
print(“Class=”,i[3])
print(“Sec:”,i[4])
print(“Phonenumberis=”,i[5]) print(“Email_id:”,i[6])
 print(“Streamis:”,i[7])
print(“-----------------------------------------------“)
else:
print(“StudentDetailsNotFound”) d.commit()
#Todisplaythemarksofstudentsfrom student
details table .

defview_Marks():
print(“*******************VIEWSTUDENT
DETAILS******************”)
K=input(“Enternametoviewstudentdetails: “)

D=con.connect(host=”localhost”,user=”root”,passwor
d=”admin”,database=”student_management_system”
)
C=d.cursor()
c.execute(“select*fromSTUDENT_DETAILSwhere NAME
like ‘%{}%’”.format(k))
s=c.fetchall() for i in s:
 print(“MARKS:”,i[8])

print(“------------------------------------------------“)
d.commit()

whileTrue:
print(“**************WELCOMETOSTUDENT
MANAGEMENT*****************”)
print(“1.admin”)
print(“2.user”)
print(“3.exit”)
ch=int(input(“loginthrough:“)) if ch==1:
admin() elifch==2:
user() elifch==3:
break else:
print(“invalidinput”)
MySQLDATABASES
STUDENTMANAGEMENTSYSTEMDATABASEAND
STUDENT DETAILS TABLE:-

ADDSTUDENTFROMSTUDENT_DETAILSTABLE:
#Addedanewstudentinstudentdetailstablenamed
PRITI SHARMA
UpdatedStudentClassFromSTUDENT_DETAILSTable:

#updatedtheclassofstudentnameSALONIfromclass 12 to
class 11.

UpdatedStudentStreamFromSTUDENT_DETAILS
Table:

#updatedtheStreamofstudentnameSALONIfrom
SCIENCE to ARTS.
DELETESTUDENTFROMSTUDENT_DETAILSTABLE:

#DeletedtheDetailsofstudentnamePRITISHARMA
from STUDENT_ DETAILS TABLE.
OUTPUTS
#UserPanelandAdminPanel:

#searchStudentDetails:
#UpdatestudentDetails:
##Name:

##Gender:
##Class:

##Section:
##Stream:

#ViewMarkofstudent:
#AddstudentDetails:

#DeleteStudentDetails: