Séance 4 - Bases de python pour le trading

Les bases de Python appliquées au trading algorithmique incluent des concepts clés comme les structures
de contrôle, les fonctions, et la programmation orientée objet (POO). Ces composantes sont essentielles
pour construire des algorithmes performants et organiser le code de manière cohérente et réutilisable.
Cette séance met l'accent sur la façon d'utiliser ces éléments pour répondre aux besoins de l'analyse
financière et du trading, permettant ainsi de développer des solutions modulaires et efficaces.

1. Introduction aux structures de contrôle en python

Les structures de contrôle sont à la base de la logique des programmes en Python et permettent de
prendre des décisions en fonction de certaines conditions ou de répéter des opérations jusqu'à ce qu'une
certaine condition soit remplie. Dans le cadre du trading algorithmique, elles sont particulièrement
importantes car elles permettent d'implémenter les stratégies basées sur des règles conditionnelles : par
exemple, acheter une action si son prix dépasse un certain seuil ou vendre si une autre condition est
remplie.

Dans cette section, nous explorerons les principales structures de contrôle en Python, telles que les
conditions (if, elif, else) et les boucles (for, while).

1.1. La structure conditionnelle

En programmation, les structures conditionnelles sont des outils essentiels qui permettent de prendre des
décisions automatiques en fonction de certaines conditions. Dans le contexte du trading algorithmique, les
structures conditionnelles permettent de définir des règles de décision pour acheter, vendre, ou conserver
un actif en fonction de différents critères (comme le prix d'une action, le volume de transactions, ou des
indicateurs techniques).

Les structures conditionnelles en Python sont principalement composées de trois éléments :

 if : Permet de vérifier si une condition est vraie et, si oui, d'exécuter un bloc de code spécifique.
 elif : Permet de tester plusieurs conditions de manière séquentielle si la première condition if est
fausse.
 else : Définit un cas par défaut à exécuter lorsque toutes les conditions précédentes sont fausses.

1.1.1. Structure if

La structure conditionnelle if permet d'exécuter un bloc de code uniquement si une condition donnée est
vraie. Elle est souvent utilisée pour prendre des décisions en fonction des valeurs ou des états dans les
programmes.

if condition:
# code exécuté si la condition est vraie

1
Exemple : Vérifions si le prix d'une action a baissé en dessous d'un certain seuil pour générer un signal
d'achat.

# importer les bibliothèques

import pandas as pd
import yfinance as yf
# Utiliser yfinance pour importer les cours ajustés de l'action AAPL
ticker = "AAPL" # Choisir le ticker du titre à télécharger
start = "2024-07-01" # Date de début du téléchargement
end = "2024-09-30" # Date de fin du téléchargement
interval = "1d" # Intervalle de temps souhaité
data = [Link](ticker,
start=start,
end=end,
interval=interval,
actions=False,
auto_adjust=True,
progress=False)

# Supprime le niveau d'index secondaire des colonnes du DataFrame

data = [Link](1, axis=1)

# Définir le prix d'achat et le seuil pour lancer l'ordre d'achat

prix_action = [Link][1,3]
seuil_achat = [Link]["2024-07-01", "Close"]
# Vérifier si la condition d'achat est remplie
if prix_action < seuil_achat:
print("Acheter l'action")

NB : Pour éviter des erreurs d’exécution, il est essentiel de vérifier les points suivants :

 Vérifiez que les données téléchargées contiennent des valeurs pour la date "2024-07-01" : Si cette
date est manquante dans l'index data, la ligne seuil_achat = [Link]["2024-07-01", "Close"]
renverra une erreur KeyError. Avant d’accéder à cette date, assurez-vous qu’elle existe dans
l’index du DataFrame.
 iloc[1, 3] utilise des index numériques pour accéder aux lignes et colonnes. Dans ce cas, il accède à
la deuxième ligne (index 1) et à la quatrième colonne (index 3). Si l'ordre des colonnes du
DataFrame change, cette position pourrait ne plus correspondre aux données souhaitées. Il est
souvent préférable d’utiliser l'accès par nom de colonne pour plus de clarté et de flexibilité, par
exemple prix_action = data["Close"].iloc[1] pour accéder à la colonne Close. Par ailleurs,
[Link][1, 3] suppose qu’il y a au moins deux lignes dans le DataFrame data. Si le DataFrame est
vide ou contient moins de deux lignes, une erreur d’index se produira. Pour éviter cela, il est
recommandé de vérifier la longueur du DataFrame avant d’accéder aux lignes :
 Vérification de la non-nullité de prix_action et seuil_achat : Si prix_action ou seuil_achat est None
