Automating the evaluation of portfolio performance is a key step in modern FinTech workflows. The **Sharpe Ratio** is a foundational metric for assessing **risk-adjusted returns**, helping you compare portfolios with different risk profiles on a level playing field. By calculating the Sharpe Ratio programmatically, you can quickly determine whether a portfolio's returns justify the risks taken, and categorize its performance for better investment decision-making.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_sharpe_ratio_value(self):
        import user_code
        import numpy as np
        importlib.reload(user_code)
        returns = [0.05, 0.02, 0.04, -0.01, 0.03]
        risk_free_rate = 0.01
        expected = (np.mean(returns) - risk_free_rate) / np.std(returns)
        result = user_code.analyze_sharpe_ratio(returns, risk_free_rate)
        _dynamic_test(
            self,
            result is not None and abs(result - expected) < 1e-6,
            f"Sharpe Ratio is correctly calculated: {expected}",
            f"Sharpe Ratio calculation incorrect: expected {expected}, got {result}",
        )

    def test_category_good(self):
        import user_code
        importlib.reload(user_code)
        returns = [0.15, 0.16, 0.14, 0.17, 0.15]
        risk_free_rate = 0.01
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.analyze_sharpe_ratio(returns, risk_free_rate)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "good" in output,
            'Correctly categorizes as "good" when Sharpe Ratio > 1',
            f'Expected "good" in output, got: {output}',
        )

    def test_category_average(self):
        import user_code
        importlib.reload(user_code)
        returns = [0.02, 0.01, 0.015, 0.012, 0.011]
        risk_free_rate = 0.01
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.analyze_sharpe_ratio(returns, risk_free_rate)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "average" in output,
            'Correctly categorizes as "average" when 0 < Sharpe Ratio <= 1',
            f'Expected "average" in output, got: {output}',
        )

    def test_category_poor(self):
        import user_code
        importlib.reload(user_code)
        returns = [-0.01, 0.0, -0.02, 0.01, -0.03]
        risk_free_rate = 0.01
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.analyze_sharpe_ratio(returns, risk_free_rate)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "poor" in output,
            'Correctly categorizes as "poor" when Sharpe Ratio <= 0',
            f'Expected "poor" in output, got: {output}',
        )

    def test_zero_std(self):
        import user_code
        importlib.reload(user_code)
        returns = [0.05, 0.05, 0.05, 0.05]
        risk_free_rate = 0.05
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.analyze_sharpe_ratio(returns, risk_free_rate)
        _dynamic_test(
            self,
            result == 0,
            'Handles zero standard deviation and returns Sharpe Ratio 0',
            f'Expected Sharpe Ratio 0 for zero 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: Sharpe Ratio Analyzer

Oplossing

Challenge: Sharpe Ratio Analyzer

Oplossing