Bienvenue à cette formation "Python pour la Finance" destinée à toutes personnes qui souhaitent apprendre Python pour l'utiliser dans le secteur financier mais plus généralement dans l'analyse de données. Que vous soyez étudiant, professionnel de la finance ou simplement passionné par le domaine, cette formation vous permettra de maîtriser les bases de Python et de l'appliquer à des cas concrets dans le secteur financier.
![Python Finance](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/draze_a_python_in_a_crypto_trading_room_1a54cd54_45a8_4c17_a742_d702c7a77577_bcd044b57f.png)

Nous sommes ravis de vous annoncer que cette formation "Python pour la Finance" est proposée totalement gratuitement par Crypto Robot ! Notre objectif est de rendre l'apprentissage du langage Python et de son application dans le domaine financier accessible à tous. Le meilleur moyen de nous soutenir est de nous suivre sur les différents réseaux sociaux, de vous abonner à notre Newsletter dans laquelle nous vous partagerons notamment les corrections de certains exercices. Enfin vous pouvez partager cette formation au plus grand nombre !
<MAIL_FORM/>

À la fin de chaque session, un exercice pratique sera proposé pour vous permettre de mettre en application les concepts abordés. De plus, chaque session sera accompagnée d'une vidéo explicative pour vous guider pas à pas dans votre apprentissage.

<EXCHANGE_CARD image_name="bitget_fr_1" link="https://partner.bitget.com/bg/CryptoRobotSIFR"/>

## **Sommaire**

- **0 - Python et VsCode l'installation** : Apprenez à installer Python et Visual Studio Code, un éditeur de code polyvalent et puissant, pour débuter votre aventure dans l'apprentissage du langage Python.
- **1 - Variables, Opérations et Types** : Familiarisez-vous avec les variables, les opérations mathématiques et les différents types de données en Python.
- **2 - Boucles et Conditions en Python** : Découvrez comment utiliser les structures de contrôle telles que les boucles et les conditions pour réaliser des tâches répétitives ou conditionnelles.
- **3 - Les Listes et les Dictionnaires en Python** : Apprenez à manipuler les listes et les dictionnaires pour stocker et organiser vos données efficacement.
- **4 - Les Fonctions et les Classes en Python** : Découvrez comment créer et utiliser des fonctions et des classes pour structurer votre code et faciliter la réutilisation.
- **5 - La librairie Pandas, la meilleure librairie pour les données financières** : Apprenez à utiliser Pandas, une librairie puissante pour la manipulation et l'analyse de données, spécialement adaptée pour travailler avec des données financières.
- **6 - Visualiser ses données en Python grâce à Matplotlib** : Découvrez comment créer des graphiques et des visualisations interactives de vos données financières en utilisant la librairie Matplotlib.
- **7 - Déverrouiller la puissance de Pandas et éviter les boucles** : Apprenez à tirer le meilleur parti de Pandas en évitant les boucles et en utilisant des techniques avancées pour manipuler et analyser vos données.
- **8 - Maîtriser l'utilisation des dates en Python** : Découvrez comment gérer et manipuler les dates et les heures en Python, un aspect crucial pour travailler avec des données financières.
- **9 - Backtester une stratégie de trading automatisé en Python** : Apprenez à développer et à évaluer des stratégies de trading automatisées en utilisant Python.
- **10 - Analyser le backtest d'un portefeuille de trading en Python grâce à Pandas** : Découvrez comment analyser les performances de votre portefeuille de trading en utilisant Pandas pour tirer des conclusions et optimiser vos stratégies.


<EXCHANGE_CARD image_name="bitget_fr_1" link="https://partner.bitget.com/bg/CryptoRobotSIFR"/>

Il est important de souligner que le meilleur moyen de progresser en Python, c'est de ne pas se contenter de regarder les vidéos et de lire les documents, mais de vous engager activement dans la pratique. Nous vous encourageons à travailler sur des projets personnels, même de petite envergure, afin d'appliquer et de renforcer vos compétences acquises tout au long de cette formation.

Dans cette formation, vous découvrirez le langage de programmation Python et comment l'appliquer le plus rapidement à des concepts financiers.

# **Conclusion de la Formation "Python pour la Finance"**

Nous sommes arrivés à la fin de notre parcours d'apprentissage ensemble, et j'espère que cette formation "Python pour la Finance" vous a fourni les connaissances et les compétences nécessaires pour débuter ou approfondir votre aventure dans le monde passionnant de la finance et de l'analyse de données avec Python.

![PythonFinanceConclusion.jpg](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Finance_Conclusion_5470619cd7.jpg)

## **Points Clés de la Formation**

Au cours de ces 10 leçons, nous avons couvert une gamme étendue de sujets, y compris :

- Les fondamentaux de Python et l'environnement de développement avec Visual Studio Code.
- La compréhension des variables, opérations, et types en Python.
- Les structures de contrôle telles que les boucles et les conditions.
- La manipulation des listes et dictionnaires.
- La création et utilisation des fonctions et classes.
- L'utilisation avancée de la librairie Pandas pour les données financières.
- La visualisation de données avec Matplotlib.
- La gestion des dates et heures, essentielle dans le secteur financier.
- Le développement et l'évaluation de stratégies de trading automatisées.
- L'analyse de performances d'un portefeuille de trading.

<EXCHANGE_CARD image_name="bitget_fr_1" link="https://partner.bitget.com/bg/CryptoRobotSIFR"/>

## **Appliquez Vos Connaissances**

Rappelez-vous, la pratique est la clé de la maîtrise. Nous vous encourageons à continuer à utiliser Python dans vos projets personnels ou professionnels. N'hésitez pas à revisiter les leçons de ce cours pour rafraîchir vos connaissances, et souvenez-vous que chaque projet est une opportunité d'apprendre quelque chose de nouveau.

## **Restez Connecté**

Continuez à nous suivre sur les réseaux sociaux et à vous abonner à notre Newsletter pour plus de conseils, de tutoriels, et d'actualités sur Python dans la finance. Votre feedback est précieux, donc partagez vos réussites, vos défis, et vos idées avec nous et la communauté de Crypto Robot.

<MAIL_FORM/>

## **Un Grand Merci**

Enfin, un grand merci de la part de toute l'équipe de Crypto Robot pour avoir choisi notre formation. Nous espérons que vous avez trouvé ce cours à la fois informatif et enrichissant, et nous sommes impatients de vous voir appliquer ces compétences dans le monde réel.

"Continuez à apprendre, continuez à grandir, et que vos projets financiers prospèrent avec Python !"

---

Bonne chance et bon succès dans vos futures aventures en programmation Python et en finance ! 🚀📈

<MDX_YT videoId="jHjTd7osxRA"/>

## Les Variables, c'est quoi ?

Les **variables** sont à la base de tout programme informatique. C’est un moyen d’enregistrer une donnée pour pouvoir l’utiliser plus tard. 
Je veux par exemple enregistrer le nombre d’actions Apple que je détiens pour ensuite faire des opérations en fonction de ce nombre d’actions. 
Pour déclarer une variable en Python c’est très simple, voici un exemple :

```python
apple_stock_number = 5
```

Une variable est composé de 3 éléments : un **nom**, une **valeur** et un **type**.
Dans ce cas, le nom est **`apple_stock_number`**, la valeur est 5, et le type est un nombre (nous verrons les types en détail dans un second temps).

> Pour nommer une variable en Python, on va en général la nommer avec un nom explicite (en anglais), tout en minuscule, avec des “_” à la place des espaces. C’est en quelque sorte une convention qu’il est important de respecter.
> 

Vous pouvez maintenant à tout moment retrouver le nombre d’actions APPLE que vous détenez en faisant par exemple :

```python
print(apple_stock_number) # Affiche 5
```

Vous devrez ici voir afficher 5 qui correspond bien à la valeur que nous avons assigné plus haut. Cela affiche la valeur de notre variable.

> **`print()`** est ce que l’on appelle une fonction qui nous permet d’afficher la valeur de ce que l’on met à l’intérieur de la parenthèse. Vous avez pu tester cette fonction dans la séance précédente avec le **`print(”hello world”)`** qui dans ce cas affiche  le texte “hello world”.
> 

> Le caractère **`#`** permet d’ajouter des commentaires. Tout ce qui est après le **`#`** ne sera pas pris en compte dans le programme. Cela peut servir à fournir des indications afin de se souvenir de ce que fait le code par exemple.
> 

Vous pouvez également modifier la valeur de votre variable en faisant :

```python
apple_stock_number = 7
```

La valeur de la variable sera maintenant 7. Pour vous rendre compte de la modification, vous pouvez faire :

```python
apple_stock_number = 5
print(apple_stock_number) # Affiche 5
apple_stock_number = 7
print(apple_stock_number) # Affiche 7
```

Dans ce cas, vous devriez voir afficher 5 puis 7.

Attention si vous faites :

```python
print(microsoft_stock_number) # Affiche une erreur
```

Vous obtiendrez une erreur, car vous n’avez pas défini la variable **`microsoft_stock_number`***.*

## Quels sont les différents types ?

Dans la première partie, nous avons vu que la variable **`apple_stock_number`** était de type nombre. Or pour être exacte, le type *nombre* n’existe pas en Python. Nous allons voir ici les 4 types principaux utilisés en Python pour la définition de variable.

- **int** pour Integer qui sont les nombres entiers (exemple 5 ou -5)
- **float** pour Floating-point number qui sont les nombres à virgule (exemple 5.91)
- **str** pour String qui sont les chaînes de caractère (exemple “Hello World”)
- **bool** pour Boolean qui sont les booléens comme vrai ou faux (exemple True ou False)

Pour voir un exemple concret, vous pouvez exécuter ce code :

```python
int_var = -5
float_var = 5.7
str_var = "Hello World"
bool_var = True

print(type(int_var)) # Affiche <class 'int'>
print(type(float_var)) # Affiche <class 'float'>
print(type(str_var)) # Affiche <class 'str'>
print(type(bool_var)) # Affiche <class 'bool'>
```

Nous avons ici défini 4 nouvelles variables, chacune de types différents. En effet, vous devriez voir afficher pour chaque variable un message **`<class ‘’>`** avec le type à l’intérieur des guillemets.

> **`type()`** est comme **`print()`**, une fonction qui permet cette fois d’obtenir le type de l’objet que l’on met à l’intérieur de la parenthèse
> 

Nous n’allons pas rentrer dans le détail ici, mais sachez que vous pouvez aussi changer le type d’une variable dans certain cas, par exemple :

```python
int_var = -5
str_var = str(-5)
print(str_var) # Affiche "-5" au lieu de -5 et str_var ne réagira plus comme un nombre
print(type(str_var)) # Affiche <class 'str'>
```

Bien connaitre les types des variables que l’on utilise est important. Un bon nombre d’erreurs qui surviennent lorsque l’on construit un code en Python, et dans la plupart des langages de programmation en général, surviennent du fait que l’utilisateur essaie de faire des opérations entre des types de variable qui ne sont pas compatibles entre elles.

## Utiliser les opérations en Python

Présentement que nous avons vu comment déclarer des variables et leurs types, nous allons pouvoir utiliser les opérations de base en Python. 
Les opérations de base sont : 

- l'addition (+)
- la soustraction (-)
- la multiplication (*)
- la division (/)
- le modulo (%)

Le modulo (%) est une opération peu utilisée qui nous permet de récupérer le reste d'une division.

Voici quelques exemples d'utilisation de ces opérations :

```python
# Addition
result = 2 + 3
print(result) # affiche 5

# Soustraction
result = 10 - 5
print(result) # affiche 5

# Multiplication
result = 2 * 3
print(result) # affiche 6

# Division
result = 10 / 5
print(result) # affiche 2.0 car le résultat d'une division est de type float

# Modulo
result = 7 % 3
print(result) # affiche 1 car 3*2 + 1 = 7
```

Il est important de noter que vous pouvez utiliser ces opérations avec des variables de type **`str`**, mais cela va générer des comportements différents. Par exemple :

```python
word1 = "Hello"
word2 = "World"
result = word1 + word2
print(result) # affiche "HelloWorld"
result = word1 + " " + word2
print(result) # affiche "Hello World"
print(word1 * 2) # affiche "HelloHello"
```

En utilisant les opérations de base et les variables en Python, vous pouvez maintenant effectuer des calculs et les utiliser dans des programmes pour faire des calculs de profits, de pertes ou de calculs de taux de rendement. N'oubliez pas de toujours vérifier que les variables utilisées sont du bon type avant de les utiliser dans des opérations.

## Mise en situation et entraînement

Vous trouverez ci-dessous un exercice reprenant les concepts vus précédemment. Pour rappel, le meilleur moyen pour progresser est de s’exercer. Vous avez ici un exemple d’exercice, mais c’est encore mieux si vous le personnalisez en essayant de répondre à une de vos problématiques comme votre calcul d’impôt.

**Contexte :**
John détient un compte titre avec des actions APPLE. 
L’action APPLE vaut actuellement 135 dollars l’unité.
John a acheté 20 actions APPLE à 60 dollars l’unité, puis 10 actions APPLE à 145 dollars l’unité et enfin revendu 8 actions APPLE à 120 dollars l’unité. 
Il hésite à revendre ses actions APPLE restantes. Pour l’aider dans sa décision, il a notamment besoin de savoir de combien il sera taxé s’il vend ses actions restantes.

**Questions :**

1. Affichez la valeur en dollars des actions actuelles présentes sur le compte titre de John 
2. Affichez le prix moyen d’achat de John pour ses actions APPLE
3. Affichez la plus-value totale de John s’il vendait toutes ses actions APPLE aujourd’hui.
4. John a la double nationalité belge et française, il peut choisir ou déclarer ses plus-values. En France, il est taxé à hauteur de 30% des plus-values. En Belgique, il n’est pas taxé pour les 500 premiers dollars de plus-value, mais sur le reste, il est taxé à 40%. Affichez les taxes sur les plus-values si John paye ses taxes en France et s’il les paye en Belgique.

Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_1.ipynb

Familiarisez-vous avec les variables, les opérations mathématiques et les différents types de données en Python.

Variables, Opérations et Types

<MDX_YT videoId="V7zrICm_kes"/>

## **Les boucles en Python**

Les boucles sont un concept essentiel en programmation, permettant d'exécuter un bloc de code plusieurs fois en fonction d'une condition ou d'un nombre d'itérations déterminé. Dans le contexte de la finance, elles peuvent être utilisées pour analyser des données sur plusieurs périodes ou pour effectuer des calculs répétitifs. Un exemple très concret serait le backtest, le backtest est une simulation sur le passé d’une stratégie d’investissement ou de trading. Pour réaliser un backtest, nous allons parcourir chaque prix sur une période donnée, et cela se fait grâce à une boucle. En Python, on utilise principalement deux types de boucles : **`for`** et **`while`**.

### **La boucle `for` en Python**

La boucle **`for`** est utilisée pour parcourir une séquence et exécuter un bloc de code pour chaque élément de cette séquence. Une séquence peut avoir plusieurs types comme une liste, un tuple, un dictionnaire ou une chaîne de caractères. Nous verrons ces types lors de la prochaine séance, pour l’instant cela n’est pas très important pour la compréhension.

