Comment calculer le VaR en 2026 (Tutoriel Python)

Introduction

Le Value at Risk (VaR) est une mesure clé en gestion des risques financiers. Il estime la perte maximale potentielle d'un portefeuille sur une période donnée (ex. : 1 jour) à un niveau de confiance spécifique (ex. : 95 % ou 99 %). Par exemple, un VaR à 95 % de 10 000 € signifie qu'il y a 5 % de chances de perdre plus de 10 000 € en une journée.

Pourquoi est-ce crucial en 2026 ? Avec la volatilité des marchés crypto, actions et obligations amplifiée par l'IA et les géopolitiques, les régulateurs comme Bâle III exigent des calculs VaR précis. Ce tutoriel beginner vous guide de A à Z en Python : méthodes paramétrique (normale), historique et Monte Carlo. Vous obtiendrez des codes complets et exécutables, des visualisations et des analogies simples (comme un 'filet de sécurité' probabiliste). À la fin, vous calculerez le VaR de n'importe quel actif. Idéal pour analystes juniors ou investisseurs personnels. (142 mots)

Prérequis

Python 3.10+ installé
Bibliothèques : numpy, pandas, scipy, matplotlib (installées via pip)
Connaissances de base en probabilités (moyenne, écart-type) et finance (rendements)
Un éditeur comme VS Code ou Jupyter Notebook

Installation des dépendances et génération de données

installation.sh

pip install numpy pandas scipy matplotlib

Installez les bibliothèques essentielles. numpy pour les calculs vectoriels, pandas pour les données tabulaires, scipy pour les stats avancées et matplotlib pour les graphiques.

Préparation des données de rendements

Avant tout calcul, générez ou chargez des rendements journaliers (returns = (prix_t - prix_{t-1}) / prix_{t-1}). Ici, nous simulons 1000 jours de rendements pour un portefeuille actions avec une moyenne de 0,1 % et volatilité 2 %, réaliste pour un indice comme le CAC40. Analogy : comme observer 1000 tirages d'une urne probabiliste.

Génération des données historiques simulées

generate_data.py

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Paramètres : 1000 jours, mu=0.001 (rendement moyen), sigma=0.02 (volatilité)
np.random.seed(42)
returns = np.random.normal(0.001, 0.02, 1000)

# Portefeuille initial de 100 000 €
initial_value = 100000
values = initial_value * np.cumprod(1 + returns)

df = pd.DataFrame({'returns': returns, 'portfolio_value': values})
print(df.head())

# Sauvegarde pour réutilisation
df.to_csv('portfolio_returns.csv', index=False)
print('Données générées et sauvées.')

Ce script génère des rendements gaussiens et calcule la valeur cumulée du portefeuille. np.cumprod accumule les rendements composés. Utilisez seed(42) pour reproductibilité. Exécutez-le une fois pour créer portfolio_returns.csv.

Méthode paramétrique : VaR sous loi normale

La méthode paramétrique assume des rendements normalement distribués. Formule : VaR = Valeur_initiale × (μ - z × σ), où z est le quantile (1,645 pour 95 %, 2,326 pour 99 %). Avantage : rapide. Limite : ignore les 'queues épaisses' des marchés réels (krachs). Analogy : comme prédire la pluie avec une moyenne météo, sans tempêtes extrêmes.

Calcul du VaR paramétrique

var_parametrique.py

import numpy as np
import pandas as pd
from scipy.stats import norm

# Chargement des données
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
initial_value = 100000

# Statistiques
mu = np.mean(returns)
sigma = np.std(returns)
print(f"Rendement moyen mu: {mu:.4f}, Volatilité sigma: {sigma:.4f}")

# Niveaux de confiance
confidence_levels = [0.95, 0.99]
for conf in confidence_levels:
    z = norm.ppf(conf)  # Quantile normal
    var = initial_value * (mu - z * sigma)
    print(f"VaR {int(conf*100)}%: {var:.2f} € (perte max attendue)")

Calcule mu et sigma empiriques, puis applique la formule VaR. norm.ppf donne le z-score. Résultat typique : VaR 95% ~2 700 €, 99% ~4 500 €. Rapide pour gros volumes.

Méthode historique : Basée sur les données passées

VaR historique trie les pertes passées et prend le quantile. Non-paramétrique : capture les extrêmes réels. Exemple : pour 95 %, triez 1000 rendements descendants et prenez le 5e pire (position 50). Avantage : simple, robuste aux non-normalités. Limite : nécessite beaucoup de données historiques.

