Demo Mode

Project 3 of 5

Project 3: Exam Results Analysis

Apply your knowledge to build something amazing!

Project 3: Exam Results Analysis :bar_chart:

:information_source: Project Overview Difficulty Level: Intermediate
Estimated Time: 2-3 hours
Skills Practiced:

Data generation with Numpy

Statistical calculations

Data visualization with Matplotlib

Working with arrays and tables

Creating professional charts

What You'll Build: A complete exam results analysis system that generates student scores, calculates statistics, and creates visualizations to help understand class performance.

:emoji:️ Project Roadmap

sql

📝 Part 1: Data Setup (30 mins)
    └─→ Import libraries
    └─→ Store student data
    └─→ Calculate totals & averages
    └─→ Create score table

📊 Part 2: Line Graph Visualization (45 mins)
    └─→ Plot student scores
    └─→ Add labels and legends
    └─→ Format the graph
    └─→ Display results

📈 Part 3: Bar Chart Analysis (45 mins)
    └─→ Calculate subject averages
    └─→ Create bar visualization
    └─→ Add statistical insights
    └─→ Polish presentation

🎥 Part 4: Video Recording (30 mins)
    └─→ Demonstrate code
    └─→ Explain insights
    └─→ Submit project

Project Components

The project consists of:

Code Implementation: Generate and analyze data, calculate scores, and visualize the results.
Video Submission: Record a 2-3 minute video demonstrating the code and explaining how it works.

Project Requirements

Code Implementation

Platform: Any Python IDE (e.g., Google Colab, Jupyter Notebook, or local Python setup)
Requirements:
- Generate Data: Use Numpy to generate random data for exam scores of students (e.g., 50 students with scores for 5 subjects).
- Score Calculation: For each student, calculate the total score and average score across all subjects.
- Data Visualization: Use Matplotlib to create the following visualizations:
  - A bar chart representing the total scores of each student.
  - A line chart showing the average score over time (if applicable, for example, over several exam periods).
  - A pie chart showing the distribution of grades (e.g., number of students in each grade range).

Video Submission

Duration: 2-3 minutes
Requirements:
- Record a video showing your program running.
- Demonstrate how the random data is generated and how the total and average scores are calculated.
- Show the visualizations created with Matplotlib.
- Explain what the visualizations represent and what insights you can draw from them (e.g., which student performed the best, the overall class performance).

Evaluation Criteria

Your project will be evaluated based on the following criteria:

Code Functionality (50%)
- Correct implementation of score generation, calculation, and visualization.
- Proper use of Numpy for generating data and performing calculations.
- Correct use of Matplotlib for visualizations.
Code Quality (25%)
- Code is clean, well-organized, and easy to understand.
- Includes comments to explain key parts of the code.
Creativity and Features (15%)
- Additional features, such as adding more visualizations, handling different types of datasets, or customizing the visualizations.
Video Submission (10%)
- Clear and concise explanation of the project and its components.
- Demonstrates the working code and discusses the insights from the visualizations.

Submission Requirements

Final submission should include:

Python code file (e.g., .py or notebook)
2-3 minute video showing the project and explanation

Project Submission

Make sure to double-check your project before submitting. Ensure you have included the Python code file and the video explanation as required.

Submit your project here

:rocket: Getting Started

:warning: Important Setup Instructions

Click the link here

Make a copy of the Colab Notebook into your Google Drive

Rename your copy to include your name (e.g., "YourName_ExamAnalysis")

Do NOT edit the original shared notebook!

Import Required Packages

python

import numpy as np
from prettytable import PrettyTable
import matplotlib.pyplot as plt

:memo: Part One: Working with Score Data

Step One: Store the Given Data

:bulb: Pro Tip Copy and paste this code to get started quickly! The data represents 7 students and their scores in 3 subjects.

python

students = np.array(["Adam", "Bob", "Crystal", "David", "Edmund", "Lily", "Jasmine"])
math_score = np.array([87, 42, 87, 99, 53, 95, 89])
science_score = np.array([78, 51, 89, 89, 70, 89, 90])
english_score = np.array([90, 66, 83, 83, 91, 90, 90])

Step 2: Calculate Total and Average Scores

Now let's calculate statistics for each student:

