Before you begin working on portfolio risk, it is important to recap what **Value at Risk (VaR)** represents in finance. **VaR** is a widely used risk measure that estimates the maximum potential loss of a portfolio over a specific time frame, given a certain probability level. The historical method for calculating **VaR** uses actual past returns to determine the loss threshold that will not be exceeded with a given confidence level. For example, a 1-day 5% VaR of `-2%` means that on 95% of days, the portfolio's loss will not be greater than 2%, but on 5% of days, losses could be worse.

import numpy as np
import pandas as pd

# Simulate 2 years of daily portfolio returns (about 504 trading days)
np.random.seed(42)
returns = np.random.normal(loc=0.0005, scale=0.012, size=504)
dates = pd.date_range(start="2022-01-01", periods=504, freq="B")
portfolio_returns = pd.DataFrame({"returns": returns}, index=dates)

print(portfolio_returns.head())

To calculate multiple VaR thresholds, such as the 1% and 5% daily VaR, you need to determine the appropriate quantiles from the historical returns distribution. Visualizing these VaR levels on a histogram helps you see where the most extreme losses fall relative to the rest of the data. By plotting the returns and marking the VaR thresholds, you can better communicate the risk profile of the portfolio.


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
import pandas as pd
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare a known set of returns for reproducibility
        np.random.seed(42)
        self.returns = np.random.normal(loc=0.0005, scale=0.012, size=504)
        self.dates = pd.date_range(start="2022-01-01", periods=504, freq="B")
        self.portfolio_returns = pd.DataFrame({"returns": self.returns}, index=self.dates)
        # Calculate expected VaR values
        self.expected_var_1 = np.percentile(self.returns, 1)
        self.expected_var_5 = np.percentile(self.returns, 5)

    def test_var_1_percentile(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to avoid displaying the plot
        plt_show_backup = plt.show
        plt.show = lambda *args, **kwargs: None
        # Capture print output
        buf = io.StringIO()
        sys_stdout_backup = sys.stdout
        sys.stdout = buf
        user_code.compute_and_plot_var(self.portfolio_returns)
        sys.stdout = sys_stdout_backup
        plt.show = plt_show_backup
        output = buf.getvalue()
        # Check if 1% VaR value is in output (rounded to 4 decimals)
        expected_str = f"1-day 1% historical VaR: {self.expected_var_1:.4f}"
        _dynamic_test(
            self,
            expected_str in output,
            "Correct 1-day 1% VaR value is printed in interpretation",
            f"Expected line '{expected_str}' in output, got: {output}",
        )

    def test_var_5_percentile(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to avoid displaying the plot
        plt_show_backup = plt.show
        plt.show = lambda *args, **kwargs: None
        # Capture print output
        buf = io.StringIO()
        sys_stdout_backup = sys.stdout
        sys.stdout = buf
        user_code.compute_and_plot_var(self.portfolio_returns)
        sys.stdout = sys_stdout_backup
        plt.show = plt_show_backup
        output = buf.getvalue()
        expected_str = f"1-day 5% historical VaR: {self.expected_var_5:.4f}"
        _dynamic_test(
            self,
            expected_str in output,
            "Correct 1-day 5% VaR value is printed in interpretation",
            f"Expected line '{expected_str}' in output, got: {output}",
        )

    def test_histogram_plot_and_lines(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to avoid displaying the plot
        plt_show_backup = plt.show
        plt.show = lambda *args, **kwargs: None
        # Clear previous figures
        plt.close('all')
        user_code.compute_and_plot_var(self.portfolio_returns)
        # Check if a figure was created with a histogram and both VaR lines
        figs = [plt.figure(n) for n in plt.get_fignums()]
        _dynamic_test(
            self,
            len(figs) > 0,
            "A histogram plot is created",
            "No plot was created by the function",
        )
        # Check for axvline at correct locations
        found_var_1 = False
        found_var_5 = False
        for fig in figs:
            for ax in fig.axes:
                for line in ax.get_lines():
                    x = line.get_xdata()
                    if np.isclose(x[0], self.expected_var_1, atol=1e-4):
                        found_var_1 = True
                    if np.isclose(x[0], self.expected_var_5, atol=1e-4):
                        found_var_5 = True
        _dynamic_test(
            self,
            found_var_1,
            "1% VaR line is plotted on the histogram",
            f"1% VaR line at {self.expected_var_1:.4f} not found on plot",
        )
        _dynamic_test(
            self,
            found_var_5,
            "5% VaR line is plotted on the histogram",
            f"5% VaR line at {self.expected_var_5:.4f} not found on plot",
        )
        plt.show = plt_show_backup

    def test_interpretation_statement(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to avoid displaying the plot
        plt_show_backup = plt.show
        plt.show = lambda *args, **kwargs: None
        # Capture print output
        buf = io.StringIO()
        sys_stdout_backup = sys.stdout
        sys.stdout = buf
        user_code.compute_and_plot_var(self.portfolio_returns)
        sys.stdout = sys_stdout_backup
        plt.show = plt_show_backup
        output = buf.getvalue()
        # Look for interpretation sentence
        has_1 = "1% chance" in output or "1 percent" in output
        has_5 = "5% chance" in output or "5 percent" in output
        has_loss = "lose more than" in output or "loss will be more than" in output
        _dynamic_test(
            self,
            has_1 and has_5 and has_loss,
            "Interpretation statement includes correct explanation for both VaR levels",
            f"Interpretation statement missing or incomplete: {output}",
        )

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 Portfolio VaR

Soluzione