NAVY CHILDREN SCHOOL

KARWAR

COMPUTER SCIENCE PROJECT 2024-25

PROJECT TOPIC:
STUDENT MANAGEMENT SYSTEM

Submitted By:
Name: Aman Raj
Class: XII-A
CBSE Roll Number:

Under the Guidance of:

SMITHA RODRIGUES, PGT(CS)

0
 CERTIFICATE

This is to certify that AMAN RAJ, a student of Class XII-A,

Navy Children School Karwar, has successfully completed
the project titled “Student Management System“ under my
supervision.
The student has shown great interest, dedication, and
sincerity in the completion of this project.
I hereby certify that the project meets the expected
standards and adheres to the guidelines prescribed by the
Central Board of Secondary Education (CBSE), New Delhi.

Internal Examiner External Examiner

1
 ACKNOWLEDGMENT

I would like to express my heartfelt gratitude to Mrs. Smitha

Rodrigues, PGT (CS), whose dedication and expertise in
teaching Computer Science have deeply enriched my
understanding of the subject. Her guidance has been
instrumental in the completion of this project.
I am also immensely grateful to our Principal, Dr. Anjali
Singh, for her unwavering encouragement and support. Her
inspiration has been a driving force behind the success of
this project, and I am truly appreciative of her leadership.
Finally, I would like to extend my sincere appreciation to my
fellow students for their friendship and the memorable
moments we have shared throughout this journey. Their
camaraderie has made this experience even more rewarding.

1
HARDWARE/SOFTWARE/
MODULE REQUIRED

 HARDWAREs
 Desktop/Computer/Laptop
 Mobile Phone
 SOFTWAREs
 Python
 MySQL
 MODULEs
 mysql.connector (to connect MySQL to Python)
 bcrypt (For Authentication)
 pyfiglet (For ASCII Art)

1
 CONTENTS

S.No. Topic Page No.

1 CERTIFICATE 1
2 ACKNOWLEDGMENT 2
3 HARDWARE/SOFTWARE/MODULE REQUIRED 3
4 INTRODUCTION 5
5 FUNCTIONS LIST 12
6 PYTHON SOURCE CODE 15
7 MYSQL DATABASE 26
8 OUTPUT 30

2
 INTRODUCTION

Introduction to the Student Management System

In recent years, the concept of educational administration
has undergone a transformative shift, driven by technological
advancements that streamline student management
processes. This Python-based Student Management System
exemplifies this evolution by utilizing MySQL as its backend
database, enabling efficient management of student data. The
system is designed to meet the varied needs of
administrators and users, offering functions like student
detail search, updates, views, additions, and deletions.

Evolution of Student Management Systems

Historically, managing student data involved complex, manual
processes that were prone to errors, delays, and
inefficiencies. With the advent of digital solutions, educational
institutions have been able to enhance accuracy and
efficiency in their operations. This project is part of that
3
advancement, providing an interactive and robust Student
Management System tailored to support the specific
requirements of educational administrators and users.

Project Objectives
1. Administrative Empowerment
The primary goal of this Student Management System is to
empower administrators with tools for efficient student data
management.

2. User-Friendly Interface
The project prioritizes a user-friendly experience, offering
distinct interfaces for administrators and end-users.

3. Academic and Financial Tracking

Grades and Marks
The system allows detailed academic tracking with the
add_grade() and view_grades() functions. This supports
4
record-keeping for subjects, exams, and scores, enabling
informed decision-making.

Fee Management
The update_fee() function provides financial tracking to help
administrators manage fee records and ensure timely
payments.

Key Code Functionalities Integrated

1. Search and Display Operations
Search Student
The view_students() function uses SQL queries to search by
student name, retrieving and displaying relevant information.

2. Update Operations
Update Student Details
The update_student() function allows selective updating of
student information through user input and SQL, ensuring
controlled data modification.
5
3. Data Manipulation Operations
Add Student
The add_student() function integrates user input with SQL
queries to add new student records, ensuring the database
remains comprehensive.

Delete Student
The delete_student() function uses SQL to remove student
records by name, supporting data management.

4. Authentication & Main Menu

Authentication
The system uses a login() function to handle user login. It
validates credentials and grants role-based access, ensuring
that only authorized users can access specific features.