Par exemple, supposons que nous avons un solde de compte actuel de 3000€, tous les mois, nous touchons un salaire de 2000€ et nous avons 1800€ de dépense. Nous souhaitons connaître à la fin de l’année (après 12 mois) le solde de notre compte  :

```python
balance = 3000
salary = 2000
expenses = 1800

for i in range(12):
	balance = balance + salary - expenses 
	print("Solde après", i+1, "mois", balance, "€")

print("Le solde de mon compte en fin d'année est :", balance, "€")
```

Ici, nous définissons trois variables : **`balance`**, **`salary`** et **`expenses`**. Ces variables représentent respectivement le solde de départ du compte, le salaire mensuel et les dépenses mensuelles. 

Ensuite, nous utilisons une boucle **`for`** pour simuler les transactions financières sur une période de 12 mois. La fonction **`range(12)`** génère une séquence de nombres de 0 à 11 (12 éléments au total). 

Vous pouvez remarquer que les 2 lignes en dessous du **`fo`r** ne sont pas alignées au même niveau. En effet, elles sont ce qu’on appelle **indentées, c'est-à-dire** espacées de 4 espaces à gauche. **Les lignes indentées sont incluses par le `for`**, alors que celles non indentées comme la dernière ne le seront pas. Concrètement, l’affichage **`“Solde après…”`** sera affiché 12 fois alors que le texte **`“Le solde de mon compte…”`** ne sera affiché qu’une seule fois.

Nous mettons par la suite à jour notre solde en lui ajoutant le salaire et en retirant les dépenses et affichons grâce à la fonction **`print()`** notre nouveau solde, ainsi que le mois de l’année. Comme nous l’avons vu plus haut, la fonction **`range(12)`** génère une séquence de nombres de 0 à 11 donc lors de l’affichage, nous ajouterons 1 à **`i`** afin de commencer au mois 1 au lieu du mois 0.

Enfin, nous affichons le solde final en fin d’année.

![Python output result](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/python_output1_cc899d94a5.png)

### **La boucle `while` en Python**

La boucle **`while`** est utilisée pour exécuter un bloc de code **tant qu'une condition est vraie**. Par exemple, supposons que nous voulons calculer combien de temps faut-il pour doubler un investissement avec un taux d'intérêt annuel fixe :

```python
initial_investment = 1000
interest_rate = 0.05
years = 0
current_value = initial_investment

while current_value < initial_investment * 2:
    current_value = current_value * (1 + interest_rate)
    years += 1

print("Il faudra", years, "années pour doubler l'investissement.")
```

Dans cet exemple, le bloc de code à l'intérieur de la boucle **`while`** sera exécuté tant que la valeur de **`current_value`** est inférieure au double de l'investissement initial. À chaque itération, nous mettons à jour la valeur de **`current_value`** avec les intérêts et on incrémente **`years`** de 1.

Nous sortons donc de la boucle **`while`** lorsque la valeur de **`current_value`** devient supérieur à 2 fois notre investissement initial. A ce moment, nous affichons grâce à la fonction **`print`** la valeur de notre variable **`years`** qui représente le nombre d’année nécessaire pour doubler notre investissement.

## **Comment utiliser des conditions en Python ?**

Les conditions sont également un concept important en programmation. Elles permettent d'exécuter un bloc de code si une condition est vraie, et éventuellement un autre bloc de code si cette condition est fausse. En Python, on utilise les mots-clés **`if`**, **`elif`** et **`else`** pour définir des conditions. **`if`** pour **si**, **`elif`** pour **sinon si** et enfin **`else`** pour **sinon.**

Voici un exemple simple :

```python
bitcoin_price = 45000

if bitcoin_price <= 30000:
    print("Acheter")
elif bitcoin_price > 30000 and bitcoin_price <= 50000:
    print("Vendre la moitié")
elif bitcoin_price < 60000:
    print("Conserver")
else:
    print("Vendre la totalité")
```

Dans cet exemple, le programme va afficher "Vendre la moitié", car la valeur de **`bitcoin_price`** est 45 000, ce qui est supérieur à 30 000 et inférieur à 50 000. Vous découvrez ici le mot clé **`and`** qui représente l’opérateur et en français, il existe par ailleurs le **`or`** qui représente le ou en français.

Voici quelques autres exemples simples d’utilisation de **conditions**:

```python
text = "hello"
if text == "hello" or text == "hi":
		print("text is hello or hi")
elif text != "hello":
		print("text is not hello and also no hi")

condition = True
if condition is True:
		print("My condition is true")
else:
		print("My condition is false")
```

## **Exemple combinant boucles et conditions en Python**

Pour illustrer l'utilisation combinée des boucles et des conditions en Python, prenons un exemple où nous cherchons à déterminer combien de mois il vous faudra pour atteindre un objectif d'épargne, en tenant compte d'une augmentation possible de l'épargne mensuelle en fonction d'une promotion au travail.

- Objectif d'épargne : 10 000 €
- Épargne mensuelle actuelle : 400 €
- Promotion prévue dans 6 mois
- Augmentation de l'épargne mensuelle après promotion : 200 € (épargne mensuelle de 600 €)

```python
# Variables
savings_goal = 10000
monthly_savings = 400
promotion_month = 6
savings_increase = 200

# Initialiser les compteurs
months_needed = 0
total_savings = 0

# Boucle pour atteindre l'objectif d'épargne
while total_savings < savings_goal:
    # Vérifie si la promotion a eu lieu
    if months_needed == promotion_month:
        monthly_savings += savings_increase

    # Ajoutez l'épargne mensuelle au total
    total_savings += monthly_savings

    # Incrémentez le compteur de mois nécessaires
    months_needed += 1

print(f"Il vous faudra {months_needed} mois pour atteindre votre objectif d'épargne de {savings_goal} €.")
```

Dans cet exemple, nous utilisons une boucle **`while`** pour simuler l'épargne mensuelle et vérifier si l'objectif d'épargne a été atteint. La condition **`if`** à l'intérieur de la boucle vérifie si la promotion a eu lieu et met à jour l'épargne mensuelle en conséquence. Le compteur **`months_needed`** permet de suivre le nombre de mois nécessaires pour atteindre l'objectif d'épargne. 

Vous remarquerez également l’utilisation de += . Pour comprendre **`a += 1`** est exactement la même chose que **`a = a + 1`.** L'opérateur **`+=`** ajoute la valeur de droite à la variable de gauche, puis affecte le résultat à la variable de gauche. Les opérateurs **`-=`** ou **`*=` **existent également et marchent sur le même principe.

```python
a = 5
a += 3 # a = a + 3
print(a) # Affiche 8

b = 10
b -= 1 # b = b - 1
print(b) # Affiche 9

c = 2
c *= 15 # c = c * 15
print(c) # Affiche 30
```

## **Mise en pratique**

Pour mettre en pratique les concepts abordés dans cette partie, essayons de résoudre un exercice simple. Imaginons que vous avez investi 1000 € dans différents actifs financiers, et vous voulez savoir combien d'années, il faudra pour atteindre un certain objectif de capitalisation.

Supposons que vous avez les informations suivantes :

- Investissement initial : 1000 €
- Objectif de capitalisation : 2000 €
- Taux d'intérêt annuel : 4 %

Questions :

1. Combien d'années faudra-t-il pour atteindre l'objectif de capitalisation ?
2. Modifiez le taux d'intérêt annuel et vérifiez l'impact sur le nombre d'années nécessaires pour atteindre l'objectif.
3. Ajoutez une boucle **`for`** pour tester différents taux d'intérêt annuels (par exemple, de 2 % à 8 %, par pas de 1 %) et affichez le nombre d'années nécessaires pour atteindre l'objectif pour chaque taux.

Cet exercice devrait vous permettre de mieux comprendre l'utilisation des boucles et des conditions en Python appliquées au contexte de la finance. Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_2.ipynb. N'hésitez pas à adapter cet exemple à vos propres besoins et à explorer d'autres scénarios financiers.

Découvrez comment utiliser les structures de contrôle telles que les boucles et les conditions pour réaliser des tâches répétitives ou conditionnelles.

Boucles et Conditions en Python

<MDX_YT videoId="VgAotnwBHN0"/>

Dans cette première partie nous allons installer 2 logiciels. Le premier sera **Python** qui va justement nous permettre d’éxécuter du code Python sur notre machine. A partir de là vous serez capable d’éxécuter du code python dans votre terminal de commande ce qui est déjà bien. 

Cependant vous vous doutez peu être que le code s’écrit rarement à travers la console (ce n’est pas très pratique). C’est pour cela que l’on va installer ce que l’on appelle un **IDE** (Integrated Development Environnement) ou Environnement de Développement en français. **Cet IDE sera VsCode** qui est l’IDE le plus utilisé et complètement open source 😉. En bonus, VsCode est personnalisable avec des **extensions** qui aide beaucoup à la programmation et qui boost l’efficacité du programmeur. Nous verrons cela plus tard. D’ailleurs, VsCode ne permet pas que d’écrire du Python, mais aussi d’autre langage de programmation très utilisé de nos jours tel que JavaScript, C, CSS. C’est ainsi un très bon “investissement long terme” pour l’apprentissage et l’utilisation de la programmation, et ce que l’on soit amateur ou professionnel !

Ce tutoriel explique les installations sur **Windows** mais c’est à peu près le même principe sur Mac et sur Linux.

