Stratégie de base: l’investissement régulier

Définition de la stratégie

Ici, nous étudions une stratégie simple, facile à mettre en œuvre sur plusieurs années et facile à faire évoluer en cas de changement de situation personnelle.

Cette stratégie consiste à investir un montant identique de 100€ chaque mois.

L’indice retenu pour l’investissement sera le « S&P500 Total Return ».

Le nombre de transaction étant limité à une par mois, cette stratégie ne prend pas en compte de frais de transactions.

Vous pouvez récupérer tout le code Python de cette étude ici:

Télécharger

Données d’étude

Nous allons regarder quels auraient été les résultats d’une telle stratégie sur les 20 dernières années. On va utiliser Python et la librairie pandas pour manipuler les données.

Pour cela on va récupérer les cours de l’indice « S&P500 Total Return » et l’historique du taux de change USD/EUR sur Yahoo Finance pour calculer les données les plus pertinentes pour nos choix d’investissement sur cet indice.

Préparation de notre programme Python

Les librairies nécessaires

Tout d’abord, dans notre programme, on va appeler les librairies suivantes:

############################################################
### IMPORTATION DES LIBRAIRIES NECESSAIRES
############################################################

import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
  • la librairie pandas pour la manipulation des données
  • yfinance pour la récupération des données sur Yahoo Finance
  • matplotlib pour nous faire de beaux graphiques de synthèse
  • quelques fonctions de datetime pour faire des manipulations sur les dates

Les données de départ

On initialise les premières variables:

############################################################
### DONNEES DE DEPART POUR LA STRATEGIE
############################################################

tick = "^SP500TR" # Ticker du SP500 (TR)
change = "USDEUR=X"  # Ticker de l'USD/EUR
historique_annees = 20
montant_mensuel = 100
start_date = datetime.now() - timedelta(days=365 * historique_annees)
end_date = datetime.now()
support = pd.DataFrame()
patrimoine = pd.DataFrame()
  • tick va nous permettre d’aller chercher les données de l’indice S&P500 (TR) surYahoo Finance
  • la variable change sera utilisé pour récupérer l’historique du taux de change sur Yahoo Finance
  • historique_annees indique que l’on va étudier cette stratégie sur les 20 dernières années
  • montant_mensuel correspond aux 100 euros que nous investirons chaque mois
  • start_date est la date de départ de l’étude, il y a 20 ans.
  • end_date est la date de fin de l’étude
  • support est le DataFrame qui contiendra les données de l’indice
  • patrimoine est le DataFrame qui contiendra les données de notre patrimoine

Les DataFrames sont des outils de la librairie pandas qui peuvent être comparés à des tableaux type excel. Ces DataFrames sont particulièrement puissants pour effectuer de nombreux calculs à l’intérieur de ces tableaux.

Les données de notre support, l’indice S&P500 (TR)

Récupération des données du S&P500 (TR) avec Yahoo Finance

Nous enregistrons les données historiques dans le DataFrame support:

# RECUPERATION DES DONNEES DU S&P500 (TR)
support[tick + "_usd"] = yf.download(tick, start=start_date, end=end_date, progress=False)["Close"]

Nous ajoutons « _usd » à la fin du nom de la colonne qui va récupérer toutes les valeurs de clôture quotidienne de l’indice.

Un index est créé en parallèle qui contient toutes les dates de l’historique pour lesquelles il y a un cours de clôture associé.

Récupération du taux de change USDEUR sur Yahoo Finance

De même, on récupère le taux de change sur 20 ans et on le stocke dans une nouvelle colonne « USDEUR » du DataFrame support:

# RECUPERATION DU TAUX USDEUR
support["USDEUR"] = yf.download(change, start=start_date, end=end_date, progress=False)["Close"]
support.dropna(inplace=True)

On retire enfin les lignes qui pourraient ne pas comporter de valeurs numériques et poser des problème lors des manipulations de données.

Calcul du S&P500 (TR) en euros

On va utiliser les données précédemment récupérées pour calculer la valeur de l’indice S&P500 (TR) en euro. On va multiplier les 2 colonnes précédentes:

# CALCUL DU S&P500 (TR) EN EUR
support[tick + "_eur"] = support[tick + "_usd"] * support["USDEUR"]

Calcul des rendements annuels équivalents

Afin de pouvoir les afficher dans nos graphiques de synthèse, nous calculons les 2 rendements de 2 indices (dollar et euro):

# CALCUL DES RENDEMENTS ANNUELS EQUIVALENTS
rdt_annuel_equivalent_usd = 100 * ( ( support[tick +"_usd"].iloc[-1] / support[tick +"_usd"].iloc[0]) ** (1 / ((support.index[-1] - support.index[0]).days / 365)) - 1)
rdt_annuel_equivalent_eur = 100 * ( ( support[tick +"_eur"].iloc[-1] / support[tick +"_eur"].iloc[0]) ** (1 / ((support.index[-1] - support.index[0]).days / 365)) - 1)

