Analyze Student Data with Python

Build a Python script that loads CSV data and generates a performance report.

Introduction

30 Second Summary

Every teacher, tutor, and school administrator deals with the same challenge: turning rows of raw scores into meaningful insights about how students are actually doing. Manually scanning numbers is slow and error-prone.

In this project, you will build a Python script that reads student grades from a file, crunches the numbers, and prints a clear performance report to your terminal.

What You'll Build

A command-line Student Performance Analyzer that loads CSV data, computes statistical summaries, assigns letter grades, and outputs a formatted report.

By the end of this project, you'll have:

  • A CSV dataset with 10 student records across 3 subjects, stored in a professional project folder structure.
  • An analyzer.py script that loads, processes, and reports on the data using Python's standard library.
  • A formatted terminal report showing subject statistics, individual grades, a grade distribution chart, and the overall pass rate.
  • Secret Mission: Add a strengths and weaknesses analysis that identifies each student's best and worst subject and ranks students by score spread.

Are there any prerequisites?

None. This project includes full setup instructions for VS Code and Python. No prior programming experience is required.

Set Up Your Project

Every data analysis project starts with the same foundation: a clean folder structure and a dataset to work with.

In this step, you will create a project folder, add a CSV file with student grade data, and confirm that Python can run your script. This gives you the base structure that the rest of the project builds on.

In this step, get ready to:
  • Create the project folder structure with a data subfolder.
  • Create a CSV file with 10 student records.
  • Verify Python runs your script successfully.
Create the project folder structure

A dedicated project folder keeps your code and data organized. The data/ subfolder pattern is standard in data science projects, separating raw data from processing scripts.

  • Open the integrated terminal in VS Code by pressing Ctrl+` (macOS) or Ctrl+` (Windows).
  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder and move into it by running these commands:
mkdir student-performance-analyzer
cd student-performance-analyzer
  • Create the data subfolder by running:
mkdir data
  • Confirm the folders exist by running:
ls

You should see data listed in the output.

Don't see the data folder?

Make sure you ran mkdir data after you moved into the student-performance-analyzer folder. If the folder was created on your Desktop instead, delete it and re-run the commands from inside student-performance-analyzer.

help me fix my folder structure

  • Now open this project folder in VS Code. Click File in the top menu bar.
  • Click Open Folder.
  • Navigate to your Desktop, select the student-performance-analyzer folder, and click Select Folder.

Seeing a trust dialog?

VS Code may ask if you trust the authors of the files in this folder. Click Yes, I trust the authors to continue. This is a security feature that enables full editor functionality for the folder.

Create the CSV data file

Your analyzer needs data to work with. You will create a CSV file containing 10 student records with scores in math, science, and english.

  • In the VS Code Explorer sidebar on the left, hover over the data folder.
  • Click the New File icon that appears next to the folder name.
  • Type students.csv and press Enter.
  • Paste the following data into the file:
name,math,science,english
Alice,92,88,95
Bob,78,82,71
Charlie,65,70,68
Diana,88,91,85
Eve,45,52,48
Frank,73,68,75
Grace,95,97,92
Henry,60,55,62
Ivy,84,79,88
Jack,71,74,69

What does this data represent?

Each row is one student with scores in three subjects. The first row (name,math,science,english) is the header that labels each column.

The scores range from 45 to 97, giving you a mix of failing, passing, and top-performing students. This variety produces meaningful statistics when you analyze it later.

  • Save students.csv by pressing Ctrl+S (macOS: Cmd+S).

You should see students.csv appear under the data folder in the Explorer sidebar.

File not showing under data?

If students.csv appears at the project root instead of inside data/, you may have clicked the New File icon on the project root rather than on the data folder. Drag the file into the data folder in the Explorer sidebar to fix this.

help me move my CSV file into the correct folder

✔️ Awesome, I've got everything!

Great. Make sure you have saved data/students.csv before moving on.

ⓧ I'd like to double check the full code

Here is the complete data/students.csv file for comparison:

name,math,science,english
Alice,92,88,95
Bob,78,82,71
Charlie,65,70,68
Diana,88,91,85
Eve,45,52,48
Frank,73,68,75
Grace,95,97,92
Henry,60,55,62
Ivy,84,79,88
Jack,71,74,69
Create the analyzer script and verify Python runs it

