Moving averages are widely used in financial analysis to smooth out short-term fluctuations and highlight longer-term trends in price data. By averaging a set number of past data points, a moving average helps you see the underlying direction of a financial time series, making it easier to identify trends and potential turning points. This is especially useful when analyzing volatile markets, as it reduces noise and provides a clearer picture of price movement. The **simple moving average** (SMA) is the most basic type, calculated by taking the mean of a fixed window of consecutive data points as you move through the series.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Patch plt.show to avoid displaying plots during tests
        self._original_show = plt.show
        plt.show = lambda *args, **kwargs: None
        self.user_code = importlib.import_module("user_code")

    def tearDown(self):
        plt.show = self._original_show

    def test_window_size_too_small(self):
        importlib.reload(self.user_code)
        prices = [100, 101, 102]
        window = 0
        raised = False
        try:
            self.user_code.plot_moving_average(prices, window)
        except ValueError as e:
            raised = True
        _dynamic_test(
            self,
            raised,
            "Correctly raises ValueError for window size < 1",
            "Did not raise ValueError for window size < 1",
        )

    def test_window_size_too_large(self):
        importlib.reload(self.user_code)
        prices = [100, 101, 102]
        window = 5
        raised = False
        try:
            self.user_code.plot_moving_average(prices, window)
        except ValueError as e:
            raised = True
        _dynamic_test(
            self,
            raised,
            "Correctly raises ValueError for window size > len(prices)",
            "Did not raise ValueError for window size > len(prices)",
        )

    def test_sma_values_and_none_placeholders(self):
        importlib.reload(self.user_code)
        prices = [10, 20, 30, 40, 50]
        window = 3
        # We'll patch plt.plot to capture the y values for SMA
        plotted = {"prices": None, "sma": None}
        orig_plot = plt.plot
        def fake_plot(y, *args, **kwargs):
            # First call: prices, second call: SMA
            if plotted["prices"] is None:
                plotted["prices"] = y
            else:
                plotted["sma"] = y
            return orig_plot(y, *args, **kwargs)
        plt.plot = fake_plot
        try:
            self.user_code.plot_moving_average(prices, window)
        finally:
            plt.plot = orig_plot
        expected_sma = [None, None, 20.0, 30.0, 40.0]
        _dynamic_test(
            self,
            plotted["sma"] == expected_sma,
            f"Correct SMA values: {expected_sma}",
            f"Incorrect SMA values: expected {expected_sma}, got {plotted['sma']}",
        )
        _dynamic_test(
            self,
            plotted["prices"] == prices,
            f"Original prices plotted correctly",
            f"Original prices not plotted correctly: expected {prices}, got {plotted['prices']}"
        )

    def test_plot_labels_and_legend(self):
        importlib.reload(self.user_code)
        prices = [100, 105, 110, 115, 120]
        window = 2
        # Patch plt functions to capture calls
        called = {"xlabel": False, "ylabel": False, "title": False, "legend": False}
        orig_xlabel = plt.xlabel
        orig_ylabel = plt.ylabel
        orig_title = plt.title
        orig_legend = plt.legend
        plt.xlabel = lambda *args, **kwargs: called.update({"xlabel": True})
        plt.ylabel = lambda *args, **kwargs: called.update({"ylabel": True})
        plt.title = lambda *args, **kwargs: called.update({"title": True})
        plt.legend = lambda *args, **kwargs: called.update({"legend": True})
        try:
            self.user_code.plot_moving_average(prices, window)
        finally:
            plt.xlabel = orig_xlabel
            plt.ylabel = orig_ylabel
            plt.title = orig_title
            plt.legend = orig_legend
        for label in ["xlabel", "ylabel", "title", "legend"]:
            _dynamic_test(
                self,
                called[label],
                f"Plot includes {label}",
                f"Plot missing {label}",
            )

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

Explore how Python empowers FinTech solutions by automating financial analysis, modeling, and data-driven decision making. This course blends practical coding with real-world finance scenarios, guiding you through essential FinTech concepts and hands-on challenges.

Learn to analyze, manipulate, and visualize financial data using Python, focusing on core FinTech data workflows.

Apply Python to assess financial risk and optimize investment portfolios using statistical and mathematical techniques.

Apply machine learning techniques to financial data for prediction, classification, and decision support in FinTech applications.

Challenge: Plot Moving Average

Solution

Challenge: Plot Moving Average

Solution