Dans le code précédent, on applique la formule de calcul du rendement annuel équivalent. Pour rappel, vous pouvez retrouver le détail du calcul dans cet article.

Calculs du recul maximum

Le recul maximum d’une courbe est une donnée cruciale. Elle indique, en pourcentage, le recul maximum d’une courbe à partir de son précédent point le plus haut.

Par exemple, un recul maximum de 55%, indique qu’à partir d’un point haut à 100, la courbe va baisser au maximum de 55% et redescendre à un point bas à 45.

Ce recul est appelé maximum car une telle baisse n’est rencontrée qu’une seule fois sur l’historique étudié.

Voici le code pour calculé les reculs maximums des indices S&P500 (TR) en dollar et en euro:

# CALCUL DES RECULS MAXIMUMS
support["sommet_usd"] = support[tick + "_usd"].cummax()
support["sommet_eur"] = support[tick + "_eur"].cummax()
support["recul_usd"] = -100 * (support["sommet_usd"] - support[tick + "_usd"]) / support["sommet_usd"]
support["recul_eur"] = -100 * (support["sommet_eur"] - support[tick + "_eur"]) / support["sommet_eur"]
support_recul_max_usd = round(support["recul_usd"].min(), 2)
support_recul_max_eur = round(support["recul_eur"].min(), 2)

Et voilà, nous avons maintenant toutes les données qui nous intéressent concernant notre support. Nous allons les utiliser dans une partie des graphiques de synthèse que nous pouvons déjà préparer.

Préparation des graphiques – partie 1/2

Nous allons créer 4 graphiques différents pour notre synthèse et afficher:

  1. L’indice S&P500 (TR) en dollars
  2. La taux de change USDEUR
  3. L’indice S&P500 (TR) en euros
  4. La progression du montant investi et de la valeur de notre investissement

Le graphique de l’indice S&P500 (TR) en dollars

On va commencer par afficher un titre global pour les 4 graphiques et afficher plusieurs informations dans le premier graphique. Voici le code:

# PREPARATION DES GRAPHIQUES DE SYNTHESE - PARTIE 1

plt.suptitle("Investissement mensuel sur le S&P500 (TR) en EUR", fontsize=14, fontweight='bold')

plt.subplot(221)
plt.plot(support[tick + "_usd"], color="royalblue")
plt.text(support.index[0], support[tick + "_usd"].iloc[-1] * 1, f"Rdt annuel équivalent: {rdt_annuel_equivalent_usd:.2f}%", 
        ha="left", va="bottom", color='black', fontweight='normal', fontsize=10)
plt.text(support.index[0], support[tick + "_usd"].iloc[-1] * .95, f"Recul max: {support_recul_max_usd:.2f}%", 
        ha="left", va="bottom", color='black', fontweight='normal', fontsize=10)
plt.legend(["S&P500 (TR) en USD"], loc=4)
plt.title("S&P500 (TR) en USD")

plt.plot() va afficher la courbe de la valeur de l’indice en dollar en prenant en abscisse les valeurs de l’index du DataFrame (les dates).

plt.text() affiche du texte, à savoir le rendemant annuel équivalent et le recul maximum de l’indice.

Voici ce que nous obtiendrons dans la synthèse:

On note déjà quelques chiffres importants:

  • un rendement annuel équivalent de 10.56%
  • un recul max de 55.25%

Le graphique du taux de change USD/EUR

Dans le second graphique, on affiche simplement le taux USD/EUR. Le code est assez simple:

plt.subplot(222)
plt.plot(support["USDEUR"], color="darkorange")
plt.legend(["USD/EUR"], loc=4)
plt.title("USD/EUR")

Voici le graphique obtenu:

Le graphique du S&P500 (TR) en euros

Sur le troisième graphique, on va indiquer l’indice S&P500 (TR) en euros. Voici le code:

plt.subplot(223)
plt.plot(support[tick + "_eur"], color="royalblue")
plt.text(support.index[0], support[tick + "_eur"].iloc[-1] * 1, f"Rendement annuel équivalent: {rdt_annuel_equivalent_eur:.2f}%", 
        ha="left", va="bottom", color='black', fontweight='normal', fontsize=10)
plt.text(support.index[0], support[tick + "_eur"].iloc[-1] * .95, f"Recul max: {support_recul_max_eur:.2f}%", 
        ha="left", va="bottom", color='black', fontweight='normal', fontsize=10)
plt.legend(["S&P500 (TR) en EUR"], loc=4)
plt.title("S&P500 (TR) en EUR")