(par exemple, en raison de données manquantes ou d’une absence de l’index), une erreur de
comparaison peut se produire. Avant d’évaluer la condition d’achat, assurez-vous que ces deux
valeurs ne sont pas None.
2
Dans la suite du cours, nous verrons comment gérer ces types d'erreurs pour rendre le code plus robuste
et éviter des interruptions lors de l'exécution.

1.1.2. Structure elif

La structure elif, qui signifie "else if" (sinon si), permet d'évaluer plusieurs conditions dans une séquence.
Si la première condition if est fausse, Python passe à la condition elif. Si la condition elif est également
fausse, elle passe au elif suivant, et ainsi de suite. Cela permet de simplifier le code en évitant d'imbriquer
plusieurs if.

if condition1:
# Code exécuté si condition1 est vraie
elif condition2:
# Code exécuté si condition2 est vraie
elif condition3:
# Code exécuté si condition3 est vraie

Exemple : Utiliser les conditions elif pour vérifier les différents niveaux de prix

# on utilise le même dataframe data

date_evaluation = "2024-07-05" # Date spécifique pour l'évaluation du prix

prix_actuel = data['Close'].loc[date_evaluation] # Obtenir le prix de clôture pour la date d'évaluation
seuil_achat = 210 # Définir le seuil d'achat
seuil_vente = 230 # Définir le seuil de vente

# Vérifier les conditions de trading

if prix_actuel < seuil_achat: # Condition d'achat si le prix est inférieur au seuil d'achat
print("Acheter, le prix est inférieur au seuil d'achat.")

elif prix_actuel > seuil_vente: # Condition de vente si le prix est supérieur au seuil de vente
print("Vendre, le prix est supérieur au seuil de vente.")

else: # Condition de conservation si le prix est entre les seuils

print("Conserver, le prix est entre les seuils d'achat et de vente.")
NB : le code est basique et peut engendrer des erreurs d’exécution. Il faut donc faire attention aux points
suivants :

 Assurez-vous que la date d'évaluation (2024-07-05) est bien présente dans les données
téléchargées. Si cette date est absente (par exemple, si elle tombe un jour de fermeture du
marché), data['Close'].loc[date_evaluation] générera une erreur KeyError.
 Si prix_actuel est None (par exemple, si la date est manquante), une erreur se produira lors de la
comparaison dans les conditions if et elif.
 Il est recommandé de s'assurer que seuil_achat est inférieur à seuil_vente. Si ce n'est pas le cas,
cela pourrait générer des signaux incohérents.

3
 1.1.3. Structure else

La structure else est utilisée à la fin d’un bloc conditionnel if...elif...else pour gérer tous les cas qui ne
correspondent à aucune des conditions précédentes. C’est une sorte de "filet de sécurité" pour capturer
toutes les possibilités non couvertes par les conditions if et elif.

if condition1:
# Code exécuté si condition1 est vraie
elif condition2:
# Code exécuté si condition2 est vraie
else:
# Code exécuté si toutes les conditions précédentes sont fausses

Exemple : Vérification de la Présence d'une valeur dans un dataframe

# Définir la date à vérifier

date_a_verifier = "2023-01-10"

# Vérifier la présence de la date dans le DataFrame

# 1. Vérifier si le DataFrame est vide
if [Link]: # .empty est une propriété qui renvoie True si le DataFrame est vide
print("Le DataFrame est vide, aucune donnée disponible.")

# 2. Si le DataFrame n'est pas vide, vérifier si la date est présente dans l'index
elif date_a_verifier in [Link]: #Vérifie si la date est dans l'index du DataFrame
print(f"La date {date_a_verifier} est présente dans le DataFrame.")

# 3. Si le DataFrame n'est pas vide mais que la date est absente

else:
print(f"La date {date_a_verifier} n'est pas présente dans le DataFrame.")

