From Data Science Fundamentals to Real-World Applications: Managing Student Data with Python

Author:

Garnet Ezra

Date:

26 September 2024

Course/Program:

Digital Talent Incubator-Data Scientist

Institution:

Purwadhika Digital Technology School

Instructor:

ilham candra

Project:

Capstone Project Pototofolio Module 1

Introduction

In this era, data science has become a great tool in different levels of business fields, assisting in making sound decisions, automating tedious work, and creating significant insight from many datasets. Python, one of the most common programming languages, has an impactful role in this journey.

While learning Data Science, my project was to build a student management system for a tutoring service as my capstone project. This automation system handles administrative tasks such as student registration, attendance recording, and invoice generation. This article will show how basic data science and Python programming knowledge can be applied to solve real-world problems.  

1. Foundations in Data Science and Python Programming

Data Science Overview

"Data science is a field of applied mathematics and statistics that provides valuable information based on large amounts of complex data or big data.

Data science, or data-driven science, combines aspects of different fields with the aid of computation to interpret reams of data for decision-making purposes." (Banton)

However, data science has challenges, like cleaning raw data, scaling algorithms, and understanding the real-world data context. Learning essential tools and programming languages like Python is necessary to solve this.

Key Topics Learned

Throughout the program, I explored various Python concepts and tools that are crucial in data science:

Python Programming Basics: I learned about variables, data types (strings, integers, floats), and control flow structures (loops and conditional statements).

Collections in Python: Working with lists, dictionaries, sets, and tuples to allow efficient storage and manipulation of data.

Functions and Modularity: Writing reusable code blocks through functions was essential for building structured, maintainable programs.

Handling User Input and Error Control: Learning how to handle inputs robustly and prevent crashes through error handling (`try-except` statements).

These foundational concepts helped me build a practical, real-world application for managing a tutoring service, which this article will explain later.

2. Capstone Project Overview

Objective

My capstone project aimed to create a Python-based system to manage students' data for my private tutoring service, including student registration, tracking attendance, and generating invoices based on student attendance. The system allows the tutor to:

a.      Add students and their details (sessions, rates, and grades).

b.     Record attendance.

c.      Calculate and generate invoices based on the number of sessions attended.

Certainly! Here’s a revised version of the section with detailed explanations of the CRUD operations and added comments in the code to make the functions easier to understand:

3. Project Structure and Code Breakdown

This student data management system is built based on CRUD (Create, Read, Update, Delete) operations. These operations allow the tutor to manage student information effectively, including registering new students, updating their attendance, and generating invoices.

Data Storage: Nested Dictionary

At the heart of the system is a nested dictionary that stores all student data. Each student is represented by a unique key (ID) in the dictionary, with their information (such as name, rate per session, total sessions, grade, and attendance) stored as values.

Example:

Python

# A dictionary storing multiple student records.

students_info = {

    1: {"Name": "Adit", "Rate": 30000, "Sessions": 4, "Grade": 4, "Attendance": 2},

    2: {"Name": "Akmal", "Rate": 75000, "Sessions": 12, "Grade": 5, "Attendance": 6},

}

```

Explanation: In this structure, each student is assigned a unique identifier (`1` for Adit, 2 for Akmal). Each student has a dictionary of attributes including name, rate, sessions, grade, and attendance.

Purpose: This setup allows easy retrieval and manipulation of student data during operations like registration, attendance tracking, and invoice generation.

CRUD Operations Using Functions

1. Create (C) – Adding a New Student

This function handles the creation of a new student. It asks for details such as the student's name, rate per session, total sessions, and grade. These details are then added to the students_info dictionary with a unique ID.

Python

   # Function to add a new student

   def add_student():

       student_id = len(students_info) + 1  # Generate a new student ID

       name = input("Enter student's name: ")

       rate = limited_input("Enter rate per session (integer): ", int)  # Input with validation

       sessions = limited_input("Enter number of sessions: ", int)

       grade = limited_input("Enter student's grade: ", int)

       # Add the new student to the dictionary

       students_info[student_id] = {

           "Name": name,

           "Rate": rate,

           "Sessions": sessions,

           "Grade": grade,

           "Attendance": 0  # New students start with 0 attendance

       }

       print(f"Student {name} added successfully.")

   ```

Purpose: Adds a new student’s information to the system by creating an entry in the dictionary.

Notes: limited_input() is used to ensure the correct input type (e.g., integer for the rate and sessions).

2. Read (R) – Displaying Student Information

This function allows the tutor to read and display student details. It formats and prints the stored data in a tabular format, showing all students currently registered in the system.

Python

   # Function to display all students in a table format

   def display_students():

       # Print header row

       print(f"{'ID':<5}{'Name':<15}{'Rate':<10}{'Sessions':<10}{'Grade':<10}{'Attendance':<10}")

       # Loop through the dictionary and print each student's details

       for student_id, student in students_info.items():

           print(f"{student_id:<5}{student['Name']:<15}{student['Rate']:<10}{student['Sessions']:<10}{student['Grade']:<10}{student['Attendance']:<10}")

   ```

Purpose: Presents the list of students, along with their rate, total sessions, grade, and attendance in a structured way.

Notes: The dictionary’s key-value pairs are iterated over using a for loop to display each student's information.

3. Update (U) – Recording Attendance

This function allows the tutor to update a student's attendance. It checks if the student has remaining sessions and, if so, increments the attendance count by one.

Python

   # Function to record attendance for a student

   def record_attendance(student_id):

       # Check if the student ID exists in the system

       if student_id in students_info:

           student = students_info[student_id]

           # Check if the student has any remaining sessions

           if student['Attendance'] < student['Sessions']:

               student['Attendance'] += 1  # Increment attendance

               print(f"Attendance recorded for {student['Name']}.")

           else:

               print(f"{student['Name']} has already attended all sessions.")

       else:

           print("Student ID not found.")

   ```

