Sl. No. CONTENT Page No.

1. Aim 1

2. Introduction 2

3. Objectives 3

4. Scope of the Project 4

5. Program Description 5

6. Source Code 6-9

7. Sample Output 10 - 11

8. Tools & Technologies Used 12 - 13

9. Bibliography 14

10. Conclusion 15
 1
AIM

The aim of this project, titled Student Grade Management System, is to design and
implement a Python-based program capable of efficiently managing academic
records of students through a simple, organized, and systematic approach. The
primary objective is to develop a functional system that demonstrates how student
information—consisting of roll numbers, names, and marks—can be stored,
retrieved, updated, deleted, and saved using fundamental programming concepts.
By creating a menu-driven structure supported by user-defined functions, the
program aims to simplify the handling of multiple records while highlighting the
importance of modularity, data organization, and structured workflow in software
development.
This project aims to provide hands-on experience in managing real-life data
through Python’s dictionary data structure, where student details are stored using
roll numbers as unique identifiers. The system seeks to demonstrate how such a
structure enables efficient access to information while preventing duplication of
records. Through operations such as adding new students, updating existing details,
and deleting selected entries, the project emphasizes the role of CRUD operations
—Create, Read, Update, Delete—which form the foundation of most database
applications.
Another aim of the project is to introduce file handling as a means of achieving
data persistence. After all necessary operations are performed during runtime, the
final data is saved into an external text file, ensuring that the updated information
remains accessible even after the program stops executing. This inclusion reflects
how software applications store long-term records.
Lastly, the project aims to present a clear workflow that students can understand
and replicate, beginning with predefined entries, moving through controlled
modifications, and concluding with the generation of a final output file. Overall,
the aim is to create a practical, easy-to-understand system that demonstrates how
Python can be used to build efficient academic management tools while helping
learners grasp essential programming concepts.
 2

INTRODUCTION

The Student Grade Management System is a Python-based project designed to

demonstrate efficient methods for managing academic data in a structured and
organized manner. In educational settings, maintaining student records is essential
for evaluating performance and ensuring administrative accuracy. This project
provides a simplified representation of how such information can be processed
using Python’s core features, enabling students to understand how data is stored,
accessed, modified, and preserved in practical applications.

The project relies on a dictionary data structure to store student records, where
each student is represented by a roll number, name, and marks. The roll number
serves as a unique identifier, ensuring that each entry remains distinct and can be
accessed directly. This approach reflects real-world database systems where unique
identifiers prevent data duplication and support efficient retrieval.

Modular programming is another key aspect introduced through this project.

Operations such as adding new students, updating existing records, deleting
entries, and displaying the complete list are each implemented as separate user-
defined functions. This division enhances clarity, readability, and organization
while demonstrating how larger applications can be built from smaller functional
units. The modular approach also makes the program easier to maintain and
upgrade in the future.

A significant component of the project Is the implementation of file handling.

After performing all operations, the program saves the final student records into a
text file. This demonstrates how data can be stored permanently, emphasizing the
necessity of backups and the role of external files in preserving important
information. It also mirrors real administrative systems where student data remains
accessible across multiple sessions.

The entire workflow beginning with seven predefined students, followed by a

series of additions, updates, deletions, and final display helps students understand
the sequential nature of data processing. By performing each operation step-by-
step, the project illustrates how changes affect the dataset as a whole. The Student
Grade Management System provides a clear and practical understanding of how
Python can be utilized to create academic data management tools, introducing
essential programming concepts.

OBJECTIVES

1. To store student records in an organized data structure.

2. To implement CRUD operations using Python functions.

3. To understand and apply dictionary-based data storage.

4. To add new student entries into the system.

5. To update existing student information accurately.

6. To delete specific student records when required.

7. To display all student data in a clear and readable format.

8. To practice modular programming through the use of functions.

 9. To learn file handling techniques to save final records.

[Link] apply programming logic to a real-world academic task.

SCOPE OF THE PROJECT

The scope of the Student Grade Management System includes several essential
components that collectively demonstrate how Python can be applied to manage
academic data in a structured and efficient manner. Although the program is small
in scale, it closely reflects real-world practices used in educational institutions for
maintaining student records and serves as a foundational model for more complex
systems.

A primary element within the scope Is the use of a dictionary to organize student
details using unique roll numbers. Each record consists of the student’s name and
marks, allowing quick access, reliable updates, and efficient deletion. This reflects
the basic principles of database management, where unique identifiers help
maintain accuracy and avoid duplication. The structure provides students with
practical experience in handling organized and easily retrievable data.

Another important part of the project’s scope is modular programming. The

program uses separate functions for adding students, updating records, deleting
entries, and displaying all data. This division of tasks into smaller, manageable
blocks helps improve readability and maintainability. It also introduces students to
modularity, which is a vital programming technique used in large software
applications.