NB : Python propose une expression conditionnelle en une seule ligne, qui est parfois appelée "opérateur
ternaire". Elle est utile pour les cas simples où on souhaite affecter une valeur en fonction d'une condition.

x = -100
valeur = "Positif" if x > 0 else "Négatif"
print(f"x est un entier {valeur}")

Cela fonctionne comme un if court en une seule ligne.

1.2. Les boucles

Les boucles sont des structures de contrôle essentielles en programmation qui permettent de répéter des
actions plusieurs fois de manière automatisée. Dans le contexte du trading algorithmique, elles sont
particulièrement utiles pour parcourir et analyser des séries de données financières, comme les prix
journaliers, les volumes de transactions, ou encore les indicateurs techniques.

4
Python propose principalement deux types de boucles :

 La boucle for, qui permet de parcourir chaque élément d’une séquence (liste, dictionnaire,
DataFrame) un par un.
 La boucle while, qui exécute un bloc de code tant qu'une condition donnée est vraie, permettant
des répétitions dynamiques jusqu'à ce que l’objectif soit atteint.

1.2.1. Boucle for

La boucle for est utilisée pour parcourir les éléments d'une séquence, comme une liste, un dictionnaire ou
une série temporelle. En trading, la boucle for est particulièrement pratique pour analyser les données de
prix sur plusieurs jours et calculer des métriques financières (par exemple, rendement journalier,
moyenne mobile, ou volatilité).

for element in sequence:

# Code exécuté pour chaque élément de la séquence
Dans la boucle for, chaque élément de la séquence est traité un par un. Cela permet de répéter une action
pour chaque élément de la séquence, qu'il s'agisse d'une liste de prix ou de dates.

Exemple : Extraction des Dates avec Signal d'Achat

# Initialiser une colonne pour les signaux d'achat avec des valeurs par défaut à False
data['Signal_Achat'] = False

# Boucle pour détecter une baisse de trois jours consécutifs

for i in range(2, len(data)): # Démarre à 2 pour vérifier trois jours en arrière
date = [Link][i]

# Vérifier si le prix a baissé pendant trois séances consécutives

if data['Close'].iloc[i] < data['Close'].iloc[i - 1] < data['Close'].iloc[i - 2]:
[Link][date , 'Signal_Achat'] = True # Enregistrer le signal d'achat pour la troisième baisse
successive

else:
[Link][date , 'Signal_Achat'] = False # Aucun signal si les conditions de baisse successive ne sont pas
remplies

# Extraire les dates où Signal_Achat est True et les stocker dans une Series
dates_achat = [Link][data['Signal_Achat']].to_series()

# Afficher les dates d'achat

print("Dates avec signal d'achat :")
print(dates_achat)

1.2.2. Boucle while

5
La boucle while exécute un bloc de code tant qu'une condition donnée est vraie. Contrairement à la boucle
for, qui parcourt une séquence d'éléments, la boucle while continue de répéter les instructions jusqu'à ce
que la condition devienne fausse. Elle est particulièrement utile dans les situations où on ne connaît pas
d'avance le nombre d'itérations nécessaires, par exemple dans des simulations de prix ou des seuils de
sortie.

while condition:
# Code exécuté tant que la condition est vraie

Exemple : Simulation d'un Investissement

# Initialisation des variables

solde = 1000 # Montant initial de l'investissement
objectif = 2000 # Objectif à atteindre
taux_rendement = 0.05 # Rendement annuel (5%)
annees = 0 # Compteur pour les années

# Boucle pour calculer la croissance de l'investissement

while solde < objectif:
solde += solde * taux_rendement # Ajouter le rendement annuel au solde
annees += 1 # Incrémenter le compteur d'années

# Afficher les résultats

print(f"Nombre d'années pour atteindre l'objectif : {annees} années")
print(f"Solde final : {solde:.2f}")

2. Fonctions en python

Les fonctions en Python représentent un élément fondamental de la programmation, permettant de créer

des blocs de code réutilisables qui réalisent une tâche spécifique. Elles sont utiles pour structurer le code,
éviter la répétition, et faciliter la maintenance. En combinant des fonctions avec des classes et d'autres
concepts de programmation, on peut développer des scripts clairs et modulaires, bien adaptés aux besoins
d'analyses financières et de développement d'algorithmes de trading.

2.1. Définition et utilité des fonctions