Comme pour le premier graphique, on indiquera aussi le rendement annuel équivalent et le recul maximum.

Voici le graphique obtenu:

Calcul des données sur l’évolution du patrimoine

Nous allons maintenant utiliser le DataFrame patrimoine » pour regrouper toutes les données qui concernent notre patrimoine et nos investissements.

Tout d’abord, nous copions les cours de l’indice S&P500 (TR) en euros dans le DataFrame patrimoine. Il s’agit de l’indice sur lequel nous allons investir.

Nous allons aussi créer une colonne « montant_investi » dans laquelle nous mettrons les 100€ mensuellement investis.

Voici le code:

############################################################
### PARTIE III: EVOLUTION DU PATRIMOINE
############################################################

patrimoine[tick + "_eur"] = support[tick + "_eur"]
patrimoine["montant_investi"] = 0.0

Données sur les montants investis

Le premier jour de chaque mois dans l’index, nous mettrons la valeur de 100€ dans la colonne « montant_investi.

Aussi, nous calculons le montant total investi:

# INDICATION DES MONTANTS INVESTIS DANS LE DATAFRAME PATRIMOINE
patrimoine["year"] = patrimoine.index.year
patrimoine["month"] = patrimoine.index.month
first_days = patrimoine.groupby(["year", "month"]).head(1).index
patrimoine.loc[patrimoine.index.isin(first_days), "montant_investi"] = montant_mensuel
patrimoine["montant_total_investi"] = patrimoine["montant_investi"].cumsum()

La valeur de nos investissements

Nous calculons la valeur de nos investissements en prenant en compte une notion de quantité d’indice que nous aurions acheté. Tout comme, on parlerait de quantité d’ETF.

Ensuite on peut calculer la valeur de nos investissement en cumulant les quantités achetées et en les multipliant par le dernier cours de l’indice:

# CALCUL DE LA VALEUR DE NOS INVESTISSEMENTS MENSUELS
patrimoine["qtt_support"] = patrimoine["montant_investi"] / patrimoine[tick + "_eur"]
patrimoine["valeur_investissement"] = patrimoine["qtt_support"].cumsum() * patrimoine[tick + "_eur"]

Le rendement annuel équivalent de nos investissements

Dans cet stratégie, nous investissons à de nombreux moments différents: à chaque début de mois sur 20 ans. Nous réalisons donc 240 achats sur 20 ans.

Nous voulons déterminer à quel taux, il aurait fallut placer tous ces investissements qui se font à des dates différentes pour obtenir la même valeur que celle de nos investissements dans le S&P500 (TR).

Les calculs pour l’obtenir sont les suivants:

# CALCUL DU RENDEMENT ANNUEL EQUIVALENT DE TOUS NOS INVESTISSEMENTS
patrimoine["nb_annees"] = (patrimoine.index[-1] - patrimoine.index).days / 365
patrimoine["rendement"] = 100 * ((patrimoine[tick + "_eur"].iloc[-1] / patrimoine[tick + "_eur"]) ** (1 / ( patrimoine["nb_annees"]  ) ) - 1)
rendement_patrimoine = (patrimoine["nb_annees"] * patrimoine["qtt_support"] * patrimoine["rendement"]).sum() / (patrimoine["nb_annees"] * patrimoine["qtt_support"]).sum()

Le recul maximum de notre investissement

Comme pour les indices, nous voulons aussi connaître le recul maximum de nos investissements. Voici le code qui fait les calculs:

# CALCUL DU RECUL MAXIMUM DE LA VALEUR DE NOTRE INVESTISSEMENT
patrimoine["valeur_investissement_sommet"] = patrimoine["valeur_investissement"].cummax()
patrimoine["recul_investissement"] = - 100 * ( patrimoine["valeur_investissement_sommet"] - patrimoine["valeur_investissement"] ) / patrimoine["valeur_investissement_sommet"]
patrimoine_recul_max = round(patrimoine["recul_investissement"].min(), 2)

Calcul des valeur importantes à la fin des 20 ans

A la fin de notre stratégie, nous voulons connaître:

  • le montant total investi
  • la valeur de tous les investissements réalisés pendant 20 ans

Voici le code des calculs:

# CALCUL DES VALEURS FINALES DU MONTANT INVESTI ET DE NOS INVESTISSEMENTS
investissement_final = patrimoine["valeur_investissement"].iloc[-1]
montant_investi_final = patrimoine["montant_total_investi"].iloc[-1]

Nous disposons maintenant de toutes les données nécessaires pour terminer nos graphiques et faire notre analyse.

Préparation des graphiques – partie 2/2

Il nous reste un dernier graphique à préparer mais c’est le plus important. Nous allons y afficher 2 courbes:

  • les montants investis
  • la valeur des investissements réalisés

