Visualizing grades can help teachers quickly identify trends. In this challenge, you'll use **matplotlib** to create a bar chart of student grades.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
from unittest.mock import patch
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)

    def test_bar_chart_labels_and_heights(self):
        import user_code
        importlib.reload(user_code)
        test_grades = {"Tom": 80, "Jerry": 90, "Spike": 70}
        with patch("matplotlib.pyplot.show"):
            plt.clf()
            user_code.plot_grade_barchart(test_grades)
            ax = plt.gca()
            bars = ax.patches
            bar_labels = [tick.get_text() for tick in ax.get_xticklabels()]
            bar_heights = [bar.get_height() for bar in bars]
            expected_labels = list(test_grades.keys())
            expected_heights = list(test_grades.values())
            _dynamic_test(
                self,
                bar_labels == expected_labels,
                f"X-axis labels match student names: {expected_labels}",
                f"Expected x-axis labels {expected_labels}, got {bar_labels}"
            )
            _dynamic_test(
                self,
                bar_heights == expected_heights,
                f"Bar heights match grades: {expected_heights}",
                f"Expected bar heights {expected_heights}, got {bar_heights}"
            )

    def test_chart_labels_and_title(self):
        import user_code
        importlib.reload(user_code)
        test_grades = {"A": 1, "B": 2}
        with patch("matplotlib.pyplot.show"):
            plt.clf()
            user_code.plot_grade_barchart(test_grades)
            ax = plt.gca()
            xlabel = ax.get_xlabel()
            ylabel = ax.get_ylabel()
            title = ax.get_title()
            _dynamic_test(
                self,
                xlabel == "Student Name",
                "X-axis is labeled 'Student Name'",
                f"Expected x-axis label 'Student Name', got '{xlabel}'"
            )
            _dynamic_test(
                self,
                ylabel == "Grade",
                "Y-axis is labeled 'Grade'",
                f"Expected y-axis label 'Grade', got '{ylabel}'"
            )
            _dynamic_test(
                self,
                title == "Class Performance",
                "Chart title is 'Class Performance'",
                f"Expected chart title 'Class Performance', got '{title}'"
            )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A beginner-friendly Python course designed specifically for teachers. Learn how to use Python to organize grades, analyze student performance, and automate classroom tasks with engaging, real-world examples.

Learn the basics of Python programming with a focus on classroom and grade organization. This section introduces Python syntax, variables, and simple data structures through relatable educational scenarios.

Dive deeper into Python by learning how to organize, analyze, and visualize student grades. This section covers dictionaries, conditional logic, and basic data analysis techniques tailored for teachers.

Explore how Python can automate common classroom tasks such as attendance tracking, assignment management, and generating reports. This section introduces file operations and more advanced automation techniques.

Challenge: Visualize Class Performance

Solution