Les fonctions en Python sont des blocs de code réutilisables qui exécutent une tâche spécifique. Elles
permettent d'organiser et de structurer le code pour éviter la répétition et améliorer la lisibilité. Les
fonctions facilitent la clarté du code et sa maintenance, puisqu’elles permettent de centraliser des calculs
spécifiques.

Les fonctions en Python utilisent souvent des paramètres, qui sont des variables spécifiées entre
parenthèses lorsque la fonction est définie. Ces paramètres permettent de passer des valeurs à la fonction,
rendant son utilisation plus flexible et adaptée à différentes situations.

2.2. Exemples de fonctions intégrées en Python et paramètres

6
Python propose plusieurs fonctions intégrées qui couvrent une large gamme d'applications, et chacune
d'elles peut recevoir des paramètres pour adapter son comportement :

 len() : Cette fonction prend un paramètre, un objet tel qu'une liste, un tuple, ou une chaîne de
caractères, et renvoie sa longueur. Par exemple, len([1, 2, 3]) renverra 3.
 max() : Cette fonction accepte un paramètre qui peut être une liste, un tuple ou un autre type de
collection. Elle retourne la valeur maximale de la collection. Par exemple, max([4, 7, 1]) renverra 7.
 sum() : Cette fonction prend un paramètre, qui est un itérable (liste, tuple, etc.), et renvoie la
somme de tous les éléments. Par exemple, sum([10, 20, 30]) renverra 60.
 round() : Cette fonction prend un nombre à arrondir et peut également recevoir un deuxième
paramètre facultatif pour préciser le nombre de décimales souhaité. Par exemple, round(3.14159,
2) renverra 3.14.

2.3. Création d'une fonction

Pour créer une fonction en Python, vous utilisez le mot-clé def, suivez-le du nom de la fonction, des
parenthèses (avec ou sans paramètres), puis des deux-points. Ensuite, indentez le code à l'intérieur de la
fonction pour définir ce qu'elle doit faire.

def ma_fonction(parametre):
# Instructions de la fonction
print(f"Bonjour, {parametre}!")

# Appeler la fonction
ma_fonction("Ali")

7
Exemple : Fonction pour Calculer le Rendement Espéré d’un Titre

Le modèle de Markowich propose l’utilisation de la moyenne des rendements historiques d’un titre
comme la mesure de son rendement espéré.

Nous allons utiliser des données mensuelles sur une période de 5 ans.

import pandas as pd
import yfinance as yf

def rendement_espere_historique(ticker, start, end):

"""
Calcule le rendement espéré d'un titre comme la moyenne des rendements mensuels historiques sur 5
ans.

Parameters:
ticker (str): Symbole de l'action (ex. "AAPL")
start (str): Date de début de la période (format "YYYY-MM-DD")
end (str): Date de fin de la période (format "YYYY-MM-DD")

Returns:
float: Rendement espéré historique basé sur les rendements mensuels
"""
# Télécharger les données mensuelles de l'action
data = [Link](ticker, start=start, end=end, interval="1mo")

# Calculer les rendements mensuels

data['Rendement_Mensuel'] = data['Close'].pct_change()

# Calculer le rendement espéré comme la moyenne des rendements mensuels

rendement_espere = data['Rendement_Mensuel'].mean()

return rendement_espere

# Exemple d'utilisation
ticker = "AAPL" # Symbole de l'action
start = "2019-01-01" # Date de début pour une période de 5 ans
end = "2024-01-01" # Date de fin pour la période de 5 ans

rendement_moyen = rendement_espere_historique(ticker, start, end)

print(f"\nRendement espéré historique (mensuel) pour {ticker} sur 5 ans : {rendement_moyen:.4%}")

8
Exemple : Fonction pour Calculer le Risque Total d’un Titre

Le risque total d’un titre est calculé par son écart-type de rendement, ce qui donne une mesure de la
volatilité du titre.

import yfinance as yf
import numpy as np

def risque_titre_historique(ticker, start, end):

"""
Calcule le risque total d'un titre comme l'écart-type des rendements mensuels historiques sur 5 ans.

Parameters:
ticker (str): Symbole de l'action (ex. "AAPL")
start (str): Date de début de la période (format "YYYY-MM-DD")
end (str): Date de fin de la période (format "YYYY-MM-DD")

Returns:
float: Risque total basé sur la volatilité mensuelle des rendements
"""
# Télécharger les données mensuelles de l'action
data = [Link](ticker, start=start, end=end, interval="1mo")