The project also includes file handling, which extends its scope beyond temporary
memory storage. After completing all operations, the final student data is written
into a text file. This demonstrates how information can be saved permanently—an
essential requirement in real academic or administrative systems. The use of file
handling provides insight into real-world data storage methods and prepares
students for future work involving databases or external files.
The sequential workflow—starting with initial data, followed by additions,
updates, deletions, and final display shows how tasks are performed in a structured
and logical manner. This helps learners understand how systems process data step-
by-step. Overall, the scope of the project covers data storage, retrieval,
modification, deletion, modular programming, file handling, and structured
workflow. It provides a strong foundation for understanding how student
information systems work and offers opportunities for enhancement, such as
adding search features, calculating averages, or integrating graphical interfaces.

PROGRAM DESCRIPTION

The Student Grade Management System is a Python program designed to handle

basic academic data operations in a structured and efficient manner. The program
begins by storing details of seven initial students in a dictionary, where each
student’s roll number functions as a unique key, and the corresponding value
contains the student’s name and marks. This structure allows the program to
manage data quickly and helps maintain organized and non-duplicated records.

The system Is divided into multiple user-defined functions, each responsible for a
specific task. The fetch_students() function is used to display all stored student
records in a clear and readable format. The add_student() function enables the
addition of new student entries into the dictionary. Before adding a new record, the
function checks whether the roll number already exists, ensuring that no duplicate
entries are created. The delete_student() function removes an existing student
record using the roll number as the reference point, while the update_student()
function allows modifying the name and marks of any existing student.

The main workflow of the program follows a structured sequence of operations.

First, the initial seven records are displayed to establish the starting dataset.
Following this, five new students are added to the system using the add function.
The program then performs seven update operations, modifying selected student
names and marks to reflect changes in the record. After updating, the system
deletes five students based on the provided roll numbers. These deletions showcase
how records can be removed cleanly and efficiently when they are no longer
required.
Once all operations are completed, the program displays the remaining student
records, showing the final dataset after additions, updates, and deletions. Finally,
the system saves the complete list of remaining students into an external text file
named student_data.txt. This demonstrates the use of file handling in Python,
allowing the project to store data permanently beyond program execution.

Overall, the program presents a clear, functional, and educational demonstration of

data storage, modification, deletion, display, and file handling in Python. It reflects
real-world school record management processes using simple yet effective
programming techniques.

6
SOURCE CODE

# -------------------------------
# Student Grade Management System
# -------------------------------

# Initial 7 students
Students = {
101: [“Aarav”, 88],
102: [“Neha”, 92],
103: [“Rahul”, 75],
104: [“Sara”, 81],
105: [“Karan”, 69],
106: [“Priya”, 95],
107: [“Vikram”, 78]
}
# ------- FUNCTION TO DISPLAY -------
Def fetch_students():
Print(“\n----- Student Records -----“)
For roll, data in [Link]():
Print(f”Roll No: {roll}, Name: {data[0]}, Marks: {data[1]}”)
Print(“----------------------------\n”)

7
# ------- FUNCTION TO ADD -------
Def add_student(roll, name, marks):
If roll in students:
Print(f”Roll No {roll} already exists!”)
Else:
Students[roll] = [name, marks]
Print(f”Student {name} added successfully.”)

# ------- FUNCTION TO DELETE -------

Def delete_student(roll):
If roll in students:
Removed = [Link](roll)
Print(f”Student {removed[0]} deleted successfully.”)
Else:
Print(“Roll number not found!”)
# ------- FUNCTION TO UPDATE -------
Def update_student(roll, new_name, new_marks):
If roll in students:
Students[roll] = [new_name, new_marks]
Print(f”Student with Roll {roll} updated successfully.”)
Else:
8
Print(“Roll number not found!”)

# ------- MAIN WORKFLOW -------

Print(“Initial 7 Students:”)
Fetch_students()

Print(“Adding 5 New Students…”)

Add_student(108, “Meera”, 91)
Add_student(109, “Sahil”, 82)
Add_student(110, “Ishita”, 87)
Add_student(111, “Manoj”, 73)
Add_student(112, “Deepak”, 90)

Print(“\nUpdating 7 Students…”)
Update_student(101, “Aarav Singh”, 90)
Update_student(103, “Rahul Sharma”, 78)
Update_student(105, “Karan Patel”, 72)
Update_student(108, “Meera Devi”, 93)
Update_student(109, “Sahil Khan”, 85)
Update_student(110, “Ishita Verma”, 89)
Update_student(111, “Manoj Kumar”, 76)

Print(“\nDeleting 5 Students…”)
9
Delete_student(102)
Delete_student(104)
Delete_student(106)
Delete_student(112)
Delete_student(109)

Print(“\nRemaining Students After All Operations:”)

Fetch_students()

# ------- SAVE TO FILE -------

File = open(“student_data.txt”, “w”)
[Link](“Final Student Records:\n”)
For roll, data in [Link]():
[Link](f”Roll: {roll}, Name: {data[0]}, Marks: {data[1]}\n”)
[Link]()

Print(“File saved successfully as ‘student_data.txt’.”)

10
SAMPLE OUTPUT