Purpose: Updates a student’s attendance if they have not yet completed all their sessions.

Notes: The function checks that the student's attendance doesn’t exceed the number of sessions they signed up for.

4. Delete (D) – Cancelling a Student Registration

This function handles the deletion of a student from the system. It removes the student’s information from the dictionary based on their ID.

   Python

   # Function to cancel a student's registration

   def cancel_registration(student_id):

       # Check if the student ID exists in the system

       if student_id in students_info:

           del students_info[student_id]  # Remove student from the dictionary

           print("Student registration cancelled successfully.")

       else:

           print("Student ID not found.")

   ```

Purpos: Deletes a student's record from the system, effectively canceling their registration.

Notes: It checks if the student ID exists before attempting to delete the record.

Additional Functions for Modularity

In addition to the CRUD operations, the system also includes other utility functions to keep the code modular and maintainable.

limited_input()

This function ensures that the input is of the correct type (e.g., integer for numbers). It also limits the number of failed attempts before returning None.

Python

  # Function to validate user input and limit failed attempts

  def limited_input(prompt, valid_type, attempts=3):

      while attempts > 0:

          try:

              return valid_type(input(prompt))  # Attempt to convert input

          except ValueError:

              print(f"Invalid input, please enter a {valid_type.__name__}")

              attempts -= 1  # Decrease attempt count

      return None  # Return None if attempts are exhausted

  ```

Purpose: Prevents errors due to invalid input (e.g., typing letters instead of numbers).

Notes: This function is called in several other functions, ensuring robust input handling across the system.

generate_invoice()

This function calculates the total amount due for each student based on their attendance and rate per session. It prints an invoice for the selected student.

Python

  # Function to generate an invoice for a student

  def generate_invoice(student_id):

      # Check if the student ID exists in the system

      if student_id in students_info:

          student = students_info[student_id]

          total_due = student['Rate'] * student['Attendance']  # Calculate total

          # Print the invoice details

          print(f"Invoice for {student['Name']}:")

          print(f"Sessions Attended: {student['Attendance']}")

          print(f"Total Due: {total_due}")

      else:

          print("Student ID not found.")

  ```

Purpose: Automates invoice generation by calculating the total cost based on the student’s attendance.

Notes: This function retrieves the rate and attendance from the dictionary and calculates the total amount due.

By breaking the project into distinct CRUD operations and other supportive functions, the code is modular, easy to manage, and reusable. Each function is focused on a specific task, allowing flexibility in extending or updating individual parts of the system without affecting the whole. This approach makes the code efficient and maintainable for real-world applications.

4. Applying Python Concepts in the Capstone Project

Control Flow & Conditional Logic

The system extensively uses conditional statements (`if`, elif, else) to navigate the menu and handle various user choices. For instance, the main menu prompts users to choose between options like registering a student or recording attendance. Here's an example of the control flow:

Python code

def main_menu():

    print("\nMenu List:")

    print("1. Display Students")

    print("2. Student Registration")

    print("3. Student Cancellation")

    print("4. Record Attendance")

    print("5. Generate Invoice")

    print("6. Exit")

```

Each option leads to a different function; validation ensures that only valid choices are accepted.

Loops

Loops are critical for iterating over student records, filtering data, and managing user interactions. For instance, the for loop is used to display student data:

Python code

for idx, student in students_info.items():

    print(f"{idx}: {student['Name']}, Attendance: {student['Attendance']}")

```

This provides a simple way to process all student data and allows for flexible operations like filtering and sorting.

Collection Data Types

Using dictionaries to store student data is essential for managing structured data. A nested dictionary allows students to store information under a unique identifier, making data retrieval and updates easy.

Error Handling

Error handling through try-except blocks ensures the system does not crash when the user provides invalid input. For instance, when entering a student's rate, the system ensures it's a positive integer. It prompts the user again if an invalid entry is made:

Python code

try:

    rate = int(input("Enter student's rate: "))

except ValueError:

    print("Invalid input, please enter a valid integer.")

```

5. Learning Outcomes and Future Applications

Building this project has reinforced my understanding of structuring Python code for real-world applications. Some of the key lessons learned include:

Data Organization: Using dictionaries to store student data in a structured format made it easier to manage multiple records.

Error Handling: Preventing and fixing in the event the user inputs the wrong data type or value for better data management

Automation: Automating tedious tasks such as writing or generating invoices manually one by one.

Future Enhancements

In the future, the project could be expanded by:

Adding a GUI: Implementing a graphical user interface for better user interaction.

Database Integration: Storing student records in a database for persistent data management.

Automated Email Invoices: Automatically send invoices to students via email.

Conclusion

The Module 1 Capstone Project is an example of applying basic Python skills in solving real-world problems. Utilizing loops, conditionals, functions, and data structures, I can create a system to automate the management of my student's data for tutoring services. This project can also become an excellent start for more complex data science tasks in the future. This project is the beginning of steps to master integrating automation and programming, as it will remain crucial as data science continues evolving.

References

Banton, Caroline. Investopedia. 28 December 2022. Webpage. 25 September 2024.