When building a portfolio, understanding both the **expected return** and the **risk** (often measured by `standard deviation`) is crucial for making informed investment decisions. The **expected return** gives you an idea of what you might gain on average, while the **risk** quantifies how much the returns can vary. **Asset weights** play a fundamental role in this calculation: the proportion of your total investment allocated to each asset directly influences both the potential reward and the exposure to risk. If the weights do not sum to 1, your portfolio is either over- or under-invested, which can distort both your risk and return calculations. Ensuring proper weight allocation and accurately computing these metrics are foundational skills in portfolio management.


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

class TestTask(unittest.TestCase):
    def test_correct_metrics(self):
        import user_code
        importlib.reload(user_code)
        returns_a = [0.01, 0.02, 0.015, 0.03, 0.005]
        returns_b = [0.012, 0.018, 0.017, 0.025, 0.009]
        weight1 = 0.6
        weight2 = 0.4
        result = None
        if hasattr(user_code, 'portfolio_metrics'):
            try:
                result = user_code.portfolio_metrics(returns_a, returns_b, weight1, weight2)
            except Exception:
                result = None
        expected_return1 = np.mean(returns_a)
        expected_return2 = np.mean(returns_b)
        expected_portfolio_return = weight1 * expected_return1 + weight2 * expected_return2
        std1 = np.std(returns_a, ddof=1)
        std2 = np.std(returns_b, ddof=1)
        covariance = np.cov(returns_a, returns_b, ddof=1)[0,1]
        expected_variance = (
            (weight1 ** 2) * (std1 ** 2) +
            (weight2 ** 2) * (std2 ** 2) +
            2 * weight1 * weight2 * covariance
        )
        expected_std = np.sqrt(expected_variance)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and np.isclose(result[0], expected_portfolio_return) and np.isclose(result[1], expected_std),
            "Returns correct expected return and standard deviation for valid weights.",
            f"Expected: ({expected_portfolio_return}, {expected_std}), got: {result}",
        )

    def test_invalid_weights_valueerror(self):
        import user_code
        importlib.reload(user_code)
        returns_a = [0.01, 0.02, 0.015, 0.03, 0.005]
        returns_b = [0.012, 0.018, 0.017, 0.025, 0.009]
        weight1 = 0.7
        weight2 = 0.4
        raised = False
        if hasattr(user_code, 'portfolio_metrics'):
            try:
                user_code.portfolio_metrics(returns_a, returns_b, weight1, weight2)
            except ValueError:
                raised = True
        _dynamic_test(
            self,
            raised,
            "Raises ValueError if weights do not sum to 1.",
            "Did not raise ValueError for weights not summing to 1.",
        )

    def test_equal_length_and_numeric(self):
        import user_code
        importlib.reload(user_code)
        returns_a = [0.03, 0.02, 0.01, 0.04]
        returns_b = [0.025, 0.019, 0.013, 0.035]
        weight1 = 0.5
        weight2 = 0.5
        result = None
        if hasattr(user_code, 'portfolio_metrics'):
            try:
                result = user_code.portfolio_metrics(returns_a, returns_b, weight1, weight2)
            except Exception:
                result = None
        expected_return1 = np.mean(returns_a)
        expected_return2 = np.mean(returns_b)
        expected_portfolio_return = weight1 * expected_return1 + weight2 * expected_return2
        std1 = np.std(returns_a, ddof=1)
        std2 = np.std(returns_b, ddof=1)
        covariance = np.cov(returns_a, returns_b, ddof=1)[0,1]
        expected_variance = (
            (weight1 ** 2) * (std1 ** 2) +
            (weight2 ** 2) * (std2 ** 2) +
            2 * weight1 * weight2 * covariance
        )
        expected_std = np.sqrt(expected_variance)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and np.isclose(result[0], expected_portfolio_return) and np.isclose(result[1], expected_std),
            "Handles lists of equal length and valid numeric values.",
            f"Expected: ({expected_portfolio_return}, {expected_std}), 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: Portfolio Risk Calculator

Løsning