Before you take on the challenge of computing returns for multiple stocks, recall the essentials of financial time series analysis. Calculating **simple returns** involves measuring the percentage change from one closing price to the next, which helps you assess the day-to-day performance of a stock. **Log returns**, on the other hand, use the natural logarithm of price ratios and are especially useful for modeling and statistical analysis because they are time-additive and better suited for handling compounding effects. Both return types are fundamental in financial analytics and portfolio management.

import pandas as pd
import numpy as np

# Simulated daily closing prices for 5 stocks over 20 trading days
np.random.seed(42)
dates = pd.date_range("2023-01-01", periods=20, freq="B")
prices = np.cumprod(1 + np.random.normal(0.001, 0.02, (20, 5)), axis=0) * 100

df = pd.DataFrame(
    prices,
    index=dates,
    columns=["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]
)
print(df.head())

To calculate returns for each stock, you can use the `pct_change()` method from pandas to get simple returns, and apply the `np.log()` function to compute log returns. Add each result as a new column in your DataFrame, such as `"AAPL_return"` for simple returns and `"AAPL_log_return"` for log returns. This approach lets you compare both metrics side by side for every stock in your dataset.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.df = getattr(user_code, 'df', None)

    def test_simple_return_columns_exist(self):
        expected_cols = [f"{ticker}_return" for ticker in ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]]
        missing = [col for col in expected_cols if col not in self.df.columns]
        _dynamic_test(
            self,
            len(missing) == 0,
            f"All simple return columns exist: {expected_cols}",
            f"Missing simple return columns: {missing}"
        )

    def test_log_return_columns_exist(self):
        expected_cols = [f"{ticker}_log_return" for ticker in ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]]
        missing = [col for col in expected_cols if col not in self.df.columns]
        _dynamic_test(
            self,
            len(missing) == 0,
            f"All log return columns exist: {expected_cols}",
            f"Missing log return columns: {missing}"
        )

    def test_simple_return_values(self):
        for ticker in ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]:
            col = ticker
            ret_col = f"{ticker}_return"
            series = self.df[col]
            returns = self.df[ret_col]
            correct = np.allclose(returns[1:6], series.pct_change()[1:6], equal_nan=True)
            _dynamic_test(
                self,
                correct,
                f"Simple return values correct for {ticker}",
                f"Simple return values incorrect for {ticker}"
            )

    def test_log_return_values(self):
        for ticker in ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]:
            col = ticker
            log_col = f"{ticker}_log_return"
            series = self.df[col]
            log_returns = self.df[log_col]
            expected = np.log(series / series.shift(1))
            correct = np.allclose(log_returns[1:6], expected[1:6], equal_nan=True)
            _dynamic_test(
                self,
                correct,
                f"Log return values correct for {ticker}",
                f"Log return values incorrect for {ticker}"
            )

    def test_first_five_rows_printed(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        sys.stdout = f
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__
        output = f.getvalue()
        # Check that at least the first row's index (first date) is in output
        import pandas as pd
        np.random.seed(42)
        dates = pd.date_range("2023-01-01", periods=20, freq="B")
        first_date = str(dates[0].date())
        _dynamic_test(
            self,
            first_date in output,
            "First five rows of DataFrame printed",
            f"First five rows not printed or missing index: {first_date}"
        )

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

Master the essential Python skills needed for modern financial analysis. This course guides financial analysts through practical Python applications, from data manipulation and visualization to risk assessment and portfolio optimization, using real-world financial scenarios.

Learn how to use Python and pandas to structure, clean, and analyze financial data for actionable insights.

Master the art of visualizing financial data and uncovering trends using Python's powerful plotting libraries.

Apply Python to assess financial risk and optimize investment portfolios using real-world scenarios.

Challenge: Compute Returns for Multiple Stocks

Solução