In real-world trading, visualizing moving averages and their crossovers can help you spot potential **buy** or **sell** signals. You will work with a hardcoded set of closing prices, calculate two moving averages, and plot both together. Your goal is to clearly mark every point where the short-term average (`3-day`) crosses above or below the long-term average (`5-day`), highlighting possible trading signals.

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Hardcoded closing prices for 15 days
data = {
    "date": pd.date_range("2024-01-01", periods=15, freq="D"),
    "close": [100, 102, 101, 105, 108, 110, 107, 106, 108, 109, 111, 113, 112, 114, 115]
}
df = pd.DataFrame(data)
df.set_index("date", inplace=True)

# Calculate 3-day and 5-day simple moving averages
df["SMA_3"] = df["close"].rolling(window=3).mean()
df["SMA_5"] = df["close"].rolling(window=5).mean()

# Find crossover points
df["signal"] = 0
df["signal"][df["SMA_3"] > df["SMA_5"]] = 1
df["signal"][df["SMA_3"] < df["SMA_5"]] = -1
df["crossover"] = df["signal"].diff()

# Plotting
plt.figure(figsize=(12, 6))
plt.plot(df.index, df["close"], label="Close Price", color="black", linewidth=2)
plt.plot(df.index, df["SMA_3"], label="3-Day SMA", color="blue", linestyle="--")
plt.plot(df.index, df["SMA_5"], label="5-Day SMA", color="red", linestyle="-.")

# Mark crossover points
buy_signals = df[df["crossover"] == 2]
sell_signals = df[df["crossover"] == -2]

plt.scatter(buy_signals.index, buy_signals["close"], marker="^", color="green", s=100, label="Buy Signal (3>5)")
plt.scatter(sell_signals.index, sell_signals["close"], marker="v", color="red", s=100, label="Sell Signal (3<5)")

plt.title("Moving Average Crossover Signals")
plt.xlabel("Date")
plt.ylabel("Price")
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

**Definition:** A **moving average crossover** occurs when a short-term moving average crosses above (bullish) or below (bearish) a longer-term moving average. Traders often use these crossovers to generate buy or sell signals.

Definition

import unittest
import user_code
import ast
import re   
import importlib
import pandas as pd
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            "date": pd.date_range("2024-01-01", periods=15, freq="D"),
            "close": [100, 102, 101, 105, 108, 110, 107, 106, 108, 109, 111, 113, 112, 114, 115]
        }
        self.df = pd.DataFrame(self.data)
        self.df.set_index("date", inplace=True)
        self.df["SMA_3"] = self.df["close"].rolling(window=3).mean()
        self.df["SMA_5"] = self.df["close"].rolling(window=5).mean()
        # Prepare expected signals
        self.df["signal"] = 0
        self.df.loc[self.df["SMA_3"] > self.df["SMA_5"], "signal"] = 1
        self.df.loc[self.df["SMA_3"] < self.df["SMA_5"], "signal"] = -1
        self.df["crossover"] = self.df["signal"].diff()
        self.buy_indices = self.df[self.df["crossover"] == 2].index.tolist()
        self.sell_indices = self.df[self.df["crossover"] == -2].index.tolist()
        self.expected_sma3 = self.df["SMA_3"].tolist()
        self.expected_sma5 = self.df["SMA_5"].tolist()

    def _nan_tolerant_allclose(self, arr1, arr2, rtol=1e-8, atol=1e-8):
        # Both arrays must be the same length
        if len(arr1) != len(arr2):
            return False
        for a, b in zip(arr1, arr2):
            if (a is None or (isinstance(a, float) and np.isnan(a))) and (b is None or (isinstance(b, float) and np.isnan(b))):
                continue
            if (a is None or (isinstance(a, float) and np.isnan(a))) != (b is None or (isinstance(b, float) and np.isnan(b))):
                return False
            if not np.isclose(a, b, rtol=rtol, atol=atol):
                return False
        return True

    def test_sma3_correct(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, "df", None)
        _dynamic_test(
            self,
            isinstance(df, pd.DataFrame) and "SMA_3" in df.columns,
            "3-day SMA column exists in DataFrame.",
            "3-day SMA column missing in DataFrame."
        )
        actual = df["SMA_3"].tolist()
        _dynamic_test(
            self,
            self._nan_tolerant_allclose(actual, self.expected_sma3),
            "3-day SMA values are correct.",
            f"Expected 3-day SMA: {self.expected_sma3}, got: {actual}"
        )

    def test_sma5_correct(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, "df", None)
        _dynamic_test(
            self,
            isinstance(df, pd.DataFrame) and "SMA_5" in df.columns,
            "5-day SMA column exists in DataFrame.",
            "5-day SMA column missing in DataFrame."
        )
        actual = df["SMA_5"].tolist()
        _dynamic_test(
            self,
            self._nan_tolerant_allclose(actual, self.expected_sma5),
            "5-day SMA values are correct.",
            f"Expected 5-day SMA: {self.expected_sma5}, got: {actual}"
        )

    def test_buy_sell_crossover_indices(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, "df", None)
        _dynamic_test(
            self,
            isinstance(df, pd.DataFrame) and "crossover" in df.columns,
            "Crossover column exists in DataFrame.",
            "Crossover column missing in DataFrame."
        )
        buy_indices = df[df["crossover"] == 2].index.tolist()
        sell_indices = df[df["crossover"] == -2].index.tolist()
        _dynamic_test(
            self,
            buy_indices == self.buy_indices,
            "Buy signal crossover indices are correct.",
            f"Expected buy indices: {self.buy_indices}, got: {buy_indices}"
        )
        _dynamic_test(
            self,
            sell_indices == self.sell_indices,
            "Sell signal crossover indices are correct.",
            f"Expected sell indices: {self.sell_indices}, got: {sell_indices}"
        )

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 hands-on course designed for traders who want to leverage Python to analyze financial data, build trading strategies, and visualize market trends. This course combines practical coding tasks with real-world trading scenarios, focusing on how Python can be used to solve common problems faced by traders.

Learn how to use Python to analyze and manipulate financial data, focusing on the needs of traders. This section covers data structures, basic calculations, and essential data wrangling techniques.

Master the art of visualizing financial data and trading indicators using Python's plotting libraries. Learn to create insightful charts that help traders make informed decisions.

Apply Python to develop, backtest, and evaluate basic trading strategies. Learn to use key performance metrics and risk measures relevant to traders.

Challenge: Signal Visualization with Moving Averages

Solution