# Calculer les rendements mensuels

data['Rendement_Mensuel'] = data['Close'].pct_change()

# Calculer le risque total comme l'écart-type des rendements mensuels

risque_total = data['Rendement_Mensuel'].std()

return risque_total

# Exemple d'utilisation
ticker = "AAPL" # Symbole de l'action
start = "2019-01-01" # Date de début pour une période de 5 ans
end = "2024-01-01" # Date de fin pour la période de 5 ans

risque = risque_titre_historique(ticker, start, end)

print(f"\nRisque total (volatilité mensuelle) pour {ticker} sur 5 ans : {risque:.4%}")

2.4. Exercice

Coder une fonction qui permet de calculer le coefficient de corréltion des titres d’un portefeuille en
utilisant les données historiques mensuels sur 5 ans.

9
 3. Introduction aux classes

Les classes sont au cœur de la programmation orientée objet (POO), un paradigme de développement qui
permet de structurer des programmes en créant des objets reflétant des entités du monde réel. Une classe
agit comme un "gabarit" ou "blueprint" pour ces objets, définissant leurs attributs et leurs méthodes. En
finance, l'utilisation de classes permet de modéliser des titres financiers, des portefeuilles ou des
stratégies de trading de manière intuitive et modulaire, facilitant la réutilisation du code et l'organisation
des projets complexes.

3.1. Concept de programmation orientée objet

La programmation orientée objet (POO) est une méthode de structuration du code qui organise les
programmes en objets, chacun représentant une "entité" ou un "concept" du monde réel. Ces objets
possèdent :

 des caractéristiques (appelées attributs)

 et des actions (appelées méthodes).

Ce paradigme est particulièrement utile pour modéliser des systèmes complexes, comme les marchés
financiers, où chaque titre, portefeuille ou transaction peut être représenté comme un objet.

En POO, chaque objet est une instance d'une classe. Une classe est un "gabarit" ou un "blueprint" qui
définit les attributs et les méthodes d'un type d'objet donné.

Exemple 1 : La Classe DataFrame de la Bibliothèque Pandas

La classe DataFrame de la bibliothèque Pandas est une structure de données tabulaire très puissante,
largement utilisée en analyse de données et en data science. Elle ressemble à une table de base de données
ou à une feuille de calcul Excel, où les données sont organisées sous forme de lignes et de colonnes.

Une instance est un "objet" spécifique créé à partir d'une classe. Pour créer une instance de la classe
DataFrame :

import pandas as pd
# Créer un dictionnaire de données fictives
data = {"Date": ["2023-01-01", "2023-01-02", "2023-01-03", "2023-01-04", "2023-01-05"],
"Prix_Cloture": [150, 152, 148, 146, 149] }
# Créer une instance de la classe DataFrame en utilisant le dictionnaire de données
df = [Link](data) # 'df' est une instance de la classe DataFrame
df.set_index("Date", inplace=True) # Définit la colonne Date comme index du DataFrame
# Afficher le DataFrame
print(df)
print("Colonnes de l'instance df :", [Link])
print("Index de l'instance df :", [Link])
print("Dimensions de l'instance df :", [Link])
print("\nStatistiques descriptives de l'instance df :")
print([Link]()) # Affiche les statistiques de base pour chaque colonne numérique
print("\nMoyenne des prix de clôture dans l'instance df :")
print(df["Prix_Cloture"].mean()) # Calcule la moyenne de la colonne Prix_Cloture
10
Dans cet exemple :

 DataFrame : Représente la classe (le gabarit pour créer un tableau de données).

 df : Représente une instance de la classe DataFrame, créée avec les données fournies.
 Attributs de l'Instance df
o [Link] : Renvoie les noms des colonnes de l’instance df.
o [Link] : Renvoie l’index (ou les indices) de l’instance df.
o [Link] : Renvoie la dimension de l’instance df sous forme de tuple (nombre de lignes,
nombre de colonnes).
 Méthodes de l'Instance df
