Les Listes et les Dictionnaires en Python

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 :

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

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 :

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() :

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 :

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 :

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 :

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

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 :

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 :

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 :

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 [] :

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é :

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é :

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 :

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 :

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:

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:

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

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

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.

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:

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",
    },
]

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:

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

À 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).
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.
Ajouter dans notre dictionnaire pour chacune des cryptos, notre prix moyen d’achat.
(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.