Visualizing real-world data is a fundamental skill for anyone working with mathematics or science. When you collect data—such as daily temperatures, rainfall, or measurements from experiments—it is rarely enough to just look at the raw numbers. Visualizations like line plots and histograms help you quickly spot patterns, trends, and outliers, making the information more accessible and meaningful. Understanding the distribution of your data, through measures like the **mean** and **standard deviation**, enables you to summarize large datasets with just a few numbers and supports deeper analysis. By combining summary statistics with clear visualizations, you gain insights that are difficult to achieve by looking at raw data alone.

# List of daily temperatures
temperatures = [68, 70, 72, 71, 69, 73, 75, 74, 72, 70]

# Calculate mean
mean_temp = sum(temperatures) / len(temperatures)

# Calculate standard deviation
squared_diffs = [(x - mean_temp) ** 2 for x in temperatures]
std_dev = (sum(squared_diffs) / len(temperatures)) ** 0.5

print("Mean temperature:", mean_temp)
print("Standard deviation:", std_dev)


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
import sys
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        # Patch plt.show to prevent actual plot windows during tests
        self._original_show = plt.show
        plt.show = lambda *a, **k: None
    def tearDown(self):
        plt.show = self._original_show

    def test_mean_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show for this test
        plt.show = lambda *a, **k: None
        captured = io.StringIO()
        sys.stdout = captured
        temps = [68, 70, 72, 71, 69, 73, 75, 74, 72, 70]
        user_code.analyze_and_visualize(temps)
        sys.stdout = sys.__stdout__
        output = captured.getvalue()
        mean_expected = sum(temps) / len(temps)
        _dynamic_test(
            self,
            f"Mean temperature:" in output and str(round(mean_expected, 2))[:4] in output,
            "Mean is correctly calculated and printed.",
            f"Mean temperature not found or incorrect in output: {output}"
        )

    def test_stddev_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show for this test
        plt.show = lambda *a, **k: None
        captured = io.StringIO()
        sys.stdout = captured
        temps = [68, 70, 72, 71, 69, 73, 75, 74, 72, 70]
        user_code.analyze_and_visualize(temps)
        sys.stdout = sys.__stdout__
        output = captured.getvalue()
        mean = sum(temps) / len(temps)
        stddev_expected = (sum([(x - mean) ** 2 for x in temps]) / len(temps)) ** 0.5
        _dynamic_test(
            self,
            f"Standard deviation:" in output and str(round(stddev_expected, 2))[:4] in output,
            "Standard deviation is correctly calculated and printed.",
            f"Standard deviation not found or incorrect in output: {output}"
        )

    def test_lineplot_and_histogram_labels_titles(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show for this test
        plots = []
        def fake_show():
            # Save current figure to list for inspection
            fig = plt.gcf()
            plots.append(fig)
        plt.show = fake_show
        temps = [68, 70, 72, 71, 69, 73, 75, 74, 72, 70]
        user_code.analyze_and_visualize(temps)
        # There should be at least 2 plots
        _dynamic_test(
            self,
            len(plots) == 2,
            "Both line plot and histogram are shown.",
            f"Expected two plots, got {len(plots)}."
        )
        # Check first plot (line plot)
        ax1 = plots[0].axes[0] if plots[0].axes else None
        _dynamic_test(
            self,
            ax1 is not None and ax1.get_title() == "Daily Temperatures" and ax1.get_xlabel() == "Day" and ax1.get_ylabel() == "Temperature (°F)",
            "Line plot has correct title and axis labels.",
            f"Line plot missing or incorrect labels/titles: title='{getattr(ax1, 'get_title', lambda: None)()}', xlabel='{getattr(ax1, 'get_xlabel', lambda: None)()}', ylabel='{getattr(ax1, 'get_ylabel', lambda: None)()}'."
        )
        # Check second plot (histogram)
        ax2 = plots[1].axes[0] if plots[1].axes else None
        _dynamic_test(
            self,
            ax2 is not None and ax2.get_title() == "Temperature Distribution" and ax2.get_xlabel() == "Temperature (°F)" and ax2.get_ylabel() == "Frequency",
            "Histogram has correct title and axis labels.",
            f"Histogram missing or incorrect labels/titles: title='{getattr(ax2, 'get_title', lambda: None)()}', xlabel='{getattr(ax2, 'get_xlabel', lambda: None)()}', ylabel='{getattr(ax2, 'get_ylabel', lambda: None)()}'."
        )

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 practical course designed for math students to harness the power of Python for solving mathematical problems, visualizing data, and applying computational thinking to real-world scenarios. Each section blends engaging theory with hands-on challenges, focusing on mathematical applications and problem-solving. 

Explore how Python can be used to perform numerical calculations, solve algebraic equations, and automate mathematical processes.

Learn how to visualize mathematical data and functions using Python, and apply these skills to real-world mathematical problems.

Apply Python to probability, statistics, and simulation, enabling students to model uncertainty and analyze data in mathematical contexts.

Challenge: Analyze and Visualize Real-World Data

Solution