Monte Carlo simulation is a powerful tool for exploring the possible outcomes of investment portfolios. In portfolio optimization, it is often used to randomly generate many different combinations of asset weights, calculate their expected returns and risks, and analyze which combinations might offer the best trade-off between risk and reward. By simulating a large number of random portfolios, you can visualize the range of achievable returns and risks, and identify efficient portfolios even before using more advanced optimization techniques.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import math
import numpy as np

class TestTask(unittest.TestCase):
    def test_returns_list_of_100(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.simulate_random_portfolios()
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 100,
            "Function returns a list of 100 portfolios",
            f"Expected 100 portfolios, got {len(result) if isinstance(result, list) else type(result)}",
        )

    def test_portfolio_dict_structure(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.simulate_random_portfolios()
        ok = True
        for i, p in enumerate(result):
            if not isinstance(p, dict):
                ok = False
                break
            for key in ["weights", "expected_return", "std_dev"]:
                if key not in p:
                    ok = False
                    break
        _dynamic_test(
            self,
            ok,
            "Each portfolio is a dictionary with correct keys",
            "Each portfolio should be a dict with keys: 'weights', 'expected_return', 'std_dev'",
        )

    def test_weights_sum_to_one(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.simulate_random_portfolios()
        tol = 1e-8
        ok = True
        for i, p in enumerate(result):
            weights = p.get("weights")
            if not isinstance(weights, list) or len(weights) != 3:
                ok = False
                break
            if abs(sum(weights) - 1.0) > tol:
                ok = False
                break
        _dynamic_test(
            self,
            ok,
            "All weights lists sum to 1 within tolerance",
            "Each weights list must sum to 1 (within tolerance)",
        )

    def test_expected_return_correct(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.simulate_random_portfolios()
        asset_returns = [0.08, 0.12, 0.15]
        tol = 1e-8
        ok = True
        for i, p in enumerate(result):
            weights = p.get("weights")
            expected = p.get("expected_return")
            if not (isinstance(weights, list) and len(weights) == 3 and isinstance(expected, float)):
                ok = False
                break
            calc = sum(w * r for w, r in zip(weights, asset_returns))
            if abs(calc - expected) > tol:
                ok = False
                break
        _dynamic_test(
            self,
            ok,
            "All expected_return values match dot product of weights and asset_returns",
            "Each expected_return must match dot(weights, asset_returns) within tolerance",
        )

    def test_std_dev_correct(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.simulate_random_portfolios()
        asset_stdsq = [0.10**2, 0.15**2, 0.20**2]
        tol = 1e-8
        ok = True
        for i, p in enumerate(result):
            weights = p.get("weights")
            std_dev = p.get("std_dev")
            if not (isinstance(weights, list) and len(weights) == 3 and isinstance(std_dev, float)):
                ok = False
                break
            calc = math.sqrt(sum((w ** 2) * v for w, v in zip(weights, asset_stdsq)))
            if abs(calc - std_dev) > tol:
                ok = False
                break
        _dynamic_test(
            self,
            ok,
            "All std_dev values match weighted std formula",
            "Each std_dev must match sqrt(sum(w^2 * var)) within tolerance",
        )

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: Simulate Random Portfolios

Рішення