6
Default Admin Creation
The create_default_admin() function checks for an existing
admin in the system each time it runs. If no admin exists, it
creates a default admin account with predefined credentials
(e.g., username: admin, password: admin123). This ensures
there is always at least one admin available for access.

Main Menu Navigation

The main_menu() function serves as the primary navigation
hub. It adapts based on user roles, giving administrators
access to full system features while restricting standard
users to their assigned options.

Integration of MySQL and Python

MySQL – The Relational Database Management System
MySQL is used as the backend, providing a structured schema
for efficient storage, retrieval, and management of student
information.

7
Python – The Programming Language
Python powers the logic and interface, leveraging its
database connectivity to integrate seamlessly with MySQL,
creating a cohesive and interactive experience for users and
administrators.

Significance of the Project

The Significance of the Project section highlights the Student
Management System's critical role in modern educational
administration. This project addresses the growing need for
effective student data management in educational
institutions, aiming to reduce the challenges associated with
handling extensive student data. The system focuses on:

Efficiency and User Experience: The system optimizes

administrative tasks, offering an intuitive, user-friendly
interface. This approach enhances overall productivity for
staff and students, contributing to smoother operations and a
more streamlined workflow.

8
Technical Integration: Combining Python and MySQL, the
project leverages the strengths of these technologies to
create a robust and scalable solution. The database schema
ensures efficient data storage, retrieval, and manipulation,
while Python’s flexibility supports rapid feature updates and
interface improvements.

Future Scalability: Designed with growth in mind, the project

sets a foundation for future enhancements. This could include
expanding functionalities, such as advanced reporting,
analytics, and automated notifications, further aligning the
system with the evolving needs of educational administration.

9
 FUNCTIONS LIST
 ADMIN
Log into USER PANEL
Modify User
 Add User
 Delete User
 Update User
Display Users
Search Users
Modify Student Information
 Add Student
 Update Student
 Delete Student
 View Student Details
Manage Attendance
 Mark Attendance
 View Attendance
10
  Attendance Report
Manage Grades
 Add Grade
 View Grade
Manage Fees
 Update Fee Payment
 View Fee Details
Change Admin Credentials
Home
Back
Exit

 USER
Modify Student Information
 Add Student
 Update Student
 Delete Student
 View Student Details
11
Manage Attendance
 Mark Attendance
 View Attendance
 Attendance Report
Manage Grades
 Add Grade
 View Grade
Manage Fees
 Update Fee Payment
 View Fee Details
Change Admin Credentials
Home
Back
Exit

12
 PYTHON SOURCE
CODE
1 # Importing necessary libraries
2 import mysql.connector
3 import bcrypt
4 import pyfiglet
5
6 # Database connection setup
7 def create_connection():
8 return mysql.connector.connect(
9 host="localhost",
10 user="root",
11 password="Aman",
12 database="student_management",
13 auth_plugin='mysql_native_password'
14 )
15
16 # Function to execute SQL commands
17 def execute_query(query, params=None):
18 try:
19 conn = create_connection()
20 cursor = conn.cursor()
21 cursor.execute(query, params or ())
22 conn.commit()
23 cursor.close()
24 conn.close()
25 return True
26 except mysql.connector.Error as err:
27 print(f"Error: {err}")
28 return False
29
30 # Function to fetch results from SQL queries
31 def fetch_results(query, params=None):
32 try:
33 conn = create_connection()
34 cursor = conn.cursor()