Le contenu de cette page présente l’installation de ces deux outils étapes par étapes. Si vous souhaitez suivre l’installation en vidéo je vous conseille cette vidéo pour l’installation de Python [https://www.youtube.com/watch?v=3nrCgMTDTdY](https://www.youtube.com/watch?v=3nrCgMTDTdY) et celle-ci pour l’installation de VsCode [https://www.youtube.com/watch?v=1Z1JCuwXmiQ](https://www.youtube.com/watch?v=1Z1JCuwXmiQ)

## Installation de Python

Pour installer Python rien de très compliqué, la première chose est de se rendre sur le site officiel [https://www.python.org/downloads/](https://www.python.org/downloads/) , vous aurez ensuite un **bouton jaune vous permettant d’installer Python** pour votre système d’exploitation comme ci-dessous. 
![Python-Install0.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Install0_21167d5065.png)

Vous pouvez ensuite éxécuter ce que vous venez de télécharger.

⚠️ **Attention suivez les étapes suivantes après avoir ouvert le fichier d’installation afin d’éviter tout problème**⚠️

La chose la plus importante ici est dans la première fenêtre de bien **cocher la case Add Python 3.X to PATH** dans la première fenêtre. Cela va permettre à Windows de reconnaître automatiquement l’installation de Python en l’ajoutant aux variables d’environnements. 
![Python-Install1.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Install1_479f0bca02.png)

Ensuite nous allons choisir l’installation personnalisée (**Customize installation**) puis sur Optional Features je vous invite à laisser toutes les cases cochées.
![Python-Install2.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Install2_1581bd1511.png)

Enfin dans les options avancées je vous invite à **cocher la case Install for all users.** Je vous invite également à changer le chemin d’installation en mettant **C:\Python311** si vous installez la version 3.11.X de Python. Cela évitera tout problème de permission qui arrive assez souvent sur Windows.
![Python-Install3.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Install3_f630e1ffdd.png)

Vous pouvez ensuite cliquer sur **Install**.

Pour vérifier que Python s’est bien installé et bien parametré je vous invite à ouvrir votre invité de commande. (Sur windows tapez cmd dans la recherche windows et ouvrez le programme **invite de commande**).

Vous pouvez ensuite taper `python —version`
![Python-Version.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Version_cc319a8be7.png)

Cela devrait vous **afficher votre version de python**. Si cela vous affiche que python n’est pas reconnu vous pouvez essayer en remplaçant par python3 et si cela ne marche toujours pas je vous invite à redémarrer votre PC et si ce n’est toujours pas bon à désinstaller Python et installez le de nouveau en prenant soin de bien vérifier que vous avez coché la case “Add Python to PATH” au début de l’installation.

Vous pouvez ensuite commencer vos premières commandes python en tapant **python puis entrée**. Vous entrez dans un terminal python. Vous pouvez taper la commande `print(”hello world”)` qui va permettre d’afficher le texte hello world. Vous pouvez également faire des opérations comme 2+3 qui devrait vous afficher 5. Félicitations ! Vous ne l’avez peut-être pas réaliser, mais vous venez d’éxécuter votre premier programme python 🐍.
![Python-Console.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Console_d03b05318b.png)

## Installation de VsCode

Pous installer **VsCode** je vous invite à vous rendre sur le site officiel sur ce lien [https://code.visualstudio.com/download](https://code.visualstudio.com/download) , vous pouvez ensuite télécharger le logiciel en fonction de votre système d’exploitation.

Cliquez sur le fichier que vous avez téléchargé et cliquez sur **suivant jusqu’à arriver à la fenêtre ci-dessous.**
![VsCode-Install1.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Vs_Code_Install1_1148c39e15.png)

Ici je vous invite à **cocher toutes les cases** c’est assez important pour simplifier l’utilisation du logiciel par la suite. Vous pouvez ensuite faire suivant puis **installer**.

VsCode est maintenant installé, si la fenêtre s’est ouverte vous pouvez la fermer nous allons faire autrement.

## Votre premier programme Python avec VsCode

Nous allons maintenant créer un dossier par exemple sur votre Bureau que nous allons appeler par exemple formation_python. Ouvrez ce dossier et faites un click droit à l’intérieur. Vous devriez avoir une option “**Ouvrir avec Code**” si vous êtes sur Windows 11 cette option se trouve dans le menu “Plus d’options”.
![VsCode-Install2.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Vs_Code_Install2_90e4c054dd.png)

Vous pouvez fermer la page de Bienvenue. Puis en haut à gauche appuyer sur le bouton pour **créer un nouveau fichier**. Nommez ce fichier hello.py (.py est l’extension des fichiers executables python).
![VsCode-Nouveau-Fichier.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Vs_Code_Nouveau_Fichier_980f870022.png)

Vous devriez surement avoir un message vous proposant d’installer **l’extension Python** de VsCode qui permet à VsCode de prendre en charge  le lagage de programmation Python. Si ce n’est pas le cas vous pouvez aller dans le menu des extensions à gauche et rechercher l’extension Python puis l’installer.
![Extension-Python.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Extension_Python_c729d2951e.png)

Vous pouvez retourner à votre fichier [hello.py](http://hello.py) pour l’éditer. Vous pouvez le remplir comme ceci.

```python
print("Hello World")
```

Vous devriez avoir maintenant un bouton en haut à droite pour éxécuter votre fichier hello.py
![Python-Execution.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Python_Execution_d0c5de8e09.png)

Si vous appuyer dessus cela devrait automatiquement vous ouvrir un terminal en éxécutant une commande qui lancera votre programme Python. Et vous devriez maintenant voir affiché dans votre terminal Hello World. Vous venez de lancer votre premier programme Python dans VsCode 😉.

## Créer un Notebook

Lorsque vous aller vouloir créer un programme avec un but par exemple d’automatiser une action vous allez preque toujours comme on vient de le voir écrire votre programme dans un fichier .py. Cependant il existe un autre type de fichier qui facilite grandement les **premiers tests, l’exploration et l’analyse de données**. Ce sont ce qu’on appelle les **notebook jupyter**. Ces fichiers marchent sous forme de **cellule** que l’on peut éxécuter les unes à la suite des autres. Nous allons beaucoup utiliser ces fichiers dans cette formation. 

Pour créer un notebook Jupyter il suffit de créer un nouveau fichier comme on l’a fait précédement. Cette fois on va le nommer *hello.ipynb* (.ipynb est l’extension des notebook jupyter).

VsCode devrait également automatiquement vous demander d’installer une extension pour supporter ce genre de fichiers mais si ce n’est pas le cas vous pouvez également rechercher puis **installer l’extension Jupyter**.
![Jupyter-Extension.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Jupyter_Extension_bb8fa30c5a.png)

Vous pouvez maintenant retourner à votre fichier hello.ipynb et remplir la première cellule avec la même commande que précédement `print(”Hello World”)`.
![Jupyter-Execution1.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Jupyter_Execution1_340c1c947a.png)

Cette fois la flèche pour éxécuter est juste à gauche de la cellule. En cliquant dessus cela devrait afficher Hello World. Vous pouvez également utiliser le **raccourcis Ctrl + Entrée** pour éxécuter la cellule en cours d’édition. Vous pouvez ajouter une nouvelle cellule en dessous en passant votre souris vers le bas de la cellule actuelle et en cliquant sur le bouton + Code qui devrait apparître. Vous pouvez remplir cette cellule avec `print(2+3)`, l’éxécuter et cela devrait afficher 5. 
![Jupyter-Execution2.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/Jupyter_Execution2_b0e2cd53bc.png)

## Conclusion

Vous savez maintenant comment éxécuter un programme Python dans VsCode, que ce soit des fichiers Python qui finissent .py ou des Jupyter Notebook qui finissent .ipynb, dans cette formation nous serons amener à utiliser les deux.

Nous nous retrouvons donc à la séance suivante dans laquelle nous allons aborder les variables qui sont à la base de tout programme informatique.





Apprenez à installer Python et Visual Studio Code, un éditeur de code polyvalent et puissant, pour débuter votre aventure dans l'apprentissage du langage Python.

Python et VsCode l'installation

<MDX_YT videoId="KbMcxX2ogBI"/>

Dans cette partie, nous allons explorer deux structures de données essentielles en Python : les listes et les dictionnaires. Ces structures vous permettront de stocker et de manipuler des données de manière plus efficace dans vos programmes. Elles sont particulièrement utiles pour traiter des données financières, telles que les séries temporelles de prix, les portefeuilles d'actifs ou les informations sur les clients.

## **Les listes en Python**

Une liste en Python est une collection ordonnée et modifiable d'éléments. Les éléments d'une liste peuvent être de différents types, tels que des nombres, des chaînes de caractères ou même d'autres listes. Pour créer une liste, utilisez des crochets **`[]`** et séparez les éléments par des virgules.

### **Créer une liste**

Voici comment créer une liste contenant des valeurs numériques et textuelles :

```python
assets = ["actions", "obligations", "immobilier", "liquidités"]
print(assets)
```

Cette liste contient six éléments : trois nombres entiers et trois chaînes de caractères.

### **Accéder aux éléments d'une liste**

Pour accéder à un élément d'une liste, utilisez l'indice de l'élément entre crochets. Les indices en Python commencent à 0 pour le premier élément. Vous pouvez également accéder aux éléments en partant de la fin de la liste en utilisant des indices négatifs

```python
assets = ["actions", "obligations", "immobilier", "liquidités"]
print(assets[0])  # Affiche "actions"
print(assets[2])  # Affiche "immobilier"
print(assets[-1])  # Affiche "liquidités"
```

### **Modifier les éléments d'une liste**

Les listes sont modifiables, ce qui signifie que vous pouvez changer la valeur d'un élément en utilisant son indice :

```python
assets = ["actions", "obligations", "immobilier", "liquidités"]
assets[-2] = 15 # On peut avoir une liste avec différents types à l'intérieur
print(assets)  # Affiche ["actions", "obligations", 15, "liquidités"]
```

### **Ajouter et supprimer des éléments d'une liste**

Pour ajouter un élément à la fin d'une liste, utilisez la méthode **`append()`** :

```python
assets = ["actions", "obligations", "immobilier", "liquidités"]
assets.append("matières premières")  # Ajoute "matières premières" à la fin de la liste
```

Pour insérer un élément à une position spécifique, vous pouvez utiliser la méthode **`insert()`**
 en indiquant **l'index** (l’index est un terme très important, l’index d’un élément dans une liste est en quelque sorte son classement. Dans la liste assets, “actions” a pour index 0) et la valeur :

```python
assets.insert(1, "ETFs")  # Insère "ETFs" à la position 1 (le deuxième élément)
```

Pour supprimer un élément d'une liste, vous pouvez utiliser la méthode **`remove()`**
 en indiquant la valeur de l'élément :

```python
assets.remove("liquidités")  # Supprime "liquidités" de la liste
```

Pour supprimer un élément à un index spécifique, vous pouvez utiliser la fonction **`del`**
 :

```python
del assets[0]  # Supprime le premier élément de la liste
```

N’hésitez pas à faire des tests à l’aide de `**print()**` afin de se rendre compte des effets 

### **Parcourir une liste avec des boucles**

Comme mentionné précédemment, les boucles sont un excellent moyen de parcourir et de manipuler des listes. Vous pouvez utiliser les boucles `**for**` pour parcourir les éléments d'une liste et effectuer des opérations sur chaque élément. Voici quelques exemples d'utilisation des boucles pour parcourir une liste :

**Exemple 1 : Afficher tous les éléments d'une liste**

```python
assets = ["actions", "obligations", "immobilier", "liquidités"]

for asset in assets:
    print(asset)
```

Dans cet exemple, la boucle **`for`**parcourt tous les éléments de la liste **`assets`** et utilise la variable **`asset`** pour stocker l'élément courant à chaque itération. Ensuite, la fonction **`print()`** est utilisée pour afficher la valeur de **`asset`**.

**Exemple 2 : Appliquer une opération sur tous les éléments d'une liste**

Supposons que nous avons une liste de prix d'actions et que nous voulons calculer le rendement pour chaque action. Voici comment nous pouvons le faire en utilisant une boucle **`for`** :

```python
prices = [100, 120, 80, 150]
returns = [] # Liste vide dans laquelle on va ajouter des éléements au fur et à mesur

for price in prices:
    returns.append(price * 1.1)  # Calcule le rendement après une hausse de 10 %

print(returns)
```

Dans cet exemple, nous avons une liste **`prices`** contenant les prix d'actions. Nous créons également une liste vide **`returns`** pour stocker les résultats. La boucle **`for`** parcourt la liste **`prices`**, et pour chaque élément (prix), elle calcule le rendement après une hausse de 10 % et ajoute le résultat à la liste **`returns`** en utilisant la méthode **`append()`**. À la fin, la liste **`returns`** contiendra les rendements calculés pour chaque action.

**Exemple 3 : Parcourir une liste en utilisant `range()` et `len()`**

La fonction **`len()`** retourne la longueur d'un objet itérable, comme une liste. Vous pouvez l'utiliser en combinaison avec **`range()`** pour parcourir une liste en utilisant l'index des éléments :

```python
assets = ["actions", "obligations", "immobilier", "liquidités"]
print(len(assets)) # Affiche 4

for i in range(len(assets)):
    print("Index", i, ":", assets[i])
```

Dans cet exemple, la fonction **`len(assets)`** retourne 4, car il y a 4 éléments dans la liste **`assets`**. La fonction **`range(len(assets))`** génère une séquence d'indices de 0 à 3 (4 éléments au total).

La boucle **`for`** parcourt ces indices et utilise l'index **`i`** pour accéder à l'élément correspondant dans la liste **`assets`**. La fonction **`print()`** affiche l'index et la valeur de chaque élément.

Cette méthode est utile lorsque vous devez accéder aux éléments de la liste en utilisant leur index ou si vous devez modifier les éléments de la liste pendant que vous la parcourez.

## **Les dictionnaires en Python**

Un dictionnaire en Python est une collection non ordonnée, modifiable et indexée d'éléments. Contrairement aux listes, les dictionnaires utilisent des clés pour accéder aux éléments, plutôt que des indices. Les dictionnaires sont particulièrement utiles pour stocker et organiser des données sous forme de paires clé-valeur. Pour créer un dictionnaire, utilisez des accolades **`{}`** et séparez les clés et les valeurs par des deux-points **`:`**.

### **Créer un dictionnaire**

Voici comment créer un dictionnaire contenant des informations sur différents types d'actifs :

```python
asset_info = {
    "actions": "investissement en actions d'entreprises",
    "obligations": "investissement en titres de créance",
    "immobilier": "investissement en biens immobiliers",
    "liquidités": "investissement en liquidités ou quasi-liquidités"
}
print(asset_info)
```

Dans cet exemple, le dictionnaire **`asset_info`** contient quatre éléments, chacun représenté par une paire clé-valeur. Les clés sont des chaînes de caractères (les types d'actifs), et les valeurs sont des descriptions textuelles des actifs.

### **Accéder aux éléments d'un dictionnaire**

Pour accéder à un élément d'un dictionnaire, utilisez la clé correspondante entre crochets **`[]`**
 :

```python
asset_info = {
    "actions": "investissement en actions d'entreprises",
    "obligations": "investissement en titres de créance",
    "immobilier": "investissement en biens immobiliers",
    "liquidités": "investissement en liquidités ou quasi-liquidités"
}

print(asset_info["actions"])  # Affiche "investissement en actions d'entreprises"
print(asset_info["immobilier"])  # Affiche "investissement en biens immobiliers"
```

### **Modifier les éléments d'un dictionnaire**

Les dictionnaires sont modifiables, ce qui signifie que vous pouvez changer la valeur d'un élément en utilisant sa clé :

```python
asset_info["actions"] = "investissement en parts d'entreprises"
print(asset_info["actions"])  # Affiche "investissement en parts d'entreprises"
```

### **Ajouter et supprimer des éléments d'un dictionnaire**

Pour ajouter un nouvel élément à un dictionnaire, il suffit d'assigner une valeur à une nouvelle clé :

```python
asset_info["matières premières"] = "investissement en matières premières"
print(asset_info)
```

Pour supprimer un élément d'un dictionnaire, vous pouvez utiliser la fonction **`del`** en indiquant la clé de l'élément :

```python
del asset_info["liquidités"]
print(asset_info)
```

### **Parcourir un dictionnaire avec des boucles**

Vous pouvez utiliser des boucles pour parcourir un dictionnaire et effectuer des opérations sur ses éléments. Les dictionnaires peuvent être parcourus de différentes manières, telles que par clé, par valeur ou par paires clé-valeur.

**Exemple 1 : Parcourir un dictionnaire par clé**

Pour parcourir un dictionnaire par clé, vous pouvez utiliser simplement une boucle **`for`** :

```python
asset_info = {
    "actions": "investissement en actions d'entreprises",
    "obligations": "investissement en titres de créance",
    "immobilier": "investissement en biens immobiliers",
    "liquidités": "investissement en liquidités ou quasi-liquidités"
}

for key in asset_info:
    print(key) # Affiche la clé (actions, obligations...)
    print(asset_info[key]) # Affiche la valeur associé à la clé
```

Dans cet exemple, la boucle **`for`** parcourt toutes les clés du dictionnaire **`asset_info`** et utilise la variable **`key`** pour stocker la clé courante à chaque itération. La fonction **`print()`** est utilisée pour afficher la clé.

### Des dictionnaires et des listes plus complexes

Les dictionnaires et les listes sont des structures de données qui peuvent devenir complexes. On peut avoir par exemple des listes de listes, ou des listes de dictionnaires avec des listes comme valeurs. Nous allons voir un exemple ci-dessous:

```python
my_stocks = {
    "APPL":{
        "information": {
            "common_name": "Apple",
            "market_is_open": True,
            "currency": "dollar",
        }, 
        "quantity": 24,
        "current_price": 165.45,
        "last_5_days_price": [160.25, 163.87, 161.58, 164.01, 165.45]
    },
    "LVMH":{
        "information": {
            "common_name": "Louis Vuitton",
            "market_is_open": False,
            "currency": "euro",
        }, 
        "quantity": 10,
        "current_price": 215.72,
        "last_5_days_price": [217.56, 220.51, 221.90, 219.19, 215.72]
    }
}
```

Dans cette exemple nous avons un dictionnaire représentant des actions de notre portefeuille. Comme vous le voyez chaque élément du dictionnaire est constitué soit de valeur, d’autre dictionnaire ou de listes.  

Voici quelque commande pour afficher des valeurs:

- Afficher le prix de LVMH d’il y a 3 jours:

```python
print(my_stocks["LVMH"]["last_5_days_price"][-3])
```

- Afficher si le marché est ouvert sur l’action AAPL:

```python
print(my_stocks["APPL"]["information"]["market_is_open"])
```

## Spécificité des listes et dictionnaires

Les listes et les dictionnaires sont des types un peu spécial par rapport aux **`int`** ou aux **`string`**. Ils réagissent d’une manière qui peut sembler contre intuitive notamment dans le cas d’égalité. Un exemple vaut mieux que 1000 mots donc voici un exemple de leurs comportements particuliers.

```python
list1 = [1, 2, 3]
list2 = []

list2 = list1
list2[0] = 542

print(list1) # Affiche [542, 2, 3]
```

Comme vous pouvez le remarquer dans cet exemple, la **`list1`** n’a jamais été modifiée. Pourtant sa valeur à changer lorsque l’on a changé la variable **`list2`**. Cela est du au concept de **référence** que l’on retrouve dans beaucoup de langage de programmation pour les types complexes comme les listes ou dictionnaires.

Dans la cas de liste comme dans notre exemple lorsque l’on écrit **`list2 = list1`** cela ne veut pas dire que la valeur de **`list2`** égal la valeur de la **`list1`**. Ecrire **`list2 = list1`** signifie que la variable **`list2`** **pointe** vers la variable list1. Ce qui implique que si l’on modifie **`list2`** cela modifie également **`list1`** et inversement.

Pour éviter ce comportement vous pouvez utiliser la méthode **`.copy()`** ce qui réalisera une copie indépendante. Attention cependant si à l’intérieur de la liste il y a des autres listes ou des dictionnaires la copie ne sera pas complètement indépendante et on s’orientera vers le concept de **deepcopy** que nous n’allons pas détailler ici. 

## Mise en pratique: Suivi de transactions

Pour **mettre en pratique** les concepts abordés dans cette partie, essayons de résoudre un **exercice**. Comme d’habitude nous vous invitions a essayé d’aller plus loin que cet exercice en le complexifiant c’est comme ça que l’on progresse le plus 😉. 

Pour cette exercice nous allons vous fournir une **liste de transaction** sur des crypto-monnaies et le but sera d’en tirer certaines informations.

Voici la liste des transactions sous forme de liste de dictionnaires:

```python
transactions = [
    {
        "symbol": "BTC",
        "type": "buy",
        "quantity": 0.7,
        "price": 27090.4,
        "date": "2022-03-07",
    },
    {
        "symbol": "BTC",
        "type": "sell",
        "quantity": 0.1,
        "price": 26561.4,
        "date": "2022-04-12",
    },
    {
        "symbol": "BTC",
        "type": "buy",
        "quantity": 0.4,
        "price": 28090.4,
        "date": "2022-05-21",
    },
    {
        "symbol": "BTC",
        "type": "buy",
        "quantity": 0.3,
        "price": 25090.4,
        "date": "2022-06-02",
    },
    {
        "symbol": "BTC",
        "type": "sell",
        "quantity": 0.5,
        "price": 32034.67,
        "date": "2022-06-29",
    },
    {
        "symbol": "ETH",
        "type": "buy",
        "quantity": 6,
        "price": 1754,
        "date": "2022-05-21",
    },
    {
        "symbol": "ETH",
        "type": "buy",
        "quantity": 2,
        "price": 1950,
        "date": "2022-06-02",
    },
    {
        "symbol": "ETH",
        "type": "sell",
        "quantity": 3,
        "price": 2100.67,
        "date": "2022-06-29",
    },
]
```

1. A partir de cette liste et grâce à une boucle, créer un dictionnaire avec pour clés chacune des crypto-monnaies présente dans les transaction et comme valeur, un dictionnaire vide. Cela devrez vous donner le résultat suivant: 

```python
portfolio = {
    "BTC": {},
    "ETH": {},
}
```

1. À partir de cette liste et grâce à une boucle, ajoutez au dictionnaire précédent une clé `quantity` qui a pour valeur la quantité encore présente dans le portefeuille. (Il faudra notamment utiliser des conditions afin de vérifier si ce sont des achats ou des ventes).
2. Considérons le prix du BTC aujourd’hui de `35000` et celui de l’ETH de `2400`. Ajouter dans notre dictionnaire précédent notre PNL (c'est-à-dire notre bénéfice ou notre perte) pour chacune des cryptos, avec pour clé `pnl`.
3. Ajouter dans notre dictionnaire pour chacune des cryptos, notre prix moyen d’achat. 
4. (Bonus) Pour chacune des cryptos: afficher la quantité achetée à partir de la date du `2022-06-02` pour cela vous allez devoir vous renseigner sur comment interagir avec les dates, vous utiliserez la librairie `datetime`.

Cet exercice devrait vous permettre de mieux comprendre l'utilisation des boucles et des conditions appliquées aux dictionnaires et aux listes en Python dans le contexte de la finance. Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_3.ipynb. N'hésitez pas à adapter cet exemple à vos propres besoins et à explorer d'autres scénarios financiers.

Apprenez à manipuler les listes et les dictionnaires pour stocker et organiser vos données efficacement.

Les Listes et les Dictionnaires en Python

<MDX_YT videoId="qDf_JkOP86Y"/>

Dans cette partie, nous allons explorer deux autres concepts importants en programmation Python : les **fonctions** et les **classes**. 

Les fonctions permettent de regrouper des blocs de code réutilisables, tandis que les classes permettent de créer des objets avec des attributs et des méthodes spécifiques. 

Ces deux concepts sont essentiels pour **structurer et organiser votre code** de manière plus efficace, surtout lorsqu'il s'agit de résoudre des problèmes financiers complexes.

## **Les fonctions en Python**

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. 

 Elles permettent de découper un programme en parties plus petites et plus faciles à comprendre. 

Pour créer une fonction en Python, on utilise le mot-clé **`def`** suivi du nom de la fonction et d'une paire de parenthèses contenant les arguments de la fonction. Le bloc de code à exécuter est indenté sous la définition de la fonction.

Voici un exemple simple de fonction pour calculer l'intérêt composé :

```python
def compound_interest(principal, rate, time):
    amount = principal * (1 + rate) ** time
    interest = amount - principal
    return interest
```

Dans cet exemple, nous avons défini une fonction appelée **`compound_interest`** qui prend trois arguments : 
- le montant initial (**`principal`**),
- le taux d'intérêt (**`rate`**) 
- la durée en années (**`time`**).

La fonction calcule l'intérêt composé en utilisant la formule standard et retourne le résultat. Le fait de retourner le résultat grâce à **`return`** nous permet de pouvoir récupérer une valeur en faisant par exemple **`result = ma_fonction()`**. Ce n’est pas obligatoire de retourner une valeur si l’on ne souhaite pas récupérer de résultat en particulier (par exemple si on cherche juste à afficher quelque chose). 

Pour appeler cette fonction, il suffit de l'utiliser avec les arguments appropriés :

```python
initial_investment = 1000
interest_rate = 0.04
years = 5

interest = compound_interest(initial_investment, interest_rate, years)
print(f"L'intérêt composé après {years} années est de {round(interest, 2)} €")
```

Cet exemple calcule l'intérêt composé pour un investissement initial de 1000 €, un taux d'intérêt de 4 % et une durée de 5 ans.

Dans cet exemple, vous découvrez également un nouveau moyen d’attribuer une valeur à un string, grâce à l’utilisation de **`f`** devant **`“”`** et l’utilisation de **`{}`** à l’intérieur des **`“”`**.

```python
name = "Thomas"
age = 41.75254
print(f"Bonjour {name} tu as {round(age, 2)} ans")
# Affiche Bonjour Thomas tu as 41.75 ans
```

> On utilise ici la fonction `round()` pour arrondir la valeur de l’âge à 2 chiffres après la virgule
> 

Les fonctions sont particulièrement utiles pour éviter la duplication de code et pour simplifier les tâches répétitives. Par exemple, vous pouvez réutiliser la fonction **`compound_interest`** pour calculer l'intérêt composé pour différents investissements et taux d'intérêt.

### **Arguments optionnels et valeurs par défaut**

Il est possible de définir des valeurs par défaut pour certains arguments d'une fonction, ce qui les rend optionnels lors de l'appel de la fonction. Par exemple, on peut définir une valeur par défaut pour le taux d'intérêt annuel :

```python
def compound_interest(principal, time, rate=0.05):
    amount = principal * (1 + rate) ** time
    interest = amount - principal
    return interest

# Utilisation de la fonction sans spécifier le taux d'intérêt
investment = 1000
years = 5

earned_interest = compound_interest(investment, years)
print(f"L'intérêt composé sur {years} ans pour un investissement de {investment} € est de {round(earned_interest, 2)} €.")
```

Dans cet exemple, si le taux d'intérêt n'est pas spécifié lors de l'appel de la fonction **`compound_interest`**, la valeur par défaut de 0.05 sera utilisée.

```python
earned_interest = compound_interest(investment, years, 0.07)
print(f"L'intérêt composé sur {years} ans pour un investissement de {investment} € est de {round(earned_interest, 2)} €.")
```

Cet exemple quant à lui montre que l’on peut bien évidemment par ailleurs spécifier le paramètre `rate`.

Pour appeler une fonction vous pouvez également spécifier le nom de chaque paramètre avec un `=`, voici comment faire.

```python
earned_interest = compound_interest(
	rate=0.07,
	principal=investment,
	time=years,
)
print(f"L'intérêt composé sur {years} ans pour un investissement de {investment} € est de {round(earned_interest, 2)} €.")
```

On peut ainsi remarquer qu'avec l’utilisation des `=`, nous n’avons plus besoin de garder le même ordre des paramètres.

## **Classes en Python**

Une classe est une structure qui permet de créer facilement des objets qui suivent le même modèle. Les objets peuvent avoir des **attributs** (variables) et des **méthodes** (fonctions). Les classes permettent d'organiser et de structurer le code en regroupant des données et des fonctionnalités liées.

### **Exemple de classe : Compte bancaire**

Supposons que vous souhaitiez modéliser un compte bancaire avec des fonctions pour déposer, retirer et afficher le solde. Vous pouvez créer une classe **`BankAccount`** pour représenter un compte bancaire :

```python
class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        print(f"Vous avez déposé {amount} €. Nouveau solde : {self.balance} €.")

    def withdraw(self, amount):
        if amount > self.balance:
            print("Solde insuffisant.")
        else:
            self.balance -= amount
            print(f"Vous avez retiré {amount} €. Nouveau solde : {self.balance} €.")

    def display_balance(self):
        print(f"Votre solde est de {self.balance} €.")
```

Dans cet exemple, la classe **`BankAccount`** a un **attribut `balance`** et trois **méthodes** : **`deposit`**, **`withdraw`** et **`display_balance`**. La méthode spéciale **`__init__`** est appelée un **constructeur** et est exécutée lors de la création d'une instance de la classe.

### **Utilisation de la classe BankAccount**

Pour illustrer l'utilisation de la classe **`BankAccount`**, créons quelques instances et effectuons quelques opérations bancaires courantes, telles que les dépôts et les retraits.

```python
# Création d'un compte bancaire avec un solde initial de 500 €
account1 = BankAccount(500)

# Création d'un autre compte bancaire avec un solde initial de 2000 €
account2 = BankAccount(2000)

# Affichage du solde des deux comptes
account1.display_balance()
account2.display_balance()

# Dépôt de 1000 € sur le compte1
account1.deposit(1000)

# Retrait de 300 € sur le compte1
account1.withdraw(300)

# Affichage du solde des deux comptes après les opérations
account1.display_balance()
account2.display_balance()

# Dépôt de 1000 € sur le compte2
account2.deposit(1000)

# Retrait de 1500 € sur le compte2
account2.withdraw(1500)

# Affichage du solde des deux comptes après les opérations
account1.display_balance()
account2.display_balance()
```

Dans cet exemple, nous avons créé deux instances de la classe **`BankAccount`** avec des soldes initiaux différents. Nous avons effectué des dépôts et des retraits sur les deux comptes et affiché leur solde.

## **Exercice de mise en application : Classe `Portfolio`**

Dans cet exercice, nous allons créer une classe **`Portfolio`** pour gérer un portefeuille d'investissements. Le portefeuille contiendra plusieurs actifs financiers, tels que des actions ou des obligations, avec leur quantité respective et leur valeur unitaire.

Votre objectif est de définir et d'utiliser la classe **`Portfolio`** pour effectuer les opérations suivantes :

1. Ajouter un actif financier au portefeuille avec sa quantité et sa valeur unitaire.
2. Supprimer un actif financier du portefeuille.
3. Mettre à jour la quantité ou la valeur unitaire d'un actif financier.
4. Calculer la valeur totale du portefeuille.

### **Instructions**

1. Créez une classe **`Portfolio`** avec un attribut **`assets`** qui sera un dictionnaire pour stocker les actifs financiers et leurs informations (quantité et valeur unitaire).
2. Définissez une méthode **`add_asset`** pour ajouter un actif financier au portefeuille. La méthode prendra en paramètre le nom de l'actif, la quantité et la valeur unitaire. Si l'actif existe déjà dans le portefeuille, mettez à jour la quantité et la valeur unitaire.
3. Définissez une méthode **`remove_asset`** pour supprimer un actif financier du portefeuille. La méthode prendra en paramètre le nom de l'actif à supprimer.
4. Définissez une méthode **`update_asset`** pour mettre à jour la quantité ou la valeur unitaire d'un actif financier. La méthode prendra en paramètre le nom de l'actif, la nouvelle quantité et la nouvelle valeur unitaire.
5. Définissez une méthode **`calculate_total_value`** pour calculer la valeur totale du portefeuille. Cette méthode ne prendra pas de paramètres et retournera la somme des produits de la quantité et de la valeur unitaire pour chaque actif financier du portefeuille.

### **Exemple d'utilisation**

```python
# Création d'un portefeuille vide
my_portfolio = Portfolio()

# Ajout d'actifs financiers
my_portfolio.add_asset("AAPL", 10, 150)
my_portfolio.add_asset("GOOG", 5, 1000)
my_portfolio.add_asset("TSLA", 8, 800)

# Mise à jour d'un actif financier
my_portfolio.update_asset("AAPL", 12, 160)

# Suppression d'un actif financier
my_portfolio.remove_asset("GOOG")

# Calcul de la valeur totale du portefeuille
total_value = my_portfolio.calculate_total_value()
print(f"La valeur totale du portefeuille est de {total_value} €.")
```

Cet exercice vous permettra de pratiquer la création et l'utilisation de classes en Python dans le contexte de la finance. Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_4.ipynb. N'hésitez pas à adapter cet exemple à vos propres besoins et à explorer d'autres fonctionnalités liées à la gestion d'un portefeuille d'investissements.

## **Récapitulatif**

Dans cette partie, nous avons abordé les concepts de fonctions et de classes en Python, qui sont des éléments essentiels pour structurer et organiser votre code. Nous avons vu comment définir des fonctions et des classes, ainsi que comment les utiliser dans des exemples concrets liés à la finance.

En maîtrisant ces concepts, vous pourrez écrire des programmes plus complexes et modulaires, ce qui facilitera la maintenance et l'évolution de votre code.

Dans la suite de cette formation, nous explorerons des bibliothèques spécifiques à la finance qui vous permettront d'analyser des données financières et de créer des modèles prédictifs.

Découvrez comment créer et utiliser des fonctions et des classes pour structurer votre code et faciliter la réutilisation.

Les Fonctions et les Classes en Python

<MDX_YT videoId="2qScFPQ5mv8"/>

Dans le secteur de la finance, on peut affirmer sans trop prendre de risque que le logiciel le plus utilisé est Excel. Dans cet épisode, nous allons découvrir une librairie qui va nous permettre de **faire tout ce qui peut se faire en Excel en mieux**. 📊

## **Introduction à Pandas**

Pandas est une **bibliothèque** Python très populaire qui fournit des **structures de données** flexibles et des outils d'**analyse des données**. Elle est particulièrement adaptée pour traiter des données financières et est largement utilisée dans la communauté financière. Pandas est construite sur la bibliothèque **NumPy**, qui est une bibliothèque de calcul scientifique pour Python.

Dans cette partie, nous allons explorer les fonctionnalités de base de Pandas, y compris la création, la manipulation et l'analyse de données financières.

## **Installation et importation de Pandas**

Nous découvrons avec Pandas l’utilisation de librairie/bibliothèque. En effet, le langage de programmation Python permet d’importer des librairies qui facilitent grandement le développement. La diversité des librairies disponibles sur Python est une de ses plus grandes forces. Ces librairies s’installent grâce au gestionnaire de bibliothèque *pip* qui a dû être installé lors de l’installation de Python.

Pour utiliser Pandas, il faut d'abord l'installer en exécutant la commande suivante dans votre terminal ou invite de commandes :

```python
pip install pandas
```

Une fois installé, vous pouvez importer Pandas dans votre script Python en ajoutant cette ligne :

```python
import pandas as pd
```

L'alias "pd" est couramment utilisé pour Pandas, c’est un raccourci qui nous permet de diminuer le nombre de caractères à taper par la suite.

## **Les objets DataFrame et Series**

Les principaux objets de Pandas sont les **DataFrame** et les **Series**. Un DataFrame est une structure de données bidimensionnelle, similaire à une table de base de données ou un classeur Excel. Une Series, en revanche, est une structure de données unidimensionnelle, semblable à une liste ou une colonne d'un DataFrame. Que ce soit les Series ou les DataFrames, ils ont tous les deux des Index. Si l’on ne spécifie pas d’index à la création de nos DataFrames ou Series, un index par défaut allant de 0 à la taille de notre tableau. Ainsi chaque ligne de notre DataFrame ou notre Serie dispose d’un index.

![pandas dataframe](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/pandas_dataframe65415_091e4118ff.png)

Voici un exemple de création d'un DataFrame avec des données financières :

```python
import pandas as pd

data = {
    "date": ["2022-01-01", "2022-01-02", "2022-01-03", "2022-01-04"],
    "close": [150.0, 152.0, 153.0, 154.0],
    "volume": [1000, 1200, 1300, 1250],
}

df = pd.DataFrame(data)

print(df) # Affiche le DataFrame
print(df.index) # Affiche nos Index
print(df["close"]) # Affiche la Serie "closeé
```

Dans cet exemple, nous avons créé un dictionnaire contenant trois listes de même longueur : **`date`**, **`close`** et **`volume`**. Ces listes représentent respectivement les dates, les prix de clôture et les volumes d'un actif financier. Nous utilisons ensuite la fonction **`pd.DataFrame()`** pour créer un DataFrame à partir de ces données. Notez comment nous accédons à différentes composantes du DataFrame dans les print.

## **Manipulation et analyse des données financières avec Pandas**

Pandas offre de nombreuses fonctionnalités pour manipuler et analyser les données financières. Voici quelques exemples courants :

### Sélectionner des lignes ou des colonnes

Voici des exemples qui vont permettre de sélectionner des colonnes, des lignes, des valeurs ou plusieurs colonnes.

```python
close_column = df["close"]
print(close_column)

first_row = df.iloc[0]
print(first_row)

first_close = df.iloc[0]["close"]
print(first_close)

close_volume_columns = df[['volume', 'close']]
print(close_volume_columns)
```

Pour sélectionner des lignes en fonction d'une condition, vous pouvez utiliser des opérations de comparaison sur les colonnes du DataFrame. Par exemple, pour sélectionner toutes les lignes dans lesquelles le volume est supérieur à 1210:

```python
best_volume_rows = df.loc[df['volume'] > 1210]
print(best_volume_rows)
```

### **Lecture de données à partir de fichiers CSV ou Excel**

Dans la pratique, les données financières sont souvent stockées dans des fichiers CSV ou Excel. Les fichiers CSV sont des textes avec des données représentées en tableau. Chaque donnée est séparée par un séparateur comme une virgule par exemple. Pandas facilite la lecture de ces fichiers et la création de DataFrames à partir de leurs données :

![pandas data](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/pandas8484_742250827b.png)

Vous trouverez ici [https://github.com/CryptoRobotFr/python-pour-la-finance/blob/main/APPL_1D.csv](https://github.com/CryptoRobotFr/python-pour-la-finance/blob/main/APPL_1D.csv) un fichier CSV représentant le prix de l’action APPL jours par jours. Vous pouvez le télécharger fichier qui se trouve sur GitHub et le placer dans le même dossier que votre fichier python. 

![olhcv csv github](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/ohlcv6845_537b5870df.png)

Pour télécharger le fichier, il suffit de cliquer sur l’icône de téléchargement (entouré en rouge sur l’image ci-dessus)

> GitHub est une plateforme de développement de logiciels permettant aux développeurs de collaborer sur des projets, de suivre et de contrôler les changements dans le code. C’est également ici que sont publiés la plupart des codes “open source” notamment ceux proposés par Crypto Robot.
> 

Ces données sont dans le format OHLCV. C’est un format fréquemment utilisé pour représenter le prix d’un actif pour une période donnée (ici toute les 4 heures) : le prix d’ouverture (Open), le prix le plus haut au cours de la période (High), le prix le plus bas (Low), le prix de clôture (Close) et enfin le Volume.

Une fois le fichier csv téléchargé et placé dans votre dossier de travail, vous pouvez lire votre fichier CSV afin de le stocker dans un DataFrame. Pour cela :

```python
df = pd.read_csv("APPL_1D.csv)
print(df)
```

Dans ce cas, nous avons lu le fichier pour stocker le contenu dans la variable **`df`,** cela revient à faire ce que l’on avait fait lors de la création de notre premier DataFrame comme ceci :

```python
data = {
    "date": ["2022-01-01", "2022-01-02", "2022-01-03", "2022-01-04"],
    "close": [150.0, 152.0, 153.0, 154.0],
    "volume": [1000, 1200, 1300, 1250],
}

df = pd.DataFrame(data)
```

Sauf que dans ce cas, au lieu de spécifié nos données “à la main”, elles viennent directement d’un fichier.

## **Exploration et manipulation des données financières**

Une fois que vous avez stocké vos données financières dans un DataFrame Pandas, vous pouvez facilement **explorer et manipuler** ces données. Par exemple, vous pouvez calculer des **statistiques descriptives**, **filtrer** les données selon certaines conditions.

### Explorer les données financières

Dans un premier temps, une bonne pratique lorsque vous exploitez un fichier, est d’explorer rapidement les données de ce fichier afin de s’assurer de la qualité des données. En effet dans la réalité vos données seront rarement parfaites et prêtes pour analyse. Il faudra souvent “nettoyer” vos données. Pour explorer vos données rapidement il existe la méthode **`describe()`**.

```python
df = pd.read_csv("APPL_1D.csv")
print(df.describe())
```

![panas ohlcv](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/panas_ohlcv654_af5d437ab1.png)

Il est probable que votre affichage comporte des notations scientifique avec par exemple **`e+03`**, cela signifie dans ce cas x10 à la puissance 3, soit x1000. Cela est notamment utile lorsque l’on a des nombres très petits ou très grands. 

Dans notre cas cela nuit à notre analyse donc vous pouvez insérer cette ligne de code par exemple en dessous de l’importation de pandas afin d’arrondir tous les nombres à 2 chiffres après la virgule:

```python
pd.set_option('display.float_format', lambda x: '%.2f' % x)
```

La méthode **`describe()`** nous donne pour chaque colonne plusieurs informations.
La ligne **`count`** représente le nombre d’occurrences, les lignes **`25%`**, **`50%`** et **`75%`** représentes ce qu’on appelle des quantiles, nous ne rentrerons pas en détail ici. La ligne **`std`** représente l’écart type (standard deviation). Les autres lignes sont assez explicite par leurs noms (**`mean`**, **`min`**, **`max`**).

Avec un peu d’observation nous pouvons remarquer plusieurs “problèmes” dans nos données. 

Le premier étant la présence de la colonne **`Volume MA`** dont nous ne connaissons pas la signification et qui n’a donc aucun intérêt.

Le deuxième est que les colonnes **`time`** et **`open`** ont 2920 occurrences alors que les autres colonnes n’en n’ont que 2919. Il faudra trouver la ligne ou les autres colonnes n’ont pas de valeurs.

Ensuite la colonne **`time`** est au format numérique que l’on ne peut pas comprendre.

Enfin si l’on regarde dans le détail on voit que le minimum de la colonne **`open`** est de 0. Cela semble peu probable que le prix d’ouverture de l’action APPLE ai été à 0$ à un moment.

- Pour enlever la colonne Volume MA vous pouvez exécuter le code suivant:
    
    ```python
    df = df.drop("Volume MA", axis=1)
    ```
    
- Dans un premier temps il faut trouver où se trouve nos valeurs qui n’ont pas d’occurrences. Pour cela on peut chercher les valeurs null de la colonne close par exemple:
    
    ```python
    print(df.loc[df["close"].isnull()])
    ```
    
    
![pandas row](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/641358_0ee52f1e79.png)
    
    Nous remarquons ici que c’est la dernière ligne (avec l’index 2919) qui contient un valeur pour la colonne **`time`** et **`open`** mais pas pour les autres (les valeurs NaN signifient “Not a Number”). Cela est surement du au fait que au moment de la récupération des données, la journée n’était pas clôturée et donc que le prix le plus haut, le plus bas, le volume ainsi que le prix de clôture n’était pas disponible. Le plus simple ici pour éviter des problèmes par la suite est de supprimer cette ligne. Pour supprimer la ligne avec l’index 2919:
    
    ```python
    df = df.drop(2919)
    ```
    
- Nous pouvons remarquer que la colonne time comprend des nombres très grands. Après un peu de recherche nous pouvons comprendre que ce sont des dates en format timestamp. Les nombres en question représente le nombre de seconde passée depuis 1970. Heureusement pandas possède une méthode pour convertir ces nombres en dates.

```python
df["time"] = pd.to_datetime(df["time"], unit='s')
print(df["time"])
```

![pandas date](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/pandas_date_3cdf022a2e.png)

Nous avons maintenant des dates lisibles. Ce que nous pouvons faire maintenant c’est remplacer nos index par déaut (1, 2, 3…). Une fois que cela sera fait nous n’aurons plus besoin de notre colonne time donc nous pourrons la supprimer. Pour cela:

```python
df = df.set_index(df['time'])
del df['time']
```

Le fait que nos dates soient en index nous permet par exemple de selectionner une ou ou plusieurs lignes grâce aux dates très simplement:

```python
print(df.loc["2023-05-04"]) # Afiche les valeurs au 4 mai 2023
print(df.loc["2023-03"]) # Afiche toutes les valeurs du mois de mars 2023
print(df.loc["2023-03-03":"2023-03-15"]) # Afiche les valeurs au 3 mars au 15 mars 2023
```

### **Créer de nouvelles colonnes à partir des colonnes existantes**

Pandas vous permet de créer aisément de nouvelles colonnes en fonction des colonnes existantes. Par exemple, vous pouvez créer une colonne qui représente la moyenne entre le prix d’ouverture et de clôture :

```python
df["mean_open_close"] = (df["open"] + df["close"]) / 2
print(df["mean_open_close"])
```

Ce qu’il faut bien comprendre ici, c'est que nous appliquons l’opération sur toutes les lignes. **Vous n’avez pas besoin de faire une boucle** pour appliquer ce changement à chacune des lignes. Les boucles en Python ont tendance à être lente en temps d’exécution, alors lorsqu’il est possible de les éviter, if faut en profiter.

### **Calculer des statistiques descriptives**

Pandas propose des fonctions pour calculer des statistiques descriptives sur vos données financières. Par exemple, vous pouvez calculer la moyenne, la médiane, l'écart-type, et d'autres statistiques sur les prix des actions de chaque entreprise.

```python
# Calculer des statistiques descriptives pour chaque colonne
mean_prices = df["close"].mean()
median_prices = df["close"].median()
std_prices = df["close"].std()

print("Moyenne des prix de clôtures:", mean_prices)
print("Médiane des prix de clôtures:", median_prices)
print("Écart-type des prix de clôtures:", std_prices)
```

## Calculer une moyenne mobile

Une moyenne mobile est une moyenne du prix roulante. Cela signifie par exemple que pour chaque date la valeur de la moyenne mobile sera la moyenne des 50 dernières dates. Pour calculer des valeurs roulantes avec pandas on utilise **`rolling(50)`** suivi de l’opération que l’on souhaite faire. Pour calculer la moyenne mobile des 50 derniers jours vous utiliserai **`rolling()`** suivi de **`mean()`**.

```python
df["moving_average"] = df["close"].rolling(50).mean()
```

## **Calculer les rendements et la volatilité**

Après avoir chargé et préparé les données, vous pouvez effectuer diverses analyses financières. Par exemple, vous pouvez calculer les rendements quotidiens et la volatilité de votre actif. La volatilité est une mesure du risque associé à un investissement et est généralement calculée comme l'écart-type des rendements sur une période définie.

Voici un exemple de calcul des rendements quotidiens et de la volatilité sur une fenêtre glissante de 30 jours à l'aide de Pandas :

```python
# Calculer les rendements quotidiens
df["daily_returns"] = df["close"].pct_change()

print(df["daily_returns"].head())

# Calculer la volatilité sur 30 jours glissants
df["volatility"] = df["daily_returns"].rolling(window=30).std()

print(df["volatility"].head())
```

Dans cet exemple, nous utilisons la méthode **`pct_change()`** pour calculer les rendements quotidiens à partir des prix des actions. Ensuite, nous utilisons la méthode **`rolling()`** pour créer une fenêtre glissante de 30 jours, suivie de la méthode **`std()`** pour calculer l'écart-type (c'est-à-dire la volatilité) des rendements sur cette fenêtre glissante.

Notez que les premières 29 lignes de la colonne **`volatility_30`** contiendront des valeurs NaN (Not a Number), car il n'y a pas suffisamment de données pour calculer la volatilité sur 30 jours pour ces lignes. La méthode **`head()`** permet d’afficher les 5 premières lignes.

### **Trier les données**

Pour trier les données selon une colonne, vous pouvez utiliser la méthode **`sort_values()`** sur votre DataFrame. Par exemple, pour trier les données par ordre croissant de volatilité sur 30 jours:

```python
df["daily_returns"] = df["close"].pct_change()
df["volatility"] = df["daily_returns"].rolling(window=30).std()
print(df.sort_values(by="volatility", ascending=True))
print(df.sort_values(by="daily_returns", ascending=True))
```

Dans cet exemple, nous commencer par créer 2 nouvelles colonnes à notre DataFrame **`df`**. Nous affichons ensuite simplement notre DataFrame `**df**` en allant de la volatilité la plus faible à la plus élevée. Puis nous affichons les journées ayant eu le plus de rendements de la plus faible à la plus élevée.

### Maîtriser ses données

Pandas est une librairie très complète pour laquelle nous ne pourrons pas découvrir toutes les fonctionnalités. 

Ce qu’il faut savoir c’est qu’à peu près toute manipulation de données est possible grâce à Python et la librairie Pandas, **les limites seront vos capacités techniques** mais aussi et surtout **vos capacités algorithmiques**. Ce que l’on veut dire ici, c'est que la plus grosse difficulté est souvent de savoir exactement ce que l’on souhaite faire afin de rechercher l’information sur internet ou sur la documentation officielle Pandas. **ChatGPT** est aujourd’hui un super outil pour vous aider là-dessus.

Ce qui va donc être clé, comme nous vous l’avons déjà dit, sera de s’entraîner avec des cas pratiques. C’est pour cela que nous vous proposons un exercice d’application pertinent pour apprendre, mais c’est encore mieux si vous vous entrainez sur vos propres données / problématiques. 

 

## Exercice d’application : le Titanic

Pour cette exercice nous allons analyser les données liées au naufrage du titanic. Vous trouverez via ce lien https://github.com/CryptoRobotFr/python-pour-la-finance/blob/main/TITANIC.csv un fichier CSV représentant chacun des passagers du titanic avvec notamment leurs noms, leurs sexes, leurs classes (Pclass), leurs âges ainsi que d’autres informations.

![titanic](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/titanic65465_ab991df8ba.png)

### Instructions

Commencer par télécharger le fichier CSV, placer le dans votre répertoire, importer pandas dans votre fichier python et importer votre CSV sous la forme de DataFrame avec:

```python
df = pd.read_csv('TITANIC.csv')
```

Attention pour cette exercice vous aurez besoin de méthodes que nous n’avons pas encore vu comme **`value_counts()`** ou **`groupby()`**, le but est que vous puissiez faire des recherches par vous même.

### Questions

1. Affichez les 10 premières lignes de ce dataset pour avoir un aperçu des données.
2. Quelle est la taille de ce dataset ? (Combien de lignes et de colonnes)
3. Combien y a-t-il de passagers dans chaque classe (Pclass) ?
4. Quel est l'âge moyen des passagers ? Quel est le nom du passager le plus jeune ? Et le plus âgé ?
5. Combien de passagers ont survécu et combien sont décédés ?
6. Combien de femmes et combien d'hommes se trouvaient sur le Titanic ?
7. Combien de femmes ont survécu ? Et combien d'hommes ?
8. Quelle est la proportion de survie par classe ?
9. Créez une nouvelle colonne 'FamilySize' qui est la somme des colonnes 'SibSp' (nombre de frères et sœurs ou époux) et 'Parch' (nombre de parents ou d'enfants).
10. Quel est le nom de la personne n’ayant pas survécu qui avait le plus de membre dans sa famille ?

Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_5.ipynb

Apprenez à utiliser Pandas, une librairie puissante pour la manipulation et l'analyse de données, spécialement adaptée pour travailler avec des données financières.

La librairie Pandas, la meilleure librairie pour les données financières

<MDX_YT videoId="N59ariW4VLY"/>

Une fois que vous avez manipulé et analysé vos données financières avec Pandas, il est essentiel de les visualiser pour mieux comprendre les tendances et les relations entre les différentes variables. Dans cette partie, nous allons découvrir comment créer des graphiques pertinents avec la bibliothèque **Matplotlib**, l'une des bibliothèques de visualisation les plus populaires pour Python.

## **Introduction à Matplotlib**

Matplotlib est une bibliothèque de visualisation de données pour Python qui permet de créer une grande variété de graphiques, tels que des graphiques à barres, des histogrammes, des nuages de points et des graphiques en courbes. Elle est particulièrement adaptée pour visualiser des données financières et est souvent utilisée en combinaison avec Pandas.

## **Installation et importation de Matplotlib**

Pour utiliser Matplotlib, il faut d'abord l'installer en exécutant la commande suivante dans votre terminal ou invite de commandes :

```python
pip install matplotlib
```

Une fois installé, vous pouvez importer Matplotlib dans votre script Python en ajoutant cette ligne :

```python
import matplotlib.pyplot as plt
```

L'alias "plt" est couramment utilisé pour Matplotlib et facilite l'accès aux fonctions de la bibliothèque.

## **Créer des graphiques avec Matplotlib et Pandas**

Maintenant que nous avons importé Matplotlib, nous pouvons créer des graphiques pour visualiser nos données financières. Dans cette section, nous allons explorer quelques exemples de graphiques couramment utilisés dans le secteur de la finance.

### Première utilisation : les graphiques linéaires

Le graphique le plus simple est le graphique linéaire, créé en utilisant la méthode **`plt.plot()`**. Par exemple :

```python
x = [1, 2, 3, 4, 5]
y = [10, 20, 30, 40, 50]

plt.plot(x, y)
plt.show()
```

![matplotlib0.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/matplotlib0_022ec41580.png)

On construit un graphique à partir de 2 listes, une pour les abscisses et une pour les ordonnées

### Ajouter des légendes

Vous pouvez compléter votre graphique en y ajoutant des titres :

```python
x = [1, 2, 3, 4, 5]
y = [10, 20, 30, 40, 50]

plt.plot(x, y)
plt.xlabel("Axe X")
plt.ylabel("Axe Y")
plt.title("Graphique test")
plt.show()
```

![matplotlib1.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/matplotlib1_48272b5045.png)
On a ici ajouté un titre à chaque axe ainsi qu’un titre global au graphique.

### ****Diagrammes à barres****

Un autre type de graphique couramment utilisé est le diagramme à barres. Vous pouvez l'obtenir avec la méthode **`plt.bar()`**.

```python
plt.bar(x, y)
plt.show()
```

![matplotlib2.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/matplotlib2_5dfa2cb0e9.png)

### Les nuages de points

Les nuages de points peuvent aider à représenter des données afin de comparer les points de donnée entre eux. Il suffit d’utiliser la méthode **`plt.scatter()`**.

```python
plt.scatter(x, y)
plt.show()
```

## Visualiser des données complexes avec Pandas et Matplotlib

Pour utiliser un exemple concret, nous allons travailler sur le dataset "House Sales in King County, USA". Ce dataset représente les ventes de maison à King County. Pour chaque maison, vous avez certaines informations de la maison comme sa surface et son nombre de chambres mais surtout son prix de vente. Vous pouvez télécharger le dataset via ce lien https://github.com/CryptoRobotFr/python-pour-la-finance.

Commencez par charger le dataset avec Pandas.

```python
import pandas as pd

df = pd.read_csv('kc_house_data.csv')
```

Voici un descriptif des différentes colonnes du dataset.

- id : C'est l'identifiant unique pour chaque maison vendue.
- date : C'est la date de la vente de la maison. Cela peut être important car les tendances du marché immobilier peuvent varier avec le temps.
- price : C'est le prix de vente de la maison. C'est souvent la variable cible dans les modèles de prédiction immobilière.
- bedrooms : C'est le nombre de chambres à coucher dans la maison.
- bathrooms : C'est le nombre de salles de bains dans la maison. Les demi-salles de bains (toilette sans douche ni baignoire) peuvent être comptabilisées comme 0.5.
- sqft_living : C'est la superficie habitable de la maison en pieds carrés.
- sqft_lot : C'est la superficie totale du terrain de la maison en pieds carrés.
- floors : C'est le nombre d'étages de la maison.
- waterfront : C'est une variable indiquant si la maison a une vue sur l'eau (un lac, une rivière, la mer, etc.). C'est souvent une variable binaire (0 = pas de vue sur l'eau, 1 = vue sur l'eau).
- view : C'est une évaluation de la qualité de la vue depuis la maison. Le système de notation peut varier, mais souvent une échelle de 0 à 4 est utilisée.
- condition : C'est une évaluation de l'état général de la maison. Comme pour view, cela est souvent noté sur une échelle, avec une plus grande valeur indiquant un meilleur état.
- grade : C'est une évaluation de la qualité de la construction et du design de la maison. Les maisons avec des matériaux de construction de meilleure qualité et des conceptions plus élaborées recevront une note plus élevée.
- sqft_above : C'est la superficie habitable qui est au-dessus du niveau du sol, en pieds carrés.
- sqft_basement : C'est la superficie du sous-sol de la maison, en pieds carrés.
- yr_built : C'est l'année de construction de la maison.
- yr_renovated : C'est l'année de la dernière rénovation de la maison. Si la maison n'a jamais été rénovée, cette valeur pourrait être 0.
- zipcode : C'est le code postal de la maison. Cela peut être important car l'emplacement a un impact majeur sur les prix des maisons.
- lat : C'est la latitude de la maison, une composante de sa position géographique.
- long : C'est la longitude de la maison, une autre composante de sa position géographique.
- sqft_living15 : C'est la superficie habitable moyenne des 15 maisons les plus proches, en pieds carrés.
- sqft_lot15 : C'est la superficie du terrain moyenne des 15 maisons les plus proches, en pieds carrés.

Vous pouvez utiliser **`df.describe()`** pour analyser vos données, mais le dataset est assez propre, vous n’aurez normalement pas de retraitement à réaliser.

### Les histogrammes

Les histogrammes sont utiles pour visualiser la distribution des données. Utilisez **`plt.hist()`** pour cela. Le paramètre bins permet de spécifier le nombre de barres que vous souhaitez. Nous pouvons par exemple observer la distribution du prix de ventes de nos maisons:

```python
plt.hist(df["price"], bins=100)
plt.show()
```

![matplotlib3.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/matplotlib3_dd618834ec.png)

L’échelle des abscisses est en notation scientifique (1e6 représente 1x10 puissance 6 donc 1000000). On voir que la grande majorité des maisons de notre dataset sont comprises entre 0 et 2 millions de dollar. Cependant on voit que certaines maisons se sont vendues plus de 7 millions de dollar. Si l’on souhaite observer un peu mieux la distribution entre 0 et 2 millions de dollar nous pouvons réaliser un filtre :

```python
plt.hist(df.loc[df["price"]<2000000]["price"], bins=100)
plt.show()
```

![matplotlib4.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/matplotlib4_74e8635a3c.png)

On remarque ici que la grande majorité des maisons se trouve entre 250k et 500k dollar. Chaque barre représente le nombre de maison pour un certains interval de prix.

Le paramètre **`bins`** représente le nombre de barre que l’on souhaite, plus le paramètre sera élevé plus on aura de détail dans la répartition des données.

### Nuages de points avec couleurs variables

Il serait intéressant de regarder si il y a une relation entre la taille de la maison et son prix de vente. Le nuage de point est parfait pour cela.

```python
plt.scatter(df['sqft_living'], df['price'], s=5, c=df['sqft_living'], cmap='inferno')
plt.title('Prix en fonction de la surface habitable')
plt.xlabel('Surface habitable')
plt.ylabel('Prix')
plt.show()
```

![matplotlib5.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/matplotlib5_c46a6a7bd1.png)

Le paramètre **`s`** défini la taille des points, le paramètre **`c`** défini la variation de couleur des points, plus la couleur tire vers le rouge plus le prix est élevé. C’est le paramètres **`cmap`** qui défini la plage de couleurs.

![matplotlib6.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/matplotlib6_2aa3027f56.png)

### **Graphiques temporels**

Un autre type de graphique utile dans le domaine financier est le graphique temporel qui permet de représenter l'évolution des variables en fonction du temps. Prenons un exemple avec notre dataset. Si nous voulons observer l'évolution du prix moyen des maisons au cours du temps, nous devons d'abord convertir la colonne de date en format datetime.

```python
df['date'] = pd.to_datetime(df['date'])
```

Ensuite, nous pouvons grouper les données par mois et calculer le prix moyen :

```python
df_grouped = df.resample('M', on='date').mean()
```

Enfin, nous pouvons tracer l'évolution du prix moyen :

```python
plt.plot(df_grouped.index, df_grouped['price'])
plt.xlabel('Date')
plt.ylabel('Prix moyen')
plt.title('Evolution du prix moyen des maisons au fil du temps')
plt.show()
```

## Autres graphiques

Via ce lien [https://matplotlib.org/stable/gallery/index](https://matplotlib.org/stable/gallery/index), vous trouverez toute une galerie d’exemples de graphique possibles à réaliser avec Matplotlib.

### Seaborn, une autre librairie de visualisation

Alors que Matplotlib est une bibliothèque puissante et flexible pour la visualisation de données, son interface peut parfois être un peu complexe pour des tâches de visualisation plus avancées. C'est là qu'intervient Seaborn. Seaborn est une bibliothèque de visualisation de données en Python qui est construite sur Matplotlib. Elle offre une interface de haut niveau, ce qui rend la création de graphiques plus complexes un peu plus simple. Seaborn est particulièrement utile pour créer des graphiques statistiques attrayants et informatifs, et pour visualiser des données complexes avec plusieurs variables. Elle offre une variété de types de graphiques tels que les graphiques de distribution, les graphiques matriciels, et bien plus encore. En outre, Seaborn s'intègre bien avec les DataFrames de Pandas, ce qui facilite la visualisation directe des données de votre DataFrame. Avec ce lien, vous trouverez une liste d’exemple [https://seaborn.pydata.org/examples/index.html](https://seaborn.pydata.org/examples/index.html).

Voici un exemple d’utilisation :

```python
import seaborn as sns # pip install seaborn pour installer la librairie
sns.scatterplot(x='sqft_living', y='price', data=df)
plt.show()
```

## **Conclusion**

Comme vous pouvez le constater, Matplotlib est un outil puissant pour la visualisation de données en Python. Il offre une grande flexibilité et peut être utilisé pour créer une large gamme de graphiques et de visualisations, qui peuvent être extrêmement utiles dans le domaine de la finance pour comprendre les tendances et les relations entre différentes variables.

N'oubliez pas que la clé d'une bonne visualisation est qu'elle doit être informative et facile à comprendre. Il est donc important de toujours prendre le temps de bien formater vos graphiques, d'ajouter des titres, des légendes et des étiquettes d'axe appropriés, et de choisir les types de graphiques qui illustrent le mieux vos données.

## **Exercice d'application : Analyse et visualisation de données financières avec Matplotlib et Seaborn**

Pour cet exercice, nous allons continuer à utiliser le dataset "House Sales in King County, USA". L'objectif de cet exercice est d'approfondir votre compréhension de l'analyse et de la visualisation de données financières.

### **Partie 1 : Afficher les 5 plus grands volumes de ventes par année**

Votre premier défi consiste à extraire l'année de la colonne 'date' et à compter le nombre de ventes par an. Ensuite, affichez un graphique à barres des cinq années avec le plus grand volume de ventes. Utilisez Matplotlib pour cela.

### **Partie 2 : Afficher la distribution des prix pour les maisons avec vue sur l'eau versus sans vue sur l'eau**

Utilisez la méthode **`hist()`** de Matplotlib pour afficher deux histogrammes sur le même graphique : un pour la distribution des prix des maisons avec vue sur l'eau et un pour ceux sans vue sur l'eau. Assurez-vous d'ajouter une légende pour distinguer les deux histogrammes.

### **Partie 3 : Diagramme de corrélation**

Utilisez Seaborn pour créer une heatmap de corrélation entre les variables 'price', 'sqft_living', 'grade', 'sqft_above' et 'sqft_living15'. Quelles conclusions pouvez-vous tirer de cette heatmap ?

### **Partie 4 : Boxplot du prix par grade**

Le 'grade' dans notre dataset est une évaluation de la qualité de la construction et du design de la maison. Utilisez Seaborn pour créer un boxplot du prix de la maison par 'grade'. Qu'observez-vous sur la relation entre le 'grade' et le 'price' ?

### **Partie 5 : Scatterplot de 'price' vs 'sqft_living' avec une régression linéaire**

Créez un scatterplot de 'price' en fonction de 'sqft_living'. Utilisez la fonction **`lmplot()`** de Seaborn pour afficher également une ligne de régression linéaire. Quelle relation pouvez-vous observer entre la taille de la maison et son prix ?


Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_6.ipynb.

Découvrez comment créer des graphiques et des visualisations interactives de vos données financières en utilisant la librairie Matplotlib.

Visualiser ses données en Python grâce à Matplotlib

Apprenez à tirer le meilleur parti de Pandas en évitant les boucles et en utilisant des techniques avancées pour manipuler et analyser vos données.

Déverrouiller la puissance de Pandas et éviter les boucles

<MDX_YT videoId="BOb0Jt7xMdg"/>

*"Le temps, c'est de l'argent"*, dit un vieux dicton. Dans le monde effréné de la finance, cela n'a jamais été aussi vrai. **Les dates** et les **séquences temporelles** sont le pouls des marchés financiers, influençant chaque décision, chaque analyse, chaque transaction. Que vous traquiez la performance d'un stock sur une décennie ou analysiez les fluctuations du marché minute par minute, une maîtrise précise des dates est absolument cruciale. 

Dans cet épisode, nous dévoilerons les mystères de la manipulation des dates en Python, en vous offrant les clés pour naviguer avec aisance dans le temps.

## **Introduction aux dates en Python**

### **Le module `datetime`**

En Python, la gestion des dates est assurée principalement par le module **`datetime`**. Il propose des classes pour manipuler aussi bien des dates (année, mois, jour) que des instants précis (ajoutant heures, minutes, secondes).

Voici comment créer vos premiers objets **date** et **datetime** en Python:

```python
import datetime

# Créer une date simple
d = datetime.date(2023, 8, 21)
print(d)  # Affiche "2023-08-21"

# Créer un instant précis (timestamp)
dt = datetime.datetime(2023, 8, 21, 14, 30)
print(dt)  # Affiche "2023-08-21 14:30:00"
```

Pour obtenir la date courante ou le moment précis actuel :

```python
today = datetime.date.today()
print(today)  # Affiche la date d'aujourd'hui

now = datetime.datetime.now()
print(now)  # Affiche le moment précis actuel
```

## **2. Formats courants de dates**

### **2.1 String**

Les dates sont souvent représentées sous forme de **chaînes de caractères**, en particulier lorsqu'elles sont lues depuis des fichiers ou des bases de données.

```python
date_string = "2023-08-21"

# Convertir un string en objet datetime
date_object = datetime.datetime.strptime(date_string, "%Y-%m-%d")
print(date_object)

# Un autre exemple avec jour/mois/année et heures:minutes
date_string2 = "21/08/2023 14:30"
date_object2 = datetime.datetime.strptime(date_string2, "%d/%m/%Y %H:%M")
print(date_object2)
```

### **2.2 Timestamp Unix**

Le **timestamp Unix** représente le nombre de secondes (ou millisecondes) écoulées depuis le 1er janvier 1970, appelé **"epoch"**. C'est un format compact et universel largement utilisé en finance.

```python
import time

# Obtenir le timestamp actuel
timestamp = time.time()
print(timestamp)

# Conversion d'un timestamp vers datetime
date_from_timestamp = datetime.fromtimestamp(timestamp)
print(date_from_timestamp)

# Exemple avec millisecondes
timestamp_millis = timestamp * 1000
date_from_millis = datetime.fromtimestamp(timestamp_millis / 1000)
print(date_from_millis)
```

### 2.3 Résumé des types de date

Si nous souhaitons résumer, il existe majoritairement 4 formats pour stocker une date :

- Le format **chaîne de caractère** exemple `“2023-08-28”` qui est de type `string`.
- Le format **timestamp** par exemple `1693233091.2038012` qui est de type `float` et qui représente le nombre de secondes depuis 1970 (ou millisecondes).
- Le format **datetime** qui est le format utilisé majoritairement utiliser par python pour stocker des dates avec les heures et secondes, exemple `datetime.datetime(2023, 8, 21, 14, 30)`, cet objet est de type `datetime.datetime`.
- Le format **date** qui est le format utilisé majoritairement utiliser par python pour stocker des dates sans heures ou secondes, exemple `datetime.date(2023, 8, 21)`, cet objet est de type `datetime.date`.

## **3. Conversion entre les formats de dates**

Naviguer entre les différents formats est un besoin courant.

```python
# De datetime vers string
formatted_date = date_object.strftime("%Y-%m-%d")
print(formatted_date)  # "2023-08-21"

# Un autre format
formatted_date2 = date_object.strftime("%d %B %Y")
print(formatted_date2)  # "21 August 2023"

# De datetime vers timestamp (secondes depuis l'epoch)
timestamp_from_date = date_object.timestamp()
print(timestamp_from_date)

# Et en millisecondes
timestamp_millis_from_date = timestamp_from_date * 1000
print(timestamp_millis_from_date)
```

Vous avez ci-dessus plusieurs exemples de conversion d’un format de date à un autre. Ces exemples ne sont pas exhaustifs et il faudra vous renseigner en fonction de vos besoins.

## ****4. Utilisation des dates avec Pandas****

Après avoir exploré les bases de la manipulation des dates en Python, il est temps de passer à la vitesse supérieure en intégrant ces connaissances avec **Pandas**. Si vous êtes dans le monde de la finance, Pandas sera votre outil de prédilection pour une multitude de tâches, notamment le traitement des séries temporelles financières. Dans cet épisode, nous allons voir comment Pandas peut nous aider à **manipuler des dates** pour des cas très spécifiques liés à la finance, comme les séries temporelles des prix du Bitcoin (BTC).

### 4.1 Création du DataFrame et conversion du format de date

Pour ces exemples, nous allons charger notre DataFrame à parti d’un fichier csv déjà présenté lors de la formation précédente https://github.com/CryptoRobotFr/python-pour-la-finance/blob/main/BTC-USDT.csv. Ce csv représente l’évolution du prix du Bitcoin heure par heure sous le format OHLCV (Open, High, Low, Close, Volume).

```python
df = pd.read_csv("BTC-USDT.csv")
```
![date-formation-python0](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/date_formation_python0_211a868f2c.png)

Comme vous pouvez le remarquer, la colonne date est illisible. Cependant, si vous avez bien suivi la formation, le début de l’épisode, ce format devrait vous faire penser à quelque chose. Vous l’avez peut-être reconnu, mais ces dates sont des `timestamp`. Ce sont le nombre de millisecondes écoulées depuis 1970 (on peut reconnaître le fait que ce sont des millisecondes grâce au nombre de 0 à la fin). 

Voici comment convertir les `timestamp` en `datetime` (plus lisible et surtout plus manipulable)

```python
df = pd.read_csv("BTC-USDT.csv")
print(df["date"].dtype)
df["date"] = pd.to_datetime(df["date"], unit="ms")
print(df["date"].dtype)
```

![date-formation-python1](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/date_formation_python1_d79960cf70.png)

Les dates sont tout de suite plus lisibles. Dans le code, nous avons également rajouté deux lignes de code permettant d’afficher le type de la colonne avant et après la transformation. Nous remarquons qu’avant la transformation la colonne était de type `int` et maintenant, elle est de type `datetime`.

Nous pouvons commencer à réaliser des manipulations sur les dates.

### 4.2 Extraction du Jour de la Semaine

Pandas rend facile l'extraction du jour de la semaine grâce à son attribut **`dayofweek`**.

```python
df["weekday"] = df["date"].dt.weekday
```

![date-formation-python2](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/date_formation_python2_4121980f83.png)

Les jours de la semaine sont affichés de 0 à 6 avec 0 représentants le lundi et le 6 représentants le dimanche.

Si vous souhaitez les voir sous forme de `string` comme `“Monday”` il faudra faire ce que l’on appelle un mapping (faire correspondre une valeur à une autre) cela se fait à l’aide d’un dictionnaire et de la fonction pandas `.map()`.

```python
day_name_map = {
    0: 'Monday',
    1: 'Tuesday',
    2: 'Wednesday',
    3: 'Thursday',
    4: 'Friday',
    5: 'Saturday',
    6: 'Sunday'
}

df['weekday'] = df['weekday'].map(day_name_map)
```

### 4.3 ****Soustraction entre Deux Dates****

Essayons désormais de vérifier que nous avons bien une heure entre chacune de données. Pour cela, nous pouvons pour chaque donnée vérifier l’écart entre la date de la valeur et de la valeur précédente.

```python
df["date_diff"] = df["date"] - df["date"].shift(1)
print(df["date_diff"].value_counts())
```

Nous faisons ici simplement la différence entre la valeur de la colonne date avec la valeur de la colonne date de la valeur précédente grâce à `shift(1)`.
Nous affichons ensuite toutes les valeurs uniques et leur nombre d’occurrences associées.

![date-formation-python3](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/date_formation_python3_4f528cbe13.png)

On remarque que dans l’immense majorité des cas, nous avons bien une heure entre nos deux valeurs. Cependant, nous avons quelque cas particulier :

- 26 cas sans aucun écart (peut être des doublons)
- Plus ou moins 30 cas avec, au minimum deux heures de différences jusqu’à un maximum de plus d’un jour. Il peut être intéressant d’essayer de se renseigner sur la cause.

### 4.4 Regroupement par date

À partir de nos données, il serait intéressant de savoir si le volume d’échange moyen de bitcoin, varie en fonction du jour de la semaine.

Pour faire cela, nous pouvons essayer de regrouper nos données en fonction du jour de la semaine. Nous allons ici utiliser la fonction `group_by()` qui va nous permettre de regrouper nos données par jour de la semaine, puis la fonction `agg()` qui permet d’agréger nos données par rapport à la colonne groupée.

Cela se fait en une petite ligne de code :

```python
df.groupby('weekday').agg({"volume": "mean"})
```

![date-formation-python4](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/date_formation_python4_eea045d7de.png)

Comme on aurait pu l’attendre, le volume les jours de week-end (Samedi et Dimanche) sont bien inférieurs aux jours de la semaine. Près de 50% de volume en moins. Cela montre en partie que le majeur parti des échanges de Bitcoin sont réalisés par des professionnels qui ne traient que très peu pendant le week-end. 

## **Mise en pratique**

Pour mettre en pratique les concepts abordés dans cette partie, essayons de répondre à une question. **Est-ce qu’il existe, comme on l’a vu avec le volume en fonction des jours de la semaine, des différences dans le comportement du Bitcoin en fonction des marchés financiers ouverts.**

Nous pouvons par exemple prendre la bourse Européenne (Euronext), la bourse de New York (NYSE) et la bourse de Tokyo. La bourse Européenne est ouverte entre 9h et 17h sur le fuseau horaire de Paris. Nous vous laissons vous renseigner sur les horaires d’ouverture des autres bourses. 

La première étape sera de créer une colonne par place boursière et d’afficher `True` si pour la ligne en question la place boursière est ouverte, `False` si ce n’est pas le cas.

Une fois que cela est fait, vous pouvez comparer le volume moyen en fonction de si la place boursière est ouverte ou non. Vous pouvez également comparer la variation moyenne d’une bougie en comparant par exemple la différence entre le high et le low de chaque bougie en pourcentage. Nous vous encourageons vraiment à faire vos propres analyses.

Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_8.ipynb

Découvrez comment gérer et manipuler les dates et les heures en Python, un aspect crucial pour travailler avec des données financières.

Maitrîser l'utilisation des dates en Python

<MDX_YT videoId="iJaUH58MTgY"/>

Et s'il était possible de savoir en moins d'une seconde si une **stratégie de trading est gagnante**, cela serait bien, vous ne trouvez pas ? 

Imaginez avoir à votre disposition un outil capable d'évaluer la performance passée d'une stratégie, vous fournissant des insights précieux sans avoir à risquer un seul centime de votre capital. Aujourd'hui, nous allons plonger dans le monde fascinant du **backtesting**. Nous explorerons comment, avec quelques lignes de code Python, vous pouvez tester la viabilité de votre stratégie de trading, évaluer ses forces, ses faiblesses et être mieux préparé pour entrer avec confiance dans le monde volatile du trading. Vous êtes prêt ? Alors, allons-y !

## La stratégie de trading à backtester

Aujourd'hui, nous allons backtester les résultats de l'une des stratégies de trading les plus connues : **le croisement de moyennes mobiles.** 

Une moyenne mobile représente simplement la moyenne du prix sur les `n` dernières périodes.

Cette stratégie consiste à acheter lorsqu'une moyenne mobile à court terme (par exemple 50 périodes) croise à la hausse une moyenne mobile à long terme (par exemple 200 périodes). Inversement, un signal de vente est déclenché lorsque la moyenne mobile à court terme croise à la baisse la moyenne mobile à long terme. 

![croisement-moyenne-mobile.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/croisement_moyenne_mobile_a5673fe5e7.png)

C'est une méthode éprouvée pour identifier les points d'entrée et de sortie potentiels basés sur les tendances historiques du marché. Grâce à la puissance de **Python** et la bibliothèque **pandas**, en seulement quelques lignes de code, nous allons pouvoir déterminer **si cette stratégie a été rentable par le passé**, nous offrant ainsi des insights précieux pour nos futurs investissements.

## Backtester une stratégie de trading en Python

### Charger les données historiques avec Pandas

Pour pouvoir simuler notre stratégie de trading, vous vous en doutez peut-être, mais il va falloir les données historiques de prix de l'actif sur lequel nous voulons backtester notre stratégie. C’est un élément fondamental, car c'est grâce à ces données précieuses que nous pouvons analyser et évaluer la performance de notre stratégie dans des conditions de marché réelles. Nous vous mettons à disposition via ce lien https://github.com/CryptoRobotFr/python-pour-la-finance/blob/main/BTC-USDT.csv le cours OHLCV du Bitcoin heure par heure dans un fichier CSV. Ce fichier contient toutes les informations cruciales, telles que le prix d'ouverture, le prix le plus haut, le prix le plus bas, le prix de clôture et le volume, pour chaque heure des dernières années.

Après avoir importé la librairie Pandas avec **`import pandas as pd`** , nous allons commencer par charger ce fichier dans un DataFrame Pandas comme nous l’avons déjà fait avec l’instruction **`pd.read_csv()`**

```python
df = pd.read_csv('BTC-USDT.csv'
```

Maintenant, nous allons convertir la colonne date en datetime pour faciliter le traitement des dates et heures. Les dates sont actuellement au format unix (nombre de millisecondes écoulées depuis 1970).

```python
df["date"] = pd.to_datetime(df["date"], unit="ms")
df = df.set_index(df["date"])
del df["date"]
```

Avec ces lignes, nous avons converti la colonne **`'date'`** en objet datetime, puis nous avons défini cette colonne comme l'index de notre DataFrame. Nous avons également supprimé la colonne 'date' originale pour garder notre DataFrame propre.

### Calculer nos indicateurs techniques

Pour exécuter notre stratégie, nous allons avoir besoin préalablement de calculer nos indicateurs techniques qui sont ici la moyenne mobile court terme et long terme.

Une moyenne mobile sera sur 50 périodes et l'autre sur 200 périodes. Nous allons par la suite les utiliser pour générer des signaux d'achat et de vente.

```python
df['ma50'] = df['close'].rolling(50).mean()
df['ma200'] = df['close'].rolling(200).mean()
```

Ici, nous avons utilisé la méthode **`rolling()`** pour créer nos moyennes mobiles. La moyenne mobile sur 50 périodes sera plus réactive aux changements de prix que celle sur 200 périodes.

### Générer nos signaux d’achat et de vente

Maintenant que nous avons nos indicateurs, nous allons créer des colonnes pour les signaux d'achat et de vente basés sur la relation entre ces deux moyennes mobiles.

```python
df['buy_signal'] = False
df['sell_signal'] = False
df.loc[(df['ma50'] > df['ma200']), 'buy_signal'] = True
df.loc[(df['ma50'] < df['ma200']), 'sell_signal'] = True
```

Nous avons initialisé nos colonnes de signaux avec des valeurs **`False`**. Puis, nous avons utilisé la méthode **`loc[]`** pour remplir ces colonnes avec des valeurs **`True`** lorsque les conditions d'achat ou de vente sont remplies.

Lorsque la moyenne mobile 50 périodes est au-dessus de la moyenne mobile 200 périodes, alors nous avons un signal d’achat, inversement, nous avons un signal de vente.

### Préparer le backtest sur le Bitcoin

Nous sommes désormais prêts à exécuter le backtest. Nous initialiserons notre balance et parcourrons le DataFrame pour exécuter les ordres d'achat et de vente en fonction de nos signaux.

Nous allons commencer par initialiser 3 variables :

```python
balance = 1000
position = None
asset = "BTC"
```

- La variable **`balance`** représente le montant en dollar de notre portefeuille initial (ici 1000$).
- La variable **`position`** représente la “position” en cours, si nous réalisons un achat, nous ouvrons la position et lorsque nous vendrons, nous fermerons la position. Nous commençons sans position donc la variable est initialisée à **`None`**.
- La variable **`asset`** nous servira simplement à des fins d’affichage.

### Exécuter le backtest en Python

Nous sommes maintenant arrivés à une étape cruciale de notre parcours : l’exécution du backtest à l'aide d'une boucle qui parcourt nos données historiques et applique notre stratégie de trading. Accrochez-vous, car nous allons décomposer et décortiquer chaque ligne pour vous permettre de saisir toute la subtilité et la puissance de ce code.

```python
for index, row in df.iterrows():
```

Ici, nous entamons une boucle qui va parcourir notre DataFrame, ligne par ligne, chaque ligne représentant une période horaire dans nos données historiques du Bitcoin. 

Chaque **`row`** contient les données de trading pour une heure spécifique, et **`index`** représente l'index temporel de cette ligne.

```python
    if position is None and row['buy_signal']:
```

Nous entrons dans une condition où nous vérifions deux choses. D’abord, si nous n’avons pas de position ouverte (c’est-à-dire si nous avons acheté du Bitcoin) et ensuite, si le signal d’achat est activé pour la période en cours.

```python
        open_price = row['close']
        open_usd_size = balance
        position = {
            'open_price': open_price,
            'usd_size': open_usd_size,
        }
```

Si c’est le cas, nous ouvrons une position. Nous notons le prix d’ouverture, qui est le prix de clôture de la période en cours. Nous investissons toute notre balance disponible et enregistrons ces détails dans la variable **`position`** via un dictionnaire.

```python
        print(f"{index} - Buy for {open_usd_size}$ of {asset} at {open_price}$")
```

Enfin, nous imprimons un résumé de l’achat, indiquant la date et l’heure, la taille de la position et le prix d’achat.

```python
    elif position and row['sell_signal']:
```

Nous vérifions ensuite si nous avons une position ouverte et si le signal de vente est activé.

```python
        close_price = row['close']
        trade_result = (close_price - position['open_price']) / position['open_price']
        balance = balance + trade_result * position['usd_size']
        position = None
```

Si la condition est vraie, nous récupérons le prix de clôture pour la période en question. Ensuite, nous calculons le résultat du trade en soustrayant le prix d’ouverture de notre position au prix de clôture, le tout divisé par le prix d’ouverture pour obtenir le rendement en pourcentage. Notre balance est ensuite mise à jour en ajoutant le gain ou la perte du trade. Enfin, nous clôturons la position en la réinitialisant à None.

```python
print(f"{index} - Sell for {balance}$ of {asset} at {close_price}$")
```

Pour chaque vente, nous imprimons un résumé du trade, y compris la date et l'heure, la nouvelle balance et le prix auquel nous avons vendu l’actif.

Une fois ce code réalisé, nous pouvons exécuter notre backtest et enfin découvrir les résultats. Grâce aux **`print()`** dans le code, nous affichons chaque achat et chaque vente afin d’explorer l’exécution de la stratégie. 

![resultat-strategie-84611.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/resultat_strategie_84611_a99df7ebb0.png)

### Les résultats de la stratégie de trading

Notre backtest est maintenant fini et nous pouvons rajouter un **`print()`** dans le but d’afficher notre portefeuille final :

```python
print(f"Final balance: {balance}$")
```

> Final balance: 7847.2548834433455$
> 

Si nous avions appliqué cette stratégie de trading du croisement des moyennes mobiles de la fin 2017 jusqu'à début juillet 2023, notre portefeuille aurait grimpé à un impressionnant **7847 dollar**. Oui, vous avez bien lu. Nous aurions réalisé un bénéfice de 6847 dollar! Soit **+684%**!

Mais avant de nous emballer, il est crucial de nuancer ces résultats. Nous n'avons pas intégré les **frais de transaction** dans notre simulation. Comme vous le savez, dans le monde réel, chaque achat et vente s'accompagne de frais qui peuvent impacter significativement les rendements.

De plus, il est essentiel de mettre ces gains en perspective avec la performance globale du Bitcoin durant cette période. Une stratégie est d’autant plus impressionnante si elle surperforme l’actif sous-jacent, offrant un retour ajusté au risque attrayant.

Néanmoins, il est clair que cette stratégie aurait été rentable par le passé. Cependant, et c'est un avertissement que nous ne saurions trop répéter : le passé ne prédit pas le futur. Les marchés évoluent, et une stratégie qui était gagnante hier peut ne pas l'être demain.

Dans le prochain épisode, nous plongerons plus profondément dans l'analyse des résultats de cette stratégie. Nous examinerons les mesures clés et les techniques pour évaluer objectivement la performance, et discuterons des ajustements potentiels pour améliorer la rentabilité et réduire le risque. Restez branchés, le meilleur est encore à venir !

## Structurer notre backtest avec une Classe et des Fonctions

Dans notre quête pour rendre notre code plus propre, efficace et réutilisable, l'introduction des classes et des fonctions devient une étape incontournable. Envisagez par exemple la classe **`BacktestCrossMA`** ci-dessus. Cette structure nous permet non seulement de rendre notre code plus lisible mais aussi de l'organiser de manière modulaire, facilitant ainsi sa maintenance et sa réutilisation.

```python
class BacktestCrossMA:
    def __init__(self) -> None:
        self.df = pd.DataFrame()

    def load_data(self, path):
        self.df = pd.read_csv(path)
        self.df["date"] = pd.to_datetime(self.df["date"], unit="ms")
        self.df = self.df.set_index(self.df["date"])
        del self.df["date"]

    def populate_indicators(self):
        self.df['ma50'] = self.df['close'].rolling(50).mean()
        self.df['ma200'] = self.df['close'].rolling(200).mean()

    def populate_signals(self):
        self.df['buy_signal'] = False
        self.df['sell_signal'] = False
        self.df.loc[(self.df['ma50'] > self.df['ma200']), 'buy_signal'] = True
        self.df.loc[(self.df['ma50'] < self.df['ma200']), 'sell_signal'] = True

    def run_backtest(self):
        balance = 1000
        position = None
        asset = "BTC"

        for index, row in self.df.iterrows():

            if position is None and row['buy_signal']:
                open_price = row['close']
                position = {
                    'open_price': open_price,
                    'usd_size': balance,
                }
                print(f"{index} - Buy for {balance}$ of {asset} at {open_price}$")

            elif position and row['sell_signal']:
                close_price = row['close']
                trade_result = (close_price - position['open_price']) / position['open_price']
                balance = balance + trade_result * position['usd_size']
                position = None
                print(f"{index} - Sell for {balance}$ of {asset} at {close_price}$")
                
            
        
        print(f"Final balance: {balance}$")

bt = BacktestCrossMA()
bt.load_data('BTC-USDT.csv')
bt.populate_indicators()
bt.populate_signals()
bt.run_backtest()
```

La classe **`BacktestCrossMA`** encapsule toutes les étapes de notre backtesting, de la récupération des données à l’exécution du backtest. Elle commence par initialiser un DataFrame, puis chaque méthode de la classe est dédiée à une étape spécifique du processus. La méthode **`load_data()`** charge les données, **`populate_indicators()`** calcule les moyennes mobiles, et **`populate_signals()`** détermine les signaux d'achat et de vente. Enfin, **`run_backtest()`** exécute le backtest basé sur ces signaux.

En encapsulant ces étapes dans une classe, nous pouvons facilement réutiliser et adapter notre code pour d’autres actifs ou stratégies, rendant notre travail non seulement plus efficace mais aussi plus organisé et gérable. Cela démontre la beauté et l'efficacité de la programmation orientée objet, une compétence précieuse pour tout développeur travaillant dans le domaine de la finance quantitative.

## **Mise en pratique**

Après avoir exploré la stratégie du croisement des moyennes mobiles, il est temps de mettre nos connaissances en pratique avec une **nouvelle approche**. Nous vous proposons de mettre en pratique votre apprentissage avec une nouvelle stratégie de trading à backtester basée sur des **Bandes de Bollinger**, un autre outil d’analyse technique populaire parmi les traders.

Pour mettre en œuvre cette stratégie, nous achetons lorsque le prix de clôture est au-dessus de la bande supérieure de Bollinger et vendons lorsque le prix repasse en dessous de la bande moyenne. Si vous n’êtes pas famillier avec le concept de bandes de Bollinger nous vous laissons vous renseigner via ce lien [https://www.abcbourse.com/apprendre/11_lecon4.html](https://www.abcbourse.com/apprendre/11_lecon4.html)

Pour débuter, il sera nécessaire de se familiariser avec le calcul et l'interprétation des Bandes de Bollinger. En combinant la théorie avec la pratique, nous aurons l’occasion de tester et d’affiner une nouvelle stratégie, amplifiant ainsi notre arsenal de trading et affinant nos compétences en programmation Python pour la finance. 

## Librairie utile pour le calcul d’indicateur technique

Si vous souhaitez aller plus loin en testant d’autres stratégies basées sur d’autres indicateurs, nous vous conseillons d’aller voir du côté de la librairie python TA qui regroupe de nombreux indicateurs techniques. Voici le lien de la documentation de la librairie [https://technical-analysis-library-in-python.readthedocs.io/en/latest/](https://technical-analysis-library-in-python.readthedocs.io/en/latest/).

Une fois installée avec **`pip install ta`** puis importé dans votre code avec **`import ta`** vous pourrez par exemple calculer le RSI, un autre indicateur technique de trading très connu.

```python
df["RSI"] = ta.momentum.RSIIndicator(close=df["close"], window=14).rsi()
```
Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_9.ipynb. Bon courage et rendez vous à la prochaine séance dans laquelle nous découvrirons **comment analyser au mieux les résultats de ces backtest**.

Apprenez à développer et à évaluer des stratégies de trading automatisées en utilisant Python.

Backtester une stratégie de trading automatisé en Python

Découvrez comment analyser les performances de votre portefeuille de trading en utilisant Pandas pour tirer des conclusions et optimiser vos stratégies.

Analyser le backtest d'un portefeuille de trading en Python grâce à Pandas

large_draze_a_python_in_a_crypto_trading_room_1a54cd54-45a8-4c17-a742-d702c7a77577.png

medium_draze_a_python_in_a_crypto_trading_room_1a54cd54-45a8-4c17-a742-d702c7a77577.png

small_draze_a_python_in_a_crypto_trading_room_1a54cd54-45a8-4c17-a742-d702c7a77577.png

thumbnail_draze_a_python_in_a_crypto_trading_room_1a54cd54-45a8-4c17-a742-d702c7a77577.png

draze_a_python_in_a_crypto_trading_room_1a54cd54-45a8-4c17-a742-d702c7a77577.png

Welcome to the "Python For Finance" Free Course, designed for anyone who wishes to learn Python for use in the financial sector and more broadly in data analysis. Whether you are a student, a finance professional, or simply passionate about the field, this training will enable you to master the basics of Python and apply it to real-world scenarios in the financial sector.

![pff-intro.png](https://strapi-project-image-test.s3.eu-west-3.amazonaws.com/pff_intro_6f39fb48c2.png)

We are thrilled to announce that this "Python for Finance" course is offered entirely free of charge by Crypto Robot in collaboration with Robot Traders (https://www.youtube.com/channel/UCOoKHYcIsEQsiZAMyu5I68g/)! Our goal is to make learning the Python language and its application in the financial domain accessible to everyone. The best way to support us is to follow us on our various social media platforms, and most importantly, share this course with as many people as possible!


## **Table of Contents**

- **0 - Python and VsCode Installation**: Learn how to install Python and Visual Studio Code, a versatile and powerful code editor, to start your journey in learning the Python language.
- **1 - Variables, Operations, and Types**: Get acquainted with variables, mathematical operations, and different data types in Python.
- **2 - Loops and Conditions in Python**: Discover how to use control structures such as loops and conditions to perform repetitive or conditional tasks.
- **3 - Lists and Dictionaries in Python**: Learn to handle lists and dictionaries to store and organize your data efficiently.
- **4 - Functions and Classes in Python**: Discover how to create and use functions and classes to structure your code and facilitate reuse.
- **5 - The Pandas Library, the best library for financial data**: Learn to use Pandas, a powerful library for data manipulation and analysis, especially suited for working with financial data.
- **6 - Visualizing Data in Python with Matplotlib**: Discover how to create charts and interactive visualizations of your financial data using the Matplotlib library.
- **7 - Unlocking the Power of Pandas and Avoiding Loops**: Learn to get the most out of Pandas by avoiding loops and using advanced techniques to manipulate and analyze your data.
- **8 - Mastering Date Usage in Python**: Discover how to manage and manipulate dates and times in Python, a crucial aspect when working with financial data.
- **9 - Backtesting an Automated Trading Strategy in Python**: Learn to develop and evaluate automated trading strategies using Python.
- **10 - Analyzing the Backtest of a Trading Portfolio in Python** with Pandas: Discover how to analyze the performance of your trading portfolio using Pandas to draw conclusions and optimize your strategies.

It is important to emphasize that the best way to progress in Python is not just by watching videos and reading documents, but by actively engaging in practice. We encourage you to work on personal projects, even on a small scale, to apply and reinforce the skills you've acquired throughout this training.

In this training, you will discover the Python programming language and how to apply it quickly to financial concepts.

Toutes les Formations

Python pour la Finance
23 janvier 2023

Toutes les Formations

Python pour la Finance23 janvier 2023

Python pour la Finance
23 janvier 2023