o df.set_index() : Méthode qui permet de définir une colonne comme index du DataFrame.
o [Link]() : Calcule des statistiques descriptives pour les colonnes numériques de
l’instance df.
o [Link]() : Calcule la moyenne des valeurs numériques dans les colonnes de l’instance df.
o [Link]() : Supprime les lignes contenant des valeurs manquantes dans l’instance df.

Exemple 2 : La Classe Ticker de la Bibliothèque yfinance

Un exemple typique de classe dans le contexte de l'analyse financière est la classe Ticker de la
bibliothèque yfinance, qui permet de modéliser chaque titre boursier (comme une action) avec ses
propres attributs et méthodes. La classe Ticker représente un titre en bourse et offre des méthodes pour
accéder à différentes informations financières sur ce titre.

import yfinance as yf

# Créer une instance de la classe Ticker pour une action donnée (par exemple, AAPL)
apple = [Link]("AAPL")

# Utiliser des méthodes pour accéder aux informations

# Accéder aux données historiques de prix

data_historique = [Link](period="5y")

# Afficher les informations générales de l'entreprise

infos = [Link]

# Accéder aux dividendes

dividendes = [Link]

# Accéder aux splits

splits = [Link]

# Afficher les données financières de l'entreprise (bilan, compte de résultat, etc.)

bilan = apple.balance_sheet

11
Dans cet exemple :

 Ticker : Représente la classe (le gabarit pour modéliser un titre boursier).

 apple : Une instance de la classe Ticker, représentant le titre "AAPL" (Apple).
 Principales Méthodes de la Classe Ticker :
o history() : Télécharge les données historiques de prix (exemple : cours, volume) sur une
période spécifiée (par exemple, "1d", "5y").
o info : Renvoie un dictionnaire avec des informations générales sur l'entreprise, telles que
sa capitalisation boursière, son secteur, son industrie, etc.
o dividends : Renvoie une série temporelle avec les dividendes versés par l’entreprise.
o splits : Renvoie une série temporelle indiquant les splits d’actions.
o balance_sheet : Renvoie le bilan de l’entreprise.
o financials : Renvoie le compte de résultat de l’entreprise.
o cashflow : Renvoie les flux de trésorerie de l'entreprise.
o earnings : Renvoie les résultats financiers de l’entreprise (bénéfice net, revenus, etc.).

3.2. Création d'une classe en python

En finance, par exemple, nous pouvons créer des classes pour modéliser des entités telles que des Titres
Financiers, des Portefeuilles, ou même des Stratégies de Trading. Cela permet de rendre le code plus
intuitif, modulaire et réutilisable. Une fois qu'une classe est définie, elle peut être utilisée plusieurs fois
pour créer plusieurs objets similaires, mais avec des données différentes.

3.2.1. Constructeur __init__

En Python, le constructeur d'une classe est une méthode spéciale appelée __init__(). Elle est utilisée pour
initialiser les attributs d'une instance de la classe lorsqu'elle est créée. Autrement dit, le constructeur
permet de spécifier les valeurs initiales des attributs de l'objet.

Le constructeur est défini à l'intérieur de la classe, et son nom est toujours __init__ (avec deux underscores
de chaque côté). Cette méthode est automatiquement appelée chaque fois qu'une nouvelle instance de la
classe est créée.

12
Exemple de création d'une classe avec des attributs uniquement :

class TitreFinancier:
def __init__(self, nom, ticker, prix_initial):
# Attributs d'instance
[Link] = nom # Nom de l'action (par exemple, 'Apple')
[Link] = ticker # Symbole boursier (par exemple, 'AAPL')
self.prix_initial = prix_initial # Prix initial de l'action
self.prix_courant = prix_initial # Prix courant (initialisé au même prix que le prix initial)

# Créer une instance de la classe TitreFinancier

apple = TitreFinancier("Apple", "AAPL", 150)

# Afficher les attributs de l'instance

print(f"Nom : {[Link]}")
print(f"Ticker : {[Link]}")
print(f"Prix initial : {apple.prix_initial}")
print(f"Prix courant : {apple.prix_courant}")
print(f"Prix courant : {apple.prix_courant}")

Dans cet exemple :

 class TitreFinancier : Définit une nouvelle classe appelée TitreFinancier.

 def __init__(self, nom, ticker, prix_initial) : Définit le constructeur de la classe. Ce constructeur