Calculate the total score by adding all three subject scores:
python
```
total = math_score + science_score + english_score
```
Calculate the average score and round to 2 decimal places:
python
```
average = np.round(total / 3, 2)
```

:memo: Expected Output When you print these arrays, you should see:
ini
Total score: [255 159 259 271 214 274 269]
Average score of each student: [85.   53.   86.33 90.33 71.33 91.33 89.67]

:warning: Common Error If you get a "NameError", make sure you've run the previous cell that defines the score arrays!

Step 3: Create a Professional Score Table

Let's create a nicely formatted table to display all our data:

Create the table object:
python
```
score_table = PrettyTable()
```

Set up the table structure:

python

# Add field names (column headers)
score_table.field_names = np.append("Students", students)

# Add rows for each data type
score_table.add_row(np.append("Maths", math_score))
score_table.add_row(np.append("Sciences", science_score))
score_table.add_row(np.append("English", english_score))
score_table.add_row(np.append("Total", total))
score_table.add_row(np.append("Average", average))

Display the table:

python

print("Examination Score Table")
print(score_table)

:bulb: Understanding np.append() The np.append() function adds "Students" as the first element before all student names. This creates our row labels!

Expected Output:

Examination Score Table

Students	Adam	Bob	Crystal	David	Edmund	Lily	Jasmine
Maths	87	42	87	99	53	95	89
Sciences	78	51	89	89	70	89	90
English	90	66	83	83	91	90	90
Total	255	159	259	271	214	274	269
Average	85.0	53.0	86.33	90.33	71.33	91.33	89.67

:white_check_mark: Milestone Checkpoint 1: If you can see the formatted table with all scores, totals, and averages - great job! You've completed Part 1! :tada:

:bar_chart: Part 2: Visualizing Student Scores

Now let's create a line graph to visualize how each student performs across different subjects.

Step One: Plot the Graph

Create three lines, one for each subject:

python

# Plot lines for each subject
plt.plot(students, math_score)
plt.plot(students, science_score)
plt.plot(students, english_score)

:memo: What's Happening?

x-axis: Student names

y-axis: Scores (0-100)

Each line represents a different subject

Step 2: Add Labels and Title

Make your graph professional by adding descriptive labels:

python

plt.title("Examination Score Graph", fontsize=16, fontweight='bold')
plt.xlabel("Students", fontsize=12)
plt.ylabel("Score", fontsize=12)

Step 3: Add a Legend

Help readers understand which line represents which subject:

python

plt.legend(["Mathematics", "Science", "English"])

:bulb: Making It Look Better Add this line to improve readability:
python
plt.grid(True, alpha=0.3)  # Adds a light grid

Step 4: Display the Graph

python

plt.show()

:warning: Debugging Tips Graph not showing?

Make sure you're running cells in order

Check that all variables are defined

Try plt.figure() before plotting to create a new figure

Lines look weird?

Verify your data arrays have the same length

Check for any typos in variable names

:white_check_mark: Milestone Checkpoint 2: Your line graph should show all three subjects with proper labels. Bob's low scores should be clearly visible! :chart_with_downwards_trend:

:chart_with_upwards_trend: Part 3: Creating Subject Average Bar Graph

Let's analyze which subject has the highest class average!

Step One: Import Statistical Functions

python

from scipy import stats

Step 2: Calculate Subject Averages

Calculate the mean score for each subject:

python

# Calculate means and round to 2 decimal places
mean_math = round(stats.mean(math_score), 2)
mean_sc = round(stats.mean(science_score), 2)
mean_eng = round(stats.mean(english_score), 2)

# Print to verify
print(f"Mean for Math: {mean_math}")
print(f"Mean for Science: {mean_sc}")
print(f"Mean for English: {mean_eng}")

:memo: Expected Output

rust

Mean for Math: 78.86
Mean for Science: 79.43
Mean for English: 84.71

Step 3: Prepare Data for Bar Chart

Organize your data for visualization:

python

# Subject names for x-axis
subjects = ["Mathematics", "Science", "English"]

# Average scores for y-axis
mean_subjects = [mean_math, mean_sc, mean_eng]

Step 4: Create the Bar Chart

python