13
35 cursor.execute(query, params or ())
36 results = cursor.fetchall()
37 cursor.close()
38 conn.close()
39 return results
40 except mysql.connector.Error as err:
41 print(f"Error: {err}")
42 return []
43
44 # Function to fetch a single result
45 def fetch_one(query, params=None):
46 try:
47 conn = create_connection()
48 cursor = conn.cursor()
49 cursor.execute(query, params or ())
50 result = cursor.fetchone()
51 cursor.close()
52 conn.close()
53 return result
54 except mysql.connector.Error as err:
55 print(f"Error: {err}")
56 return None
57
58 # Function to manage user-related tasks (modify users)
59 def modify_user():
60 while True:
61 print("\n--- User Management ---")
62 print("1. Register New User")
63 print("2. Update User")
64 print("3. Delete User")
65 print("4. View User Details")
66 print("5. View All Users") # New option to view all users
67 print("0. Go Back to Main Menu")
68
69 choice = input("Enter your choice: ")
70
71 if choice == '1':
72 register_user() # Call the function to register a new user
73 elif choice == '2':
74 update_user() # Call the function to update an existing user
75 elif choice == '3':
76 delete_user() # Call the function to delete a user
77 elif choice == '4':
78 view_user_details() # Call the function to view specific user details
79 elif choice == '5':
80 view_all_users() # Call the function to view all users
81 elif choice == '0':
82 break # Go back to the main menu
83 else:
84 print("Invalid choice. Please try again.")
85
86 # Register a new user with hashed password
87 def register_user():
88 username = input("Enter a username: ")
89 password = input("Enter a password: ")