Calcul du VaR historique

var_historique.py

import numpy as np
import pandas as pd

# Chargement
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
initial_value = 100000

# Pertes (négatives)
losses = -returns * initial_value
losses_sorted = np.sort(losses)

confidence_levels = [0.95, 0.99]
for conf in confidence_levels:
    index = int((1 - conf) * len(losses))
    var = losses_sorted[index]
    print(f"VaR historique {int(conf*100)}%: {var:.2f} €")

# Visualisation rapide
print("Top 5 pires pertes:", losses_sorted[:5])

Transforme returns en pertes, trie et sélectionne le quantile. Pour 1000 obs, 95% = index 50. Capture les vrais chocs, souvent plus conservateur que paramétrique.

Méthode Monte Carlo : Simulations prospectives

Monte Carlo simule des milliers de scénarios futurs basés sur mu/sigma. Idéal pour portefeuilles complexes. Étapes : générer paths, calculer pertes, prendre quantile. Analogy : lancer 10 000 dés pondérés pour prédire la fortune future.

Calcul du VaR Monte Carlo

var_monte_carlo.py

import numpy as np
import pandas as pd
from scipy.stats import norm

# Données empiriques
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
mu, sigma = np.mean(returns), np.std(returns)
initial_value = 100000

# Simulations : 10000 paths, 1 jour
n_simulations = 10000
sim_returns = np.random.normal(mu, sigma, n_simulations)
losses_mc = -sim_returns * initial_value
losses_mc_sorted = np.sort(losses_mc)

confidence_levels = [0.95, 0.99]
for conf in confidence_levels:
    index = int((1 - conf) * n_simulations)
    var_mc = losses_mc_sorted[index]
    print(f"VaR Monte Carlo {int(conf*100)}%: {var_mc:.2f} €")

Simule 10 000 rendements futurs, trie pertes. Similaire à historique mais prospectif. Augmentez n_simulations pour précision (loi faible des grands nombres).

Visualisation comparative des méthodes

Visualisez pour comparer. Histogramme des pertes + lignes VaR aide à valider (ex. : queues normales ?).

Graphique des VaR et distribution des pertes

visualisation_var.py

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Données
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
initial_value = 100000
losses = -returns * initial_value

plt.figure(figsize=(10, 6))
plt.hist(losses, bins=50, alpha=0.7, density=True, label='Distribution historique')

# VaR lignes
var_95 = np.percentile(losses, 5)
var_99 = np.percentile(losses, 1)
plt.axvline(var_95, color='red', linestyle='--', label=f'VaR 95%: {var_95:.0f}€')
plt.axvline(var_99, color='orange', linestyle='--', label=f'VaR 99%: {var_99:.0f}€')

plt.xlabel('Pertes (€)')
plt.ylabel('Densité')
plt.title('Distribution des pertes et seuils VaR')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
print(f'VaR 95% visuel: {var_95:.2f}€')

Histogramme + np.percentile pour VaR (équiv. historique). axvline trace les seuils. Sauvegardez avec plt.savefig('var_plot.png') pour rapports.

Bonnes pratiques

Utilisez des données réelles : Remplacez simulations par yfinance pour actions (ex. : pip install yfinance).
Backtestez : Comparez VaR prédit vs pertes réelles sur 1 an.
Multi-actifs : Passez à matrices de covariance pour portefeuilles.
Périodes adaptées : 1T pour trading, 10T pour fonds.
Réglementaire : Alignez sur 99% / 10 jours pour Bâle.

Erreurs courantes à éviter

Assume normale toujours : Marchés ont queues grasses → sous-estime VaR (utilisez historique/MC).
Oublier composés : Calculez sur returns log, pas simples pour longues périodes.
Peu de données : <500 obs → instable ; bootstrappez si besoin.
Ignorer corrélations : Pour portefeuilles, covariance obligatoire.

Pour aller plus loin

Approfondissez avec Expected Shortfall (CVaR), VaR conditionnel ou GARCH pour volatilité dynamique. Ressources : livre 'Quantitative Risk Management' de McNeil ; docs NumPy, SciPy stats. Formations pro : Learni Group Formations Finance Quant. Testez sur données Bitcoin via yfinance !

Comment calculer le Value at Risk (VaR) en 2026