# Create a new figure
plt.figure(figsize=(8, 6))

# Create bar chart with colors
colors = ['#FF6B6B', '#4ECDC4', '#45B7D1']
plt.bar(subjects, mean_subjects, color=colors)

# Add title and labels
plt.title("Average Score by Subject", fontsize=16, fontweight='bold')
plt.xlabel("Subjects", fontsize=12)
plt.ylabel("Average Score", fontsize=12)

# Add value labels on top of bars
for i, v in enumerate(mean_subjects):
    plt.text(i, v + 1, str(v), ha='center', fontweight='bold')

# Add a horizontal line for overall average
overall_avg = sum(mean_subjects) / len(mean_subjects)
plt.axhline(y=overall_avg, color='red', linestyle='--', alpha=0.7, label=f'Overall Avg: {overall_avg:.2f}')
plt.legend()

# Display the chart
plt.show()

:bulb: Best Practice Adding value labels on bars makes it easier to read exact values without referring to the y-axis!

:white_check_mark: Milestone Checkpoint 3: Your bar chart should clearly show that English has the highest average score! :books:

:emoji: AI Coding Assistant

:bulb: Using AI for Data Visualization Try these prompts to enhance your project:

Basic Prompts:

"Help me generate a scatter plot in Matplotlib to visualize the relationship between study hours and exam scores."

"Create a pie chart showing the grade distribution (A, B, C, D, F) based on average scores"

"Add error bars to my bar chart to show standard deviation"

Advanced Prompts:

"Create a heatmap showing correlation between different subjects"

"Generate a box plot to identify outliers in the score data"

"Create an animated bar chart that shows scores changing over time"

:dart: Extension Challenges

Ready to go beyond the basics? Try these challenges:

:star2: Challenge One: Grade Distribution (Beginner)

Create a pie chart showing how many students got A (90+), B (80-89), C (70-79), D (60-69), or F (<60) based on their average scores.

:star2: Challenge 2: Subject Difficulty Analysis (Intermediate)

Calculate the standard deviation for each subject
Create a combination chart showing both mean and standard deviation
Identify which subject has the most consistent scores

:star2: Challenge 3: Performance Dashboard (Advanced)

Create a complete dashboard with:

Individual student performance radar charts
Subject correlation matrix
Top performers highlighting
Class performance summary statistics

:star2: Challenge 4: Predictive Analysis (Expert)

Generate random data for multiple exam periods
Create trend lines showing student improvement over time
Implement a simple prediction model for future scores

:bug: Common Errors and Solutions

:warning: Troubleshooting Guide Error: "NameError: name 'plt' is not defined"

Solution: Make sure you've imported matplotlib.pyplot as plt

Error: "ValueError: x and y must have same first dimension"

Solution: Check that your arrays have the same length (7 students)

Error: Table not displaying properly

Solution: Ensure PrettyTable is imported and you're using print() to display

Error: Graph overlapping or cut off

Solution: Use plt.figure(figsize=(10, 6)) before plotting

Add plt.tight_layout() before plt.show()

Error: "ModuleNotFoundError: No module named 'scipy'"

Solution: Install scipy using !pip install scipy in Colab

:emoji: Video Recording Tips

:information_source: Video Guidelines For your 2-3 minute video:

Introduction (30 seconds)
- Briefly explain the project goal
- Show your final visualizations
Code Walkthrough (1 minute)
- Demonstrate data generation
- Show calculation process
- Explain your visualization choices
Insights (1 minute)
- Identify top performers
- Discuss subject difficulties
- Share interesting patterns you found
Conclusion (30 seconds)
- Summarize key findings
- Mention any extensions you added

Recording Tips:

Use screen recording software (OBS, Loom, or built-in tools)
Speak clearly and at a moderate pace
Keep your code visible while explaining
Test your audio before recording

:tada: Final Submission Checklist

Before submitting, ensure you have:

Completed all three parts of the project
Added comments to explain your code
Tested all code cells run without errors
Created all required visualizations
Recorded a 2-3 minute video explanation
Saved your notebook with a descriptive name
Double-checked the submission form link works

Good luck with your exam analysis project! Remember, data tells a story - make yours compelling! :bar_chart::sparkles:

Project 3 of 5