2
90 role = input("Enter role (e.g., admin or user): ")
91
92 # Hash the password
93 hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
94
95 # Insert the user into the database
96 query = "INSERT INTO users (username, password_hash, role) VALUES (%s, %s, %s)"
97 if execute_query(query, (username, hashed_password, role)):
98 print("User registered successfully.")
99 else:
100 print("Failed to register user.")
101
102 def search_user():
103 # Only allow admin to search users
104 role = login()
105 if role != "admin":
106 print("Access denied. Only admins can search users.")
107 return
108
109 search_term = input("Enter username or role to search for: ")
110
111 # Search query that looks for partial matches in both username and role
columns
112 query = "SELECT user_id, username, role FROM users WHERE username LIKE %s
OR role LIKE %s"
113 results = fetch_results(query, (f"%{search_term}%", f"%{search_term}%"))
114
115 if results:
116 print("\n--- Search Results ---")
117 for user in results:
118 print(f"User ID: {user[0]}, Username: {user[1]}, Role:
{user[2]}")
119 else:
120 print("No users found matching the search term.")
121 # Update an existing user's details
122 def update_user():
123 user_id = int(input("Enter the User ID of the user to update: "))
124
125 # Fetch current user details to display
126 current_user = fetch_one("SELECT username, role FROM users WHERE user_id
= %s", (user_id,))
127 if not current_user:
128 print("User not found.")
129 return
130
131 print(f"Current Username: {current_user[0]}")
132 print(f"Current Role: {current_user[1]}")
133
134 # Prompt for new details (leave blank to keep the current value)
135 new_username = input("Enter new username (leave blank to keep current):
")
136 new_password = input("Enter new password (leave blank to keep current):
")
137 new_role = input("Enter new role (leave blank to keep current): ")
138

3
139 # Prepare update fields and values
140 updates = []
141 values = []
142
143 if new_username:
144 updates.append("username = %s")
145 values.append(new_username)
146
147 if new_password:
148 # Hash the new password before saving
149 hashed_password = bcrypt.hashpw(new_password.encode('utf-8'),
bcrypt.gensalt())
150 updates.append("password_hash = %s")
151 values.append(hashed_password)
152
153 if new_role:
154 updates.append("role = %s")
155 values.append(new_role)
156
157 if not updates:
158 print("No updates made.")
159 return
160
161 # Append user ID to values for WHERE clause
162 values.append(user_id)
163 update_query = f"UPDATE users SET {', '.join(updates)} WHERE user_id =
%s"
164
165 # Execute the update
166 if execute_query(update_query, tuple(values)):
167 print("User updated successfully.")
168 else:
169 print("Failed to update user.")
170
171 # View user details (Admin only)
172 def view_user_details():
173 # Only allow admin to view user details
174 role = login()
175 if role != "admin":
176 print("Access denied. Only admins can view user details.")
177 return
178
179 # Fetch all users' details
180 users = fetch_results("SELECT user_id, username, role FROM users")
181 if not users:
182 print("No users found.")
183 return
184
185 print("\n--- User Details ---")
186 for user in users:
187 print(f"User ID: {user[0]}, Username: {user[1]}, Role: {user[2]}")
188
189 def delete_user():
190 role = login()
191 if role != "admin":

4
192 print("Access denied. Only admins can delete users.")
193 return
194
195 user_id = int(input("Enter the User ID of the user to delete: "))
196
197 # Confirm deletion
198 confirm = input("Are you sure you want to delete this user? (yes/no): ")
199 if confirm.lower() == "yes":
200 if execute_query("DELETE FROM users WHERE user_id = %s", (user_id,)):
201 print("User deleted successfully.")
202 else:
203 print("Failed to delete user.")
204 else:
205 print("User deletion canceled.")
206
207 # Function to view all users
208 def view_all_users():
209 users = fetch_results("SELECT user_id, username, role FROM users")
210
211 if not users:
212 print("No users found.")
213 return
214
215 print("\n--- All Users ---")
216 for user in users:
217 print(f"User ID: {user[0]}, Username: {user[1]}, Role: {user[2]}")
218
219 # Login function with password verification
220 def login():
221 username = input("Enter username: ")
222 password = input("Enter password: ")
223
224 # Fetch the stored password hash for the username
225 query = "SELECT password_hash, role FROM users WHERE username = %s"
226 result = fetch_one(query, (username,))
227
228 if result:
229 stored_password_hash, role = result
230 # Verify the entered password with the stored hash
231 if bcrypt.checkpw(password.encode('utf-8'),
stored_password_hash.encode('utf-8')):
232 print(f"Login successful! Role: {role}")
233 return role # Return the role for further role-based access
234 else:
235 print("Invalid password.")
236 else:
237 print("Username not found.")
238
239 return None # Login failed
240
241 # Create a default admin user if no users exist
242 def create_default_admin():
243 if not fetch_one("SELECT * FROM users LIMIT 1"):
244 print("No users found. Creating default admin user...")
245 default_username = "admin"

5
246 default_password = "admin123"
247 role = "admin"
248
249 hashed_password = bcrypt.hashpw(default_password.encode('utf-8'),
bcrypt.gensalt())
250 query = "INSERT INTO users (username, password_hash, role) VALUES
(%s, %s, %s)"
251 if execute_query(query, (default_username, hashed_password, role)):
252 print("Default admin created with username 'admin' and password
'admin123'")
253 else:
254 print("Failed to create default admin.")
255
256 # Function to manage student-related tasks (add, update, delete, view
students)
257 def student_management():
258 while True:
259 print("\n--- Student Management ---")
260 print("1. Add Student")
261 print("2. Update Student")
262 print("3. Delete Student")
263 print("4. View Students")
264 print("0. Go Back to Main Menu")
265
266 choice = input("Enter your choice: ")
267
268 if choice == '1':
269 add_student() # Call the function to add a student
270 elif choice == '2':
271 update_student() # Call the function to update a student
272 elif choice == '3':
273 delete_student() # Call the function to delete a student
274 elif choice == '4':
275 view_students() # Call the function to view all students
276 elif choice == '0':
277 break # Go back to the main menu
278 else:
279 print("Invalid choice. Please try again.")
280
281 # Functions to manage students
282 def add_student():
283 name = input("Enter student name: ")
284 dob = input("Enter date of birth (YYYY-MM-DD): ")
285 contact = input("Enter contact number: ")
286 address = input("Enter address: ")
287 guardian_name = input("Enter guardian's name: ")
288
289 query = "INSERT INTO students (name, dob, contact, address,
guardian_name) VALUES (%s, %s, %s, %s, %s)"
290 if execute_query(query, (name, dob, contact, address, guardian_name)):
291 print("Student added successfully")
292
293 def view_students():
294 students = fetch_results("SELECT * FROM students")
295 for student in students:

6
296 print(student)
297
298 def update_student():
299 student_id = int(input("Enter student ID to update: "))
300 fields = ["name", "dob", "contact", "address", "guardian_name"]
301 updates, values = [], []
302 for field in fields:
303 new_value = input(f"Enter new {field} (leave blank to skip): ")
304 if new_value:
305 updates.append(f"{field} = %s")
306 values.append(new_value)
307 if updates:
308 values.append(student_id)
309 query = f"UPDATE students SET {', '.join(updates)} WHERE student_id =
%s"
310 if execute_query(query, tuple(values)):
311 print("Student updated successfully")
312 else:
313 print("No updates made")
314
315 def delete_student():
316 student_id = int(input("Enter student ID to delete: "))
317 if execute_query("DELETE FROM students WHERE student_id = %s",
(student_id,)):
318 print("Student deleted successfully")
319
320 # Function to manage attendance-related tasks (mark attendance, view
attendance)
321 def attendance_management():
322 while True:
323 print("\n--- Attendance Management ---")
324 print("1. Mark Attendance")
325 print("2. View Attendance")
326 print("3. Attendance Report")
327 print("0. Go Back to Main Menu")
328
329 choice = input("Enter your choice: ")
330
331 if choice == '1':
332 mark_attendance() # Call the function to mark attendance
333 elif choice == '2':
334 view_attendance() # Call the function to view attendance records
335 elif choice == '3':
336 attendance_report() # Call the function to generate an
attendance report
337 elif choice == '0':
338 break # Go back to the main menu
339 else:
340 print("Invalid choice. Please try again.")
341
342 # Functions to manage attendance
343 def mark_attendance():
344 student_id = int(input("Enter student ID: "))
345 date = input("Enter date (YYYY-MM-DD): ")
346 status = input("Enter status (present, absent, late): ")

7
347
348 query = "INSERT INTO attendance (student_id, date, status) VALUES (%s,
%s, %s)"
349 if execute_query(query, (student_id, date, status)):
350 print("Attendance marked")
351
352 def view_attendance():
353 attendance = fetch_results("SELECT * FROM attendance")
354 for record in attendance:
355 print(record)
356
357 def attendance_report():
358 report = fetch_results("""
359 SELECT student_id,
360 SUM(status = 'present') AS present_count,
361 SUM(status = 'absent') AS absent_count,
362 SUM(status = 'late') AS late_count
363 FROM attendance
364 GROUP BY student_id
365 """)
366 for row in report:
367 print(f"Student ID: {row[0]}, Present: {row[1]}, Absent: {row[2]},
Late: {row[3]}")
368
369 # Function to manage grade-related tasks (add, view grades)
370 def grade_management():
371 while True:
372 print("\n--- Grade Management ---")
373 print("1. Add Grade")
374 print("2. View Grades")
375 print("0. Go Back to Main Menu")
376
377 choice = input("Enter your choice: ")
378
379 if choice == '1':
380 add_grade() # Call the function to add a grade
381 elif choice == '2':
382 view_grades() # Call the function to view grades
383 elif choice == '0':
384 break # Go back to the main menu
385 else:
386 print("Invalid choice. Please try again.")
387
388 # Functions to manage grades
389 def add_grade():
390 student_id = int(input("Enter student ID: "))
391 subject = input("Enter subject: ")
392 exam_name = input("Enter exam name: ")
393 grade = input("Enter grade: ")
394
395 query = "INSERT INTO grades (student_id, subject, exam_name, grade)
VALUES (%s, %s, %s, %s)"
396 if execute_query(query, (student_id, subject, exam_name, grade)):
397 print("Grade added")
398

8
399 def view_grades():
400 student_id = int(input("Enter student ID: "))
401 grades = fetch_results("SELECT * FROM grades WHERE student_id = %s",
(student_id,))
402 for grade in grades:
403 print(grade)
404
405 # Function to manage fee-related tasks (update fees, view fees)
406 def fee_management():
407 while True:
408 print("\n--- Fee Management ---")
409 print("1. Add Fee") # New option to add fee
410 print("2. Update Fee Payment")
411 print("3. View Fees")
412 print("0. Go Back to Main Menu")
413
414 choice = input("Enter your choice: ")
415
416 if choice == '1':
417 add_fee() # Call the function to add a new fee record
418 elif choice == '2':
419 update_fee() # Call the function to update a fee payment
420 elif choice == '3':
421 view_fees() # Call the function to view fee details
422 elif choice == '0':
423 break # Go back to the main menu
424 else:
425 print("Invalid choice. Please try again.")
426
427 # Functions to manage fees
428
429 def add_fee():
430 student_id = int(input("Enter student ID: "))
431 amount_paid = float(input("Enter amount paid: "))
432 payment_date = input("Enter payment date (YYYY-MM-DD): ")
433
434 # Check if the student already has a fee record
435 existing_fee = fetch_one("SELECT * FROM fees WHERE student_id = %s",
(student_id,))
436
437 if existing_fee is not None:
438 print("A fee record for this student already exists. Use 'update_fee'
to modify the existing record.")
439 else:
440 # Insert new fee record
441 query = "INSERT INTO fees (student_id, amount_paid, payment_date)
VALUES (%s, %s, %s)"
442 if execute_query(query, (student_id, amount_paid, payment_date)):
443 print("Fee record added successfully.")
444 else:
445 print("Failed to add fee record.")
446
447 def update_fee():
448 student_id = int(input("Enter student ID: "))
449 amount_paid = float(input("Enter amount paid: "))

9
450 payment_date = input("Enter payment date (YYYY-MM-DD): ")
451
452 # Check if the student exists in the fees table
453 existing_fee = fetch_one("SELECT amount_paid FROM fees WHERE student_id =
%s", (student_id,))
454
455 if existing_fee is None:
456 print("Student ID not found in the fees records. Adding a new entry
for the student.")
457 # If student fee record does not exist, create a new one
458 query = "INSERT INTO fees (student_id, amount_paid, payment_date)
VALUES (%s, %s, %s)"
459 if execute_query(query, (student_id, amount_paid, payment_date)):
460 print("New fee record created and payment updated.")
461 else:
462 print("Failed to create fee record.")
463 else:
464 # Update the existing fee record
465 query = "UPDATE fees SET amount_paid = amount_paid + %s, payment_date
= %s WHERE student_id = %s"
466 if execute_query(query, (amount_paid, payment_date, student_id)):
467 print("Fee payment updated successfully.")
468 else:
469 print("Failed to update fee payment.")
470
471 def view_fees():
472 student_id = int(input("Enter student ID: "))
473 fees = fetch_results("SELECT * FROM fees WHERE student_id = %s",
(student_id,))
474 for fee in fees:
475 print(fee)
476
477 # Function to go back to the main menu
478 def go_to_home():
479 print("\nReturning to the main menu...")
480 main_menu() # Call the main_menu function to return to the home screen
481
482 # Main menu function
483 def main_menu():
484 create_default_admin()
485 print("\031[1;33m"+ pyfiglet.figlet_format("Welcome to the”,
font=”banner3”,width=1000))
486 Print(pyfiglet.figlet_format("Student Management System”,
font=”banner3”,width=200)+ "\033[0;0m")
487
488
489 role = login()
490 if not role:
491 print("Access denied.")
492 return
493
494 while True:
495 print("\n--- Main Menu ---")
496 print("1. Student Management")
497 print("2. Grade Management")

10
498 print("3. Fee Management")
499 print("4. Attendance Management")
500 print("5. User Management")
501 print("6. Go to Home")
502 print("0. Exit")
503
504 choice = input("Enter your choice: ")
505 menu_options = {
506 '1': student_management, # Manage student information
507 '2': grade_management, # Manage grade information
508 '3': fee_management, # Manage fee information
509 '4': attendance_management, # Manage attendance
510 '5': modify_user, # Manage user details
511 '6': go_to_home, # Go to home (for restarting the process)
512 }
513
514 if choice == '0':
515 print("Exiting program. Goodbye!")
516 break
517 elif choice in menu_options:
518 menu_options[choice]() # Call the respective function based on
the user's choice
519 else:
520 print("Invalid choice. Please try again.")
521
522 # Run the main menu
523 if __name__ == "__main__":
524 main_menu()

11
 MYSQL DATABASE
Student Management Database:

Students Table:

12
Fees Table:

Attendance Table:

2
Grade Table:

Users Table:
3
4
OUTPUT

5
Starting of The Program:

Admin Authentication: Adding New User:

View & Update User:

6
Adding New Student: Adding Grade:

Viewing Student Details:

Deleting Student: Adding Attendance:

2
Exiting the Program:

REFERENCES
 Python
 https://www.python.org/
 MySQL
 https://www.mysql.com/
 ANSI Escape Codes in Python
 https://pypi.org/project/ansi/
 https://replit.com/talk/learn/ANSI-Escape-Codes-
inPython/22803
 https://gist.github.com/rened/9e584a7dd2935d0f461904b9f
2950007
 Class 11th & 12th Computer Science Sumita Arora Books