Initial 7 Students:
----- Student Records -----
Roll No: 101, Name: Aarav, Marks: 88
Roll No: 102, Name: Neha, Marks: 92
Roll No: 103, Name: Rahul, Marks: 75
Roll No: 104, Name: Sara, Marks: 81
Roll No: 105, Name: Karan, Marks: 69
Roll No: 106, Name: Priya, Marks: 95
Roll No: 107, Name: Vikram, Marks: 78
Adding 5 New Students…
Student Meera added successfully.
Student Sahil added successfully.
Student Ishita added successfully.
Student Manoj added successfully.
Student Deepak added successfully.

Updating 7 Students…
Student with Roll 101 updated successfully.
Student with Roll 103 updated successfully.
Student with Roll 105 updated successfully.
11
Student with Roll 108 updated successfully.
Student with Roll 109 updated successfully.
Student with Roll 110 updated successfully.
Student with Roll 111 updated successfully.

Deleting 5 Students…
Student Neha deleted successfully.
Student Sara deleted successfully.
Student Priya deleted successfully.
Student Deepak deleted successfully.
Student Sahil Khan deleted successfully.
Remaining Students After All Operations:
----- Student Records -----
Roll No: 101, Name: Aarav Singh, Marks: 90
Roll No: 103, Name: Rahul Sharma, Marks: 78
Roll No: 105, Name: Karan Patel, Marks: 72
Roll No: 107, Name: Vikram, Marks: 78
Roll No: 108, Name: Meera Devi, Marks: 93
Roll No: 110, Name: Ishita Verma, Marks: 89
Roll No: 111, Name: Manoj Kumar, Marks: 76

File saved successfully as ‘student_data.txt’.

12
TOOLS AND TECHNOLOGY USED

1. Python Programming Language

The entire Student Grade Management System is developed using Python, chosen
for its simplicity, readability, and strong support for data handling. Python’s built-
in data structures, especially dictionaries, make storing and modifying student
records easy and efficient.

2. Spyder App (Python IDE)

The program can be written and executed using the Spyder IDE, which is
commonly used in Python development. Spyder provides features like an editor,
console, debugging tools, and variable explorer, making it easy to write, test, and
view program output efficiently.
 3. Dictionaries (Python Data Structure)
The project uses dictionaries to store student information with roll numbers as
unique keys. This structure supports fast retrieval and smooth updating or deletion
of data, making it suitable for real-time data management.

4. Functions (User-Defined Functions)

The system uses modular programming with separate functions such as
add_student(), delete_student(), update_student(), and fetch_students(). This
improves clarity, structure, and maintainability of the code.

5. Loops and Conditional Statements

The project uses fundamental programming structures like for loops and if-else
statements to navigate through the dictionary, check conditions, and control the
flow of operations.
13
6. File Handling (Text File Storage)
The final student data is saved into a text file using Python’s file handling
functions (open(), write(), and close()). This ensures permanent storage and
demonstrates how data can be preserved after program execution.

7. Terminal/Command Line Output

All program interactions—such as adding, updating, deleting, and displaying
student details—appear in the terminal output, making it easy to observe how the
database changes after each operation.
 14
BIBLIOGRAPHY

The following are the links and textbook practical and theoretically used for the
completion of the project:
1. Python Documentation. Functions, File Handling, and Dictionaries. Python
Software Foundation.
Retrieved from: [Link]

2. W3Schools. Python Programming Basics, Functions, and File Operations.

 Retrieved from: [Link]

3. GeeksforGeeks. Python Dictionary and User-Defined Functions Tutorials.

Retrieved from: [Link]

4. Programiz. Python File Handling and Data Structures (Dictionary).

Retrieved from: [Link]
5. Class 12 Computer Science (Python) Textbook — Referred for
understanding the basic syntax, program structure, and logic used in
developing the Student Grade Management System.

15
CONCLUSION

The Student Grade Management System project effectively demonstrates the

application of core programming concepts such as functions, data structures, user
input handling, and file operations in Python. By implementing features to add,
update, delete, and display student records, the project provides a practical solution
for managing student information in an organized and efficient manner. Each
operation is encapsulated in a separate function, which enhances code readability,
simplifies debugging, and allows for easy future modifications or expansions.
Starting with seven initial student records, the system ensures that all
functionalities can be thoroughly tested. The sample outputs show that the system
handles user inputs accurately, updates records dynamically, and maintains data
integrity during deletion and modification processes. The display function
organizes the student data in a clear tabular format, improving the overall user
experience and demonstrating the importance of presenting information in a
structured and accessible way.
A key feature of the system is its ability to store data persistently using file
handling. This ensures that all records are saved and can be retrieved even after the
program is closed, highlighting an understanding of real-world data management
requirements. The sample outputs confirm that the system successfully reads from
and writes to the file, keeping records consistent and reliable.
Overall, the project showcases the integration of structured programming, user
interaction, and data management to solve a practical problem. It reinforces
important concepts such as modularity, error handling, and persistent storage,
which are essential skills in software development. Completing this project
provides valuable experience in designing a functional and interactive system,
preparing the programmer for more advanced applications in academic or
professional environments. The Student Grade Management System serves as a
strong foundation for future projects and demonstrates the ability to develop
efficient, user-friendly, and reliable software solutions.