Les bases de Python pour la finance en une séance : types de données, listes, dictionnaires, boucles, fonctions et messages d'erreur
Apprenez le minimum de Python dont un trader a besoin : nombres, chaînes, listes, dictionnaires, boucles, fonctions et lecture d'un traceback.
Ce que vous allez apprendre
- Les types de données que vous rencontrerez dans les données de prix :
int,float,str,bool,Noneetdatetime. - Comment les listes et les dictionnaires stockent une liste de trades, et comment une boucle
forla parcourt. - Comment écrire une fonction avec une docstring et un argument par défaut, et pourquoi les fonctions rendent les backtests testables.
- Comment lire un traceback Python de bas en haut et corriger les cinq erreurs les plus fréquentes.
Explication
Types. Toute valeur en Python a un type. 42 est un int (nombre entier), 42.5 un float (nombre décimal stocké en binaire), "AAPL" un str (texte), True un bool, et None signifie « aucune valeur ». Les floats sont approximatifs (0.1 + 0.2 affiche 0.30000000000000004), ne les comparez donc jamais avec == ; utilisez round() ou une tolérance. Pour les dates, utilisez les timestamps de pandas (leçon 3).
Les listes sont des collections ordonnées écrites entre crochets : closes = [100.0, 102.0, 101.5]. L'indexation commence à zéro (closes[0] vaut 100.0), les indices négatifs comptent à partir de la fin (closes[-1] est la dernière clôture), et le découpage (slicing) closes[1:3] renvoie les éléments 1 et 2 mais pas le 3. La même règle de fin exclue s'applique à iloc dans pandas.
Les dictionnaires associent des clés à des valeurs : trade = {"symbol": "AAA", "entry": 50.0, "qty": 100}. On y accède avec trade["entry"] ; une clé manquante lève une KeyError, tandis que trade.get("fee", 0.0) renvoie une valeur par défaut.
Boucles et conditions. Une boucle for visite chaque élément : for t in trades: suivi d'un bloc indenté. L'indentation (quatre espaces) définit le bloc. if, elif et else créent des branches selon des conditions, et les opérateurs de comparaison sont ==, !=, <, >=.
Les fonctions regroupent une logique afin de pouvoir la réutiliser et la tester. Le mot-clé def commence une définition, les paramètres se placent entre parenthèses et return renvoie une valeur :
def r_multiple(entry, exit_price, stop, side="long"):
'''Renvoie le profit en unités de risque initial (R).'''
risk = abs(entry - stop)
pnl = exit_price - entry if side == "long" else entry - exit_price
return pnl / risk
La chaîne entre triples guillemets est une docstring (documentation), et side="long" est un argument par défaut. Gardez des fonctions courtes, explicites sur leurs entrées et sans effets de bord ; c'est ce qui permettra à la leçon 9 de les tester unitairement.
Lire les erreurs. Quand quelque chose échoue, Python affiche un traceback. Lisez d'abord la dernière ligne : elle indique le type d'erreur et le message. Regardez ensuite la ligne juste au-dessus, qui montre à quel endroit de votre code l'erreur s'est produite. Les erreurs les plus fréquentes : NameError (vous avez utilisé une variable avant de la définir, souvent parce qu'une cellule du notebook n'a pas été exécutée) ; TypeError (par exemple additionner une chaîne issue d'un fichier CSV et un nombre, à corriger avec float()) ; KeyError (une colonne ou une clé de dictionnaire est orthographiée différemment, vérifiez les espaces et les majuscules) ; IndexError (vous avez demandé l'élément 10 d'une liste de 10 éléments, pensez à l'indexation à partir de zéro) ; et ZeroDivisionError (un stop égal à l'entrée donne un risque nul).
Exemple commenté
Exemple hypothétique : trois trades acheteurs clôturés, tous en euros, commissions et impôts ignorés.
trades = [
{"symbol": "AAA", "entry": 50.0, "exit": 53.0, "stop": 48.0, "qty": 100},
{"symbol": "BBB", "entry": 20.0, "exit": 19.0, "stop": 19.0, "qty": 250},
{"symbol": "CCC", "entry": 80.0, "exit": 78.0, "stop": 76.0, "qty": 60},
]
total = 0.0
for t in trades:
pnl = (t["exit"] - t["entry"]) * t["qty"]
r = r_multiple(t["entry"], t["exit"], t["stop"])
total += pnl
print(t["symbol"], pnl, round(r, 2))
print("Total:", total)
Profit sur AAA = (53 − 50) × 100 = €300 ; risque de €2 par action, donc R = 3 ÷ 2 = 1.5. BBB = (19 − 20) × 250 = −€250 ; risque de €1 par action, R = −1.0 (stoppé exactement). CCC = (78 − 80) × 60 = −€120 ; risque de €4, R = −0.5. Total = 300 − 250 − 120 = −€70. Lignes affichées : AAA 300.0 1.5, BBB -250.0 -1.0, CCC -120.0 -0.5, Total: -70.0.
total += pnl est un raccourci pour total = total + pnl. Trois trades ne disent rien d'une méthode ; seule la mécanique compte ici.
Erreur fréquente
trades, relancez uniquement la cellule de la boucle, et une valeur périmée alimente silencieusement un résultat ; après un redémarrage du noyau, vous obtenez au contraire une NameError. Avant de vous fier à un chiffre, utilisez « Restart kernel and run all cells » et assurez-vous que tout s'exécute de haut en bas sans erreur.Exercice pratique
Sur papier, écrivez une fonction position_size(account, risk_pct, entry, stop) qui renvoie le nombre entier d'actions (arrondi vers le bas) et lève une ValueError explicite si le stop est égal à l'entrée. Écrivez ensuite le résultat pour un compte de €8,000, un risque de 1.25%, une entrée à €32.50 et un stop à €30.00. Enfin, nommez le type d'erreur que Python lèverait si vous appeliez la fonction avec entry="32.50" (une chaîne) sans la convertir.
Afficher la solution
def position_size(account, risk_pct, entry, stop):
per_share = abs(entry - stop)
if per_share == 0:
raise ValueError("le stop doit être différent de l'entrée")
return int(account * risk_pct // per_share)
Chiffres : budget de risque = 8,000 × 0.0125 = €100 ; risque par action = 32.50 − 30.00 = €2.50 ; 100 ÷ 2.50 = exactement 40 actions, la fonction renvoie donc 40 (risque prévu de €100, valeur de la position de €1,300).
Avec entry="32.50", l'expression "32.50" - 30.0 lève TypeError: unsupported operand type(s) for -: 'str' and 'float'. Convertissez avec float(entry).
Limites : la fonction ignore les tailles de lot minimales, les commissions et le fait qu'un gap peut faire perdre plus que les €100 prévus.
Points clés à retenir
- Les floats sont approximatifs, l'indexation commence à zéro et les découpages excluent la fin ; ces trois faits évitent la plupart des bugs de débutant.
- Une liste de dictionnaires est la forme naturelle des trades avant pandas ; les boucles la parcourent, les fonctions lui apportent une logique réutilisable.
- Écrivez de petites fonctions pures avec des docstrings ; ce sont les unités que vous testerez à la leçon 9.
- Lisez les tracebacks de bas en haut, et redémarrez puis exécutez tout avant de vous fier à un résultat de notebook.
Étape suivante
La leçon 3 présente pandas : Series, DataFrames, le DatetimeIndex, la sélection et le filtrage de lignes, et la conversion de barres journalières en barres hebdomadaires avec resample.
Auto-évaluation
Répondez aux questions, puis vérifiez vos réponses. Vous pouvez recommencer autant de fois que vous le souhaitez.
Auto-évaluation automatique pour vos propres révisions. Vos réponses sont vérifiées dans votre navigateur ; nous ne les voyons pas et ne les évaluons pas. Ce n'est ni un examen ni une qualification.
Votre progression
« Terminée » signifie seulement que vous avez marqué la leçon comme lue. Ce n'est pas un test de votre compréhension. La progression et les notes sont enregistrées uniquement dans ce navigateur, sur cet appareil — pas dans un compte.