Now you will create the main Python script and confirm that your environment can run it.

  • In the Explorer sidebar, hover over the project folder name (student-performance-analyzer) at the top.
  • Click the New File icon.
  • Type analyzer.py and press Enter.
  • Paste the following code into the file:
print("Setup complete!")

What does this code do?

print() is a built-in Python function that displays text in the terminal. This one-liner is a quick sanity check to confirm Python is working before you write more complex code.

  • Save analyzer.py by pressing Ctrl+S (macOS: Cmd+S).
  • Open the integrated terminal by pressing Ctrl+` (macOS: Ctrl+`).
  • Run your script by entering this command:
python analyzer.py

You should see Setup complete! printed in the terminal.

Seeing an error instead?

If you see a "file not found" message, make sure your terminal is in the student-performance-analyzer folder. When VS Code opened the folder, the terminal should have started there automatically. If not, click the trash can icon in the terminal panel to close it, then press Ctrl+` to open a fresh terminal.

If you see "python is not recognized", try running python --version to confirm Python is installed and available on your system PATH.

help me troubleshoot running my Python script

✔️ Awesome, I've got everything!

Great. Make sure both files are saved before continuing to the next step.

ⓧ I'd like to double check the full code

Here is the complete analyzer.py file at this point:

print("Setup complete!")

Your project structure is ready and Python is confirmed working. Next up, you will write a function that loads the CSV data into Python so you can start analyzing it.

Load and Parse CSV Data

Your project folder is ready with a CSV file full of student data. Now it's time to write Python code that reads this file and converts it into a format your script can work with.

Python's built-in csv module handles the heavy lifting of parsing CSV files. In this step, you'll write a function that loads students.csv and turns each row into a Python dictionary with numeric scores.

In this step, get ready to:
  • Write a load_data function using csv.DictReader.
  • Call the function from a main function and print the result.
  • Verify all 10 student records load with numeric scores.
Import the csv module and write the load_data function

The csv.DictReader class reads each row of a CSV file as a dictionary, using the header row as keys. This means you can access values by column name instead of index position.

  • In VS Code, open analyzer.py (it currently contains only print("Setup complete!")).
  • Select all the existing code by pressing Ctrl+A, then replace it with the following:
import csv
from statistics import mean, median, stdev


def load_data(filepath):
    """Load student data from a CSV file."""
    students = []
    with open(filepath, newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            student = {
                "name": row["name"],
                "math": float(row["math"]),
                "science": float(row["science"]),
                "english": float(row["english"]),
            }
            students.append(student)
    return students

What does this code do?

  • import csv brings in Python's built-in CSV parsing module.
  • from statistics import mean, median, stdev imports math functions you'll use in the next step.
  • open(filepath, newline="") opens the CSV file. The newline="" parameter ensures the CSV reader handles line endings correctly.
  • csv.DictReader(f) reads each row as a dictionary, using the first row (name,math,science,english) as the keys.
  • float(row["math"]) converts the score strings from the CSV into numbers so you can do math with them later.

You won't see a change yet. The next substep adds a function to call this code.

Call load_data from a main function

Python scripts use a main function as the entry point. The if __name__ == "__main__" pattern ensures your code only runs when you execute the script directly.

  • Below the return students line in analyzer.py, add the following code:


def main():
    students = load_data("data/students.csv")
    print(students)


if __name__ == "__main__":
    main()

What does this code do?

  • main() calls load_data with the path to your CSV file and prints the result.
  • if __name__ == "__main__" tells Python to run main() only when you execute this file directly (not when importing it as a module).
  • Save analyzer.py.
Run the script and confirm the output
  • Run your script by entering this command in the terminal:
python analyzer.py

You should see a list of 10 dictionaries printed in the terminal. Each dictionary contains a student's name as a string and three scores as floating-point numbers.

What should I see?

The output starts with something like:

[{'name': 'Alice', 'math': 92.0, 'science': 88.0, 'english': 95.0}, {'name': 'Bob', ...}]

The key thing to confirm is that the scores are numbers (92.0) not strings ('92'). If you see quotes around the numbers, the float() conversion is missing.

Seeing a FileNotFoundError?

  • Make sure you're running the command from your project folder (the one that contains the data subfolder). Use cd to navigate there if needed.
  • Check that data/students.csv exists. The path in your code must match the actual file location exactly.
  • Verify there are no typos in the filename. The file must be named students.csv (all lowercase).

Help me debug a FileNotFoundError in my Python script

✔️ Awesome, I've got everything!

Great. Double check you've saved your file before moving on.

ⓧ I'd like to double check the full code

Here's the complete analyzer.py at this point:

import csv
from statistics import mean, median, stdev


def load_data(filepath):
    """Load student data from a CSV file."""
    students = []
    with open(filepath, newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            student = {
                "name": row["name"],
                "math": float(row["math"]),
                "science": float(row["science"]),
                "english": float(row["english"]),
            }
            students.append(student)
    return students


def main():
    students = load_data("data/students.csv")
    print(students)


if __name__ == "__main__":
    main()

Your data is loaded and structured. Next up, you'll write functions that crunch these numbers into meaningful statistics.

Compute Subject Statistics

Your script can load and parse all 10 student records from the CSV file. Now it's time to make sense of that raw data by computing statistics and assigning grades.

Python's statistics module provides ready-made functions for common calculations like mean, median, and standard deviation. You'll use these to analyze scores per subject and classify students by overall performance.

In this step, get ready to:
  • Write a function to compute subject-level statistics (mean, median, standard deviation).
  • Write a function to assign letter grades based on numeric scores.
  • Categorize every student by their overall average across all subjects.
Write the compute_subject_stats function

Your file already imports mean, median, and stdev from the statistics module at the top. Now you'll put them to work in a function that calculates stats for any given subject.

  • In analyzer.py, find the end of your load_data function (the return students line).
  • Add two blank lines after it, then paste the following function:
def compute_subject_stats(students, subject):
    """Compute mean, median, and standard deviation for a subject."""
    # Extract all scores for the given subject into a list
    scores = [student[subject] for student in students]
    return {
        "mean": round(mean(scores), 1),
        "median": round(median(scores), 1),
        "stdev": round(stdev(scores), 1),
        "min": min(scores),
        "max": max(scores),
    }

What does this code do?

This function takes two arguments: the full list of students and a subject name (like "math").

  • The list comprehension [student[subject] for student in students] pulls out every student's score for that one subject into a flat list.
  • It then passes that list to mean, median, and stdev from the statistics module.
  • The round(..., 1) call limits decimal places to one digit for cleaner output.
  • Save analyzer.py.
  • You won't see a change yet. The next function will use compute_subject_stats when generating the report.

Seeing a red underline in VS Code?

  • Check that your function is indented at the top level (no extra spaces before def).
  • Make sure the from statistics import mean, median, stdev line is still at the top of your file.

Help me fix a red underline error in my compute_subject_stats function.

Write the get_letter_grade function

Grade boundaries give raw numbers a human-readable label. This function maps any numeric average to a standard letter grade.

  • Below your compute_subject_stats function, add two blank lines and paste this function:
def get_letter_grade(average):
    """Convert a numeric average to a letter grade."""
    if average >= 90:
        return "A"
    elif average >= 80:
        return "B"
    elif average >= 70:
        return "C"
    elif average >= 60:
        return "D"
    else:
        return "F"

What does this code do?

  • The function checks the average from highest threshold to lowest using if/elif/else.
  • A score of 90 or above earns an A, 80+ earns a B, 70+ earns a C, 60+ earns a D, and anything below 60 is an F.
  • Order matters here. Python checks each condition top to bottom and returns as soon as one matches.
  • Save analyzer.py.
  • You won't see a change yet. The next function will call get_letter_grade for each student.

Indentation errors?

  • Make sure each elif and else is aligned with the if above it.
  • The return statements should be indented one level deeper than their matching condition.

Help me fix my if/elif/else indentation in Python.

Write the categorize_students function

This function ties everything together. It calculates each student's average across all three subjects and assigns them a letter grade.

  • Below your get_letter_grade function, add two blank lines and paste this function:
def categorize_students(students):
    """Assign each student a letter grade based on their overall average."""
    categorized = []
    for student in students:
        # Collect this student's scores across all three subjects
        scores = [student["math"], student["science"], student["english"]]
        average = round(mean(scores), 1)
        grade = get_letter_grade(average)
        categorized.append({
            "name": student["name"],
            "average": average,
            "grade": grade,
        })
    return categorized

What does this code do?

  • It loops through every student dictionary in the list.
  • For each student, it collects their math, science, and english scores into a list, then computes the mean of those three numbers.
  • It passes that average to get_letter_grade to get a letter (A through F).
  • Each result is appended as a new dictionary with the student's name, numeric average, and letter grade.

Now update your main function to call categorize_students so you can test the result.

  • Scroll down to your main function at the bottom of the file.
  • Find this line:
    print(students)
  • Replace that line with these two lines:
    categorized = categorize_students(students)
    print(categorized)
  • Save analyzer.py.
  • Run the script by entering this command in your terminal:
python analyzer.py

You should see a list of dictionaries, each containing a student's name, their numeric average, and a letter grade (A through F).

Seeing a NameError or TypeError?

  • A NameError: name 'get_letter_grade' is not defined means your categorize_students function appears above get_letter_grade in the file. Move it below so Python sees the definition first.
  • A TypeError usually means one of the score values is still a string. Check that load_data wraps each score in float().
  • Make sure the indentation inside categorize_students uses consistent spaces (4 spaces per level).

Help me debug my categorize_students function.

✔️ Awesome, I've got everything!

Great. Double check you've saved your file before moving on.

ⓧ I'd like to double check the full code

Here is the complete analyzer.py file at this point:

import csv
from statistics import mean, median, stdev


def load_data(filepath):
    """Load student data from a CSV file."""
    students = []
    with open(filepath, newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            student = {
                "name": row["name"],
                "math": float(row["math"]),
                "science": float(row["science"]),
                "english": float(row["english"]),
            }
            students.append(student)
    return students


def compute_subject_stats(students, subject):
    """Compute mean, median, and standard deviation for a subject."""
    scores = [student[subject] for student in students]
    return {
        "mean": round(mean(scores), 1),
        "median": round(median(scores), 1),
        "stdev": round(stdev(scores), 1),
        "min": min(scores),
        "max": max(scores),
    }


def get_letter_grade(average):
    """Convert a numeric average to a letter grade."""
    if average >= 90:
        return "A"
    elif average >= 80:
        return "B"
    elif average >= 70:
        return "C"
    elif average >= 60:
        return "D"
    else:
        return "F"


def categorize_students(students):
    """Assign each student a letter grade based on their overall average."""
    categorized = []
    for student in students:
        scores = [student["math"], student["science"], student["english"]]
        average = round(mean(scores), 1)
        grade = get_letter_grade(average)
        categorized.append({
            "name": student["name"],
            "average": average,
            "grade": grade,
        })
    return categorized


def main():
    students = load_data("data/students.csv")
    categorized = categorize_students(students)
    print(categorized)


if __name__ == "__main__":
    main()

Your script now understands individual performance. It can compute statistics for any subject and assign every student a letter grade. Next up, you'll build the formatted report that presents all of this data in a readable way.

Generate the Performance Report

Your analyzer can now load data, compute statistics, and assign letter grades. All of that processing happens behind the scenes, though. Without a clear output, nobody can actually read the results.

In this step, you will build a formatted terminal report that brings all your analysis together. The report will display subject-level statistics, individual student grades, a visual grade distribution, and the overall pass rate.

In this step, get ready to:
  • Write a function that counts how many students fall into each grade category.
  • Build a formatted report function that displays all analysis results.
  • Run the complete script and verify your full performance report.
Write the grade counting function

Before you can display a grade distribution chart, you need to know how many students earned each letter grade. A dedicated function will tally up the counts.

  • In analyzer.py, add the following function below your categorize_students function:
def count_grades(categorized):
    """Count how many students fall into each grade category."""
    grade_counts = {"A": 0, "B": 0, "C": 0, "D": 0, "F": 0}
    for student in categorized:
        grade_counts[student["grade"]] += 1
    return grade_counts

What does this code do?

This function creates a dictionary with all five possible letter grades initialized to zero. It then loops through every categorized student and increments the count for their assigned grade.

The result is a simple tally like {"A": 2, "B": 3, "C": 2, "D": 2, "F": 1} that you will use to build a bar chart later.

  • Save analyzer.py.

You will not see a change yet. The next function uses this tally to build the distribution chart.

Write the report printing function

This function is the centerpiece of your analyzer. It pulls together subject statistics, individual grades, the distribution chart, and pass rate into one clean terminal output.

  • In analyzer.py, add the following function below count_grades:
def print_report(students, categorized):
    """Print a formatted performance report."""
    subjects = ["math", "science", "english"]

    print("=" * 50)
    print("       STUDENT PERFORMANCE REPORT")
    print("=" * 50)
    print(f"\nTotal students analyzed: {len(students)}")

    print("\n--- Subject Statistics ---")
    for subject in subjects:
        stats = compute_subject_stats(students, subject)
        print(f"\n  {subject.upper()}")
        print(f"    Mean:   {stats['mean']}")
        print(f"    Median: {stats['median']}")
        print(f"    Stdev:  {stats['stdev']}")
        print(f"    Range:  {stats['min']} - {stats['max']}")

    print("\n--- Student Grades ---")
    for student in categorized:
        print(f"  {student['name']:<15} Average: {student['average']:<6} Grade: {student['grade']}")

    grade_counts = count_grades(categorized)
    print("\n--- Grade Distribution ---")
    for grade, count in grade_counts.items():
        bar = "#" * count
        print(f"  {grade}: {bar} ({count})")

    passing = sum(1 for s in categorized if s["grade"] != "F")
    print(f"\n  Pass rate: {round(passing / len(categorized) * 100, 1)}%")
    print("\n" + "=" * 50)

What does this code do?

  • The first section prints a header with = borders and the total student count.
  • The subject statistics loop calls compute_subject_stats for each subject and displays the mean, median, standard deviation, and range.
  • The student grades section uses f-string formatting (:<15 and :<6) to align columns neatly.
  • The grade distribution builds a simple bar chart by repeating # characters. One # per student in that grade category.
  • The pass rate counts everyone whose grade is not F and divides by the total number of students.
  • Save analyzer.py.

You will not see output yet because main() still calls print(categorized). The next substep connects everything.

Seeing a syntax error when you save?

  • Check that every f-string uses matching curly braces {}. A missing closing brace will cause an error.
  • Make sure your dictionary keys inside f-strings use single quotes (stats['mean']) since the f-string itself uses double quotes.
  • Verify the function is indented at the same level as your other function definitions (no extra indentation).

Why is my print_report function causing a syntax error?

Connect everything in main and run the script

Your main() function currently prints the raw categorized list. You need to replace that with a call to your new print_report function.

  • In analyzer.py, scroll down to your main() function.
  • Find this line:
    print(categorized)
  • Replace it with this line:
    print_report(students, categorized)

Your complete main() function should now look like this:

def main():
    students = load_data("data/students.csv")
    categorized = categorize_students(students)
    print_report(students, categorized)
  • Save analyzer.py.
  • Run your script by entering this command in the terminal:
python analyzer.py

You should see a full performance report in your terminal with a header, subject statistics for math, science, and english, individual student grades, a grade distribution chart made of # symbols, and a pass rate at the bottom.

What should I see?

Your report starts and ends with a line of = characters. Inside, you will see sections for Subject Statistics, Student Grades, and Grade Distribution.

The grade distribution shows a visual bar where each # represents one student. The pass rate should show 90.0% because 9 out of 10 students passed (only Eve received an F).

Seeing a NameError or no output?

  • If you see NameError: name 'print_report' is not defined, check that your print_report function is defined above main() in the file.
  • If you see a KeyError, make sure the dictionary keys in your f-strings match exactly ('mean', 'median', 'stdev').
  • Make sure you replaced print(categorized) with print_report(students, categorized) and did not accidentally leave both lines in.

My script is not printing the report correctly. Help me debug.

✔️ Awesome, I've got everything!

Great. Double check you have saved analyzer.py and that your terminal shows the full report.

ⓧ I'd like to double check the full code

Here is the complete analyzer.py file. Compare it with yours line by line.

import csv
from statistics import mean, median, stdev


def load_data(filepath):
    """Load student data from a CSV file."""
    students = []
    with open(filepath, newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            student = {
                "name": row["name"],
                "math": float(row["math"]),
                "science": float(row["science"]),
                "english": float(row["english"]),
            }
            students.append(student)
    return students


def compute_subject_stats(students, subject):
    """Compute mean, median, and standard deviation for a subject."""
    scores = [student[subject] for student in students]
    return {
        "mean": round(mean(scores), 1),
        "median": round(median(scores), 1),
        "stdev": round(stdev(scores), 1),
        "min": min(scores),
        "max": max(scores),
    }


def get_letter_grade(average):
    """Convert a numeric average to a letter grade."""
    if average >= 90:
        return "A"
    elif average >= 80:
        return "B"
    elif average >= 70:
        return "C"
    elif average >= 60:
        return "D"
    else:
        return "F"


def categorize_students(students):
    """Assign each student a letter grade based on their overall average."""
    categorized = []
    for student in students:
        scores = [student["math"], student["science"], student["english"]]
        average = round(mean(scores), 1)
        grade = get_letter_grade(average)
        categorized.append({
            "name": student["name"],
            "average": average,
            "grade": grade,
        })
    return categorized


def count_grades(categorized):
    """Count how many students fall into each grade category."""
    grade_counts = {"A": 0, "B": 0, "C": 0, "D": 0, "F": 0}
    for student in categorized:
        grade_counts[student["grade"]] += 1
    return grade_counts


def print_report(students, categorized):
    """Print a formatted performance report."""
    subjects = ["math", "science", "english"]

    print("=" * 50)
    print("       STUDENT PERFORMANCE REPORT")
    print("=" * 50)
    print(f"\nTotal students analyzed: {len(students)}")

    print("\n--- Subject Statistics ---")
    for subject in subjects:
        stats = compute_subject_stats(students, subject)
        print(f"\n  {subject.upper()}")
        print(f"    Mean:   {stats['mean']}")
        print(f"    Median: {stats['median']}")
        print(f"    Stdev:  {stats['stdev']}")
        print(f"    Range:  {stats['min']} - {stats['max']}")

    print("\n--- Student Grades ---")
    for student in categorized:
        print(f"  {student['name']:<15} Average: {student['average']:<6} Grade: {student['grade']}")

    grade_counts = count_grades(categorized)
    print("\n--- Grade Distribution ---")
    for grade, count in grade_counts.items():
        bar = "#" * count
        print(f"  {grade}: {bar} ({count})")

    passing = sum(1 for s in categorized if s["grade"] != "F")
    print(f"\n  Pass rate: {round(passing / len(categorized) * 100, 1)}%")
    print("\n" + "=" * 50)


def main():
    students = load_data("data/students.csv")
    categorized = categorize_students(students)
    print_report(students, categorized)


if __name__ == "__main__":
    main()

Secret mission

Add a Strengths and Weaknesses Analysis

Your report tells you how students are doing overall, but it doesn't reveal where each student shines or struggles. Can you add an analysis that identifies every student's best and worst subject, then ranks them by how uneven their scores are?

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally, so there are no ongoing costs. Decide whether to keep your project files on your machine or delete them entirely.

Resources you used:

  • Your project folder containing analyzer.py and the data subfolder.

Keep everything running

No action needed. Choose this if you plan to build on this project or reference the code later.

  • Your project folder stays on your Desktop with all files intact.
  • You can reopen the folder in VS Code anytime to review or extend your analyzer.

Pause - I'll come back to this later

Close VS Code to free up memory. Your files stay on disk and are ready whenever you return.

  • Close VS Code.
  • Your project folder remains on your Desktop. Reopen it in VS Code when you are ready to continue.

Delete - I don't want to use this again

Remove all project files from your machine.

  • Close VS Code if it is still open.
  • Open File Explorer and navigate to your Desktop.
  • Right-click your project folder (the one containing analyzer.py and the data subfolder) and select Delete.

Nice Work!

Nice Work!

You just built a complete data analysis pipeline in Python, from raw CSV file to formatted performance report. That is the exact workflow data scientists and ML engineers use as step one of every project.

Here's what you accomplished:

  • Built a Python script that loads CSV data using csv.DictReader and converts raw strings into structured dictionaries ready for analysis.
  • Applied Python's statistics module to compute mean, median, and standard deviation across multiple subjects.
  • Generated a formatted terminal report with subject statistics, letter grades, a visual grade distribution, and pass rate calculations.
  • Secret Mission: Added a strengths and weaknesses analysis using sorting with lambda functions and dictionary operations to rank students by score spread.

Ready to quiz yourself?