Understanding how a stock's price changes from one day to the next is crucial for anyone working in finance. One of the most common ways to measure these changes is by calculating **daily returns**. A daily return tells you the percentage change in a stock's price compared to the previous day's closing price. This measure helps you assess how volatile a stock is, compare performance across different assets, and even build more advanced financial models. By expressing returns as percentages, you can easily compare stocks with different price levels, making it a fundamental metric for both analysis and reporting in the world of finance.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_length_of_returns(self):
        import user_code
        importlib.reload(user_code)
        prices = [100, 102, 101, 105]
        result = user_code.calculate_daily_returns(prices)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == len(prices) - 1,
            "Returns list has correct length (one less than prices)",
            f"Expected length {len(prices)-1}, got {len(result)}",
        )

    def test_percentage_calculation_positive(self):
        import user_code
        importlib.reload(user_code)
        prices = [100, 102, 101]
        result = user_code.calculate_daily_returns(prices)
        expected = [2.0, -0.9804]
        _dynamic_test(
            self,
            isinstance(result, list) and all(abs(a-b) < 1e-4 for a, b in zip(result, expected)),
            f"Correct daily returns for [100, 102, 101]",
            f"Expected {expected}, got {result}",
        )

    def test_percentage_calculation_negative(self):
        import user_code
        importlib.reload(user_code)
        prices = [150, 100, 90]
        result = user_code.calculate_daily_returns(prices)
        expected = [-33.3333, -10.0]
        _dynamic_test(
            self,
            isinstance(result, list) and all(abs(a-b) < 1e-4 for a, b in zip(result, expected)),
            f"Correct daily returns for [150, 100, 90]",
            f"Expected {expected}, got {result}",
        )

    def test_rounding(self):
        import user_code
        importlib.reload(user_code)
        prices = [100, 100.005, 100.0001]
        result = user_code.calculate_daily_returns(prices)
        expected = [0.005, -0.0049]
        _dynamic_test(
            self,
            isinstance(result, list) and all(abs(a-b) < 1e-4 for a, b in zip(result, expected)),
            f"Daily returns rounded to four decimal places",
            f"Expected {expected}, got {result}",
        )

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: Calculate Daily Returns

Solução