prend trois paramètres (nom, ticker, prix_initial) en plus de self. Le paramètre self fait référence à
l'instance courante de la classe et est toujours le premier paramètre d'une méthode de classe.
 [Link] = nom : Initialise l'attribut nom de l'instance avec la valeur du paramètre nom.
 [Link] = ticker : Initialise l'attribut ticker de l'instance.
 self.prix_initial = prix_initial : Initialise l'attribut prix_initial de l'instance.
 self.prix_courant = prix_initial : Initialise l'attribut prix_courant au même prix que le prix initial,
puisqu'il représente le prix au moment de la création de l'objet.

Notes Importantes :

 Le constructeur permet de garantir que chaque instance de TitreFinancier dispose de tous les
attributs nécessaires dès sa création.
 self est une référence à l'objet courant et permet d'accéder aux attributs et méthodes de la classe.

13
Exemple de création d’une classe avec attributs et méthode :

import yfinance as yf
import numpy as np
import pandas as pd

class AnalyseFinanciere:
def __init__(self, ticker, start, end):
"""
Initialise une instance pour analyser un titre financier.

Parameters:
- ticker (str): Symbole de l'action (ex. "AAPL")
- start (str): Date de début de la période (format "YYYY-MM-DD")
- end (str): Date de fin de la période (format "YYYY-MM-DD")
"""
[Link] = ticker
[Link] = start
[Link] = end
[Link] = self._get_data()

def _get_data(self):
"""
Télécharge les données historiques de prix à partir de yfinance.
"""
data = [Link]([Link], start=[Link], end=[Link], interval="1mo")
return data

def calcul_rendement_espere(self):
"""
Calcule le rendement espéré d'un titre comme la moyenne des rendements mensuels historiques.

Returns:
- float: Rendement espéré historique basé sur les rendements mensuels
"""
[Link]['Rendement_Mensuel'] = [Link]['Close'].pct_change()
rendement_espere = [Link]['Rendement_Mensuel'].mean()
return rendement_espere

def calcul_risque(self):
"""
Calcule le risque total d'un titre comme l'écart-type des rendements mensuels historiques.

Returns:
- float: Risque total basé sur la volatilité mensuelle des rendements
"""
risque_total = [Link]['Rendement_Mensuel'].std()
return risque_total

def calcul_beta(self, indice_benchmark_ticker):

"""

14
 Calcule le bêta du titre par rapport à un indice de référence.

Parameters:
- indice_benchmark_ticker (str): Symbole de l'indice de référence (ex. "^GSPC" pour le S&P 500)

Returns:
- float: Bêta du titre par rapport à l'indice de référence
"""
benchmark_data = [Link](indice_benchmark_ticker, start=[Link], end=[Link],
interval="1mo")
benchmark_data['Rendement_Mensuel'] = benchmark_data['Close'].pct_change()

# Fusionner les rendements du titre et de l'indice de référence

data_combined = [Link]([Link]['Rendement_Mensuel'], benchmark_data['Rendement_Mensuel'],
left_index=True, right_index=True, suffixes=('_titre', '_benchmark'))

# Calculer la covariance entre les rendements du titre et du benchmark

covariance = data_combined.cov().iloc[0, 1]

# Calculer la variance des rendements de l'indice de référence

variance_benchmark = data_combined['Rendement_Mensuel_benchmark'].var()

# Calculer le bêta
beta = covariance / variance_benchmark
return beta

# Exemple d'utilisation
ticker = "AAPL"
start = "2019-01-01"
end = "2024-01-01"
analyse = AnalyseFinanciere(ticker, start, end)

# Calculer le rendement espéré, le risque et le bêta

rendement_espere = analyse.calcul_rendement_espere()
risque = analyse.calcul_risque()
indice_benchmark_ticker = "^GSPC" # S&P 500
beta = analyse.calcul_beta(indice_benchmark_ticker)

print(f"Rendement espéré pour {ticker} sur 5 ans : {rendement_espere:.4%}")

print(f"Risque total (volatilité mensuelle) pour {ticker} sur 5 ans : {risque:.4%}")
print(f"Bêta de {ticker} par rapport au S&P 500 : {beta:.4f}")