De plus, nous allons afficher les données suivantes:

  • le rendement annuel équivalent des investissements
  • le recul max des investissements réalisés
  • le montant total investi
  • la valeur de nos investissements au bout des 20 ans
# AFFICHAGE DES 2 COURBES
# 1- LES MONTANTS INVESTIS
# 2- LA VALEUR DE NOS INVESTISSEMENTS

plt.subplot(224)
plt.plot(patrimoine["montant_total_investi"], color='royalblue')
plt.plot(patrimoine["valeur_investissement"], color='green')
plt.text(patrimoine.index[0], patrimoine["valeur_investissement"].iloc[-1] * .8, f"Rendement annuel équivalent: {rendement_patrimoine:.2f}%", 
        ha="left", va="bottom", color='green', fontweight='normal', fontsize=10)
plt.text(patrimoine.index[0], patrimoine["valeur_investissement"].iloc[-1] * .75, f"Recul max de l'investissement: {patrimoine_recul_max:.2f}%", 
        ha="left", va="bottom", color='red', fontweight='normal', fontsize=10)
plt.text(patrimoine.index[-1] - 0.05 * timedelta(days = (patrimoine.index[-1] - patrimoine.index[0]).days), investissement_final * 1.0,
        f"{investissement_final:,.0f}€", 
        ha="right", va="top", color='green', fontweight='bold', fontsize=10)
plt.text(patrimoine.index[-1] - 0.00 * timedelta(days = (patrimoine.index[-1] - patrimoine.index[0]).days), montant_investi_final * 1.05,
        f"{montant_investi_final:,.0f}€", 
        ha="right", va="bottom", color='royalblue', fontweight='bold', fontsize=10)
plt.legend(["Montant investi", "Valeur de l'investissement"], loc=2)
plt.title("Investissement mensuel sur le S&P500 (TR) en EUR")

plt.show()

Le code est un peu plus dense. Il sert principalement à positionner correctement l’ensemble des données à afficher.

les graphiques de synthèse de la stratégie

En exécutant ce script Python, voici l’affichage que nous obtenons:

Conclusions de cette étude

Sur le dernier graphique, nous pouvons lire les informations importantes suivantes:

  • le rendement annuel équivalent est de 14.91%
  • le recul max est de -33.03%
  • en 20 ans, l’investisseur aura acheté pour 24 000€
  • l’investissement réalisé aura atteint la valeur de 121 207€ au bout de 20 ans

Bien que ces résultats semblent très bons, nous devons rester vigilants et donner un peu plus de détail sur ces 4 points.

Le rendement annuel équivalent de nos investissements

Le rendement calculé de nos investissements (14.91%) est supérieur au rendement calculé de notre indice (11.69%) sur lequel nous investissons.

Cela signifie que pendant la plupart du temps pendant les 20 ans, le cours de l’indice était inférieur à la courbe de progression théorique de 11.69%. De nombreux achats ont pu être réalisé à des cours relativement bas.

Nous voyons que sur les dernières années de la stratégie, le cours de l’indice a fortement progressé. Cette progression a fait monter le rendement de l’indice mais a aussi davantage augmenté le rendement des achats réalisés aux prix relativement bas.

Le recul maximum de nos investissements

Le recul maximum est seulement de -33.03% alors que celui de l’indice S&P500 (TR) en euros atteint -51.29%.

Acheter régulièrement un montant fixe permet de moyenner notre prix d’achat et nous évite d’acheter à un point haut.

Cette stratégie est connu pour limiter la valeur du recul maximum et limiter le stress psychologique qui peut en découler.

la première partie de la stratégie

En regardant de plus près l’évolution de l’indice entre 2005 et 2013, on note que sa progression est très modérée. D’ailleurs la courbe du montant investi et de la valeur de nos investissements se superposent et se croisent plusieurs fois.

Il faut être confiant pour persévérer dans une telle stratégie pendant plusieurs années qui ne rapporte pas énormément.

Les avantages de cette stratégie

Cette stratégie permet de constituer progressivement un patrimoine financier, tout en atténuant les risques de baisses importantes, sans néanmoins les annuler.

L’investisseur pourra aussi décider de faire évoluer ses investissements mensuels selon l’évolution de sa situation personnelle.

Mise en place de cette stratégie

Pour mettre en place une telle stratégie, il faut acheter un ETF qui suit le S&P500 et du type « Accumulation ». Le type « Accumulation » indique qu’il ne verse pas les dividendes mais les réinvestis dans l’indice.

Investir dans un ETF de type « Accumulation » revient donc à suivre l’indice « Total Return ».

N’hésitez pas à me laisser des remarques ou questions en commentaires.

Leave a Reply

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *