Teachers often need to keep track of student names. In this challenge, you'll create a **Python list** to store student names and practice **adding/removing students**.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_initial_list_length(self):
        import user_code
        importlib.reload(user_code)
        student_roster = getattr(user_code, 'student_roster', None)
        _dynamic_test(
            self,
            isinstance(student_roster, list) and len(student_roster) >= 5,
            "student_roster contains at least five names initially.",
            f"student_roster should have at least five names, got: {student_roster}"
        )

    def test_addition_increases_length(self):
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        # Remove the add/remove lines to simulate before addition
        code_before_add = code.split("# Add a new student to the list")[0] + "# Add a new student to the list\\n" + code.split("# Remove one student from the list")[1]
        ns = {}
        exec(code_before_add, ns)
        initial_len = len(ns['student_roster'])
        # Now execute after addition
        ns2 = {}
        exec(code, ns2)
        after_add_len = len(ns2['student_roster'])
        # The remove happens after add, so we check final_list +1
        _dynamic_test(
            self,
            after_add_len + 1 >= initial_len,
            "After adding and removing, list has one less or equal than after add.",
            f"Expected at least {initial_len-1} after add and remove, got {after_add_len}"
        )

    def test_removal_decreases_length(self):
        # Check that after add and remove, length is the same as original
        import user_code
        importlib.reload(user_code)
        student_roster = getattr(user_code, 'student_roster', None)
        final_list = getattr(user_code, 'final_list', None)
        _dynamic_test(
            self,
            isinstance(student_roster, list) and isinstance(final_list, list),
            "student_roster and final_list must be lists.",
            f"student_roster: {student_roster}, final_list: {final_list}"
        )
        _dynamic_test(
            self,
            len(final_list) == len(student_roster),
            "final_list matches student_roster after operations.",
            f"final_list: {final_list}, student_roster: {student_roster}"
        )

    def test_final_list_correct(self):
        import user_code
        importlib.reload(user_code)
        final_list = getattr(user_code, 'final_list', None)
        _dynamic_test(
            self,
            isinstance(final_list, list) and len(final_list) >= 5,
            "final_list contains at least five names.",
            f"final_list should have at least five names, got: {final_list}"
        )
        # Check that at least one name is new and at least one original name is missing
        original_names = {"Alice", "Bob", "Carlos", "Diana", "Eva"}
        new_names = set(final_list) - original_names
        missing_names = original_names - set(final_list)
        _dynamic_test(
            self,
            len(new_names) >= 1,
            "A new student was added to the final list.",
            f"No new student found in final_list: {final_list}"
        )
        _dynamic_test(
            self,
            len(missing_names) >= 1,
            "A student was removed from the final list.",
            f"No student removed from original list: {final_list}"
        )

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: Create a Student Roster

Ratkaisu