Dans cet exemple :

 AnalyseFinanciere est la classe qui représente un outil d'analyse pour un titre financier.
 analyse est une instance de la classe AnalyseFinanciere pour le titre "AAPL" sur la période
spécifiée (start, end).
 rendement_espere, risque, beta sont des résultats calculés en utilisant les méthodes définies
dans la classe pour estimer la performance financière du titre.

15
  Le constructeur __init__() permet de définir des valeurs initiales aux attributs (ticker, start, end,
data) dès la création d'une instance de la classe.
 Méthodes privées : La méthode _get_data() est marquée comme privée par convention (avec un
underscore au début) pour indiquer qu'elle ne doit être appelée qu'à l'intérieur de la classe.
 Méthodes publiques : calcul_rendement_espere(), calcul_risque(), et calcul_beta() sont des
méthodes publiques qui peuvent être appelées depuis n'importe quelle instance de la classe.

3.3. Exercice

Développer une classe Python qui permet de calculer le rendement espéré, le risque, et le bêta d’un titre
financier, dont les données seront importées à partir d'un fichier Excel.

Vous utiliserez cette classe pour calculer ces informations pour plusieurs actions cotées à la Bourse de
Casablanca.

4. Fonctions, classes, et organisation du code (modules, packages et bibliothèques)

Les fonctions et les classes sont au cœur de la structure en python. Elles sont souvent organisées sous
forme de modules, packages, et bibliothèques, qui permettent de structurer le code de manière claire et
réutilisable.

4.1. Modules

Un module est un fichier python contenant du code réutilisable, il peut inclure des fonctions, des classes,
des variables, etc. Lorsque l'on écrit des fonctions ou des classes qui pourraient être utiles dans plusieurs
projets ou sections d’un code, il est courant de les placer dans un module pour pouvoir les réutiliser plus
facilement.

 Exemple : supposons que nous avons un fichier nommé finance_utils.py contenant une fonction
pour calculer le rendement moyen. Ce fichier peut être importé dans un autre script avec
l'instruction import finance_utils. Ensuite, nous pourrions appeler la fonction de calcul de
rendement comme suit :

import finance_utils
rendement_moyen = finance_utils.calcul_rendement()

 Modules intégrés : python offre également un grand nombre de modules intégrés (builtin)
disponibles sans installation supplémentaire, par exemple :

o Math : fournit des fonctions mathématiques avancées, comme sqrt() pour la racine carrée
ou sin() pour le sinus.

16
 o Statistics : contient des fonctions pour réaliser des calculs statistiques, comme mean()
pour la moyenne.

o Datetime : permet de manipuler des dates et heures, essentiel pour traiter les données
financières chronologiques.

o Os : permet d'interagir avec le système d'exploitation, par exemple pour gérer des fichiers
et des dossiers.

4.2. Packages

Un package est une collection de modules organisés sous forme de répertoire. C'est une manière de
regrouper plusieurs modules liés pour faciliter leur gestion et leur utilisation. Un package est souvent
représenté par un dossier contenant plusieurs modules et un fichier spécial nommé __init__.py qui indique
à python que ce dossier est un package.

 Exemple : supposons que nous développons plusieurs modules sur des sujets financiers différents
([Link], [Link], analyse_technique.py). Pour organiser ces modules, nous pouvons les
mettre dans un dossier nommé finance. Ce dossier serait alors notre package, et nous pourrions
l'importer de la manière suivante :

from finance import rendement, risque

4.3. Bibliothèques

Une bibliothèque est une collection de modules et de packages qui offrent un ensemble de
fonctionnalités pour une tâche spécifique. Les bibliothèques sont souvent développées par la communauté
python pour répondre à des besoins courants, ce qui permet aux développeurs de ne pas avoir à
réinventer la roue pour des tâches fréquentes.

 Exemples : nous avons déjà utilisé plusieurs bibliothèques au cours des séances précédentes :

o Pandas : pour la manipulation et l'analyse de données.

o Yfinance : pour télécharger des données financières historiques.

o Numpy : pour les calculs mathématiques avancés, notamment ceux nécessaires aux
algorithmes de trading.

Ces concepts — modules, packages, et bibliothèques — permettent de structurer le code de façon logique
et hiérarchisée, tout en facilitant la réutilisation des fonctions et classes d'un projet à l'autre.

17
18