Coder des Ordres Stop Loss et Take Profit en Pine Script sur TradingView : Guide Complet

Réussir dans le trading repose en grande partie sur une gestion rigoureuse du risque. Différentes approches et outils peuvent aider à cet effet. L'une des méthodes les plus directes consiste à se protéger efficacement contre les trades allant à l'encontre de nos prévisions. Cela passe par l'implémentation d'un stop loss, qui agit comme filet de sécurité en cas de mouvement contraire. Il est tout aussi important de savoir sortir d'un trade lorsque celui-ci évolue dans le sens escompté, en verrouillant ses gains avec un take profit.

Pour coder correctement ce type de sorties en Pine Script et implémenter vos stratégies de trading sur TradingView, il y a plusieurs étapes clés à suivre. Explorons ensemble comment y parvenir de manière correcte et simple.

Comprendre les Ordres Stop Loss et Take Profit

Différences entre Ordres Stop Loss et Take Profit

Ce qui distingue un ordre stop loss et un ordre take profit d'un ordre classique, est qu'ils sont exclusivement des ordres de fermeture de position, placés souvent en même temps que l'ouverture de la position. Dans la pratique, ils seront un ordre limite ou un ordre à déclenchement, dit "trigger". Pour plus de détails sur les types d'ordres, voir notre article.

Ensuite, le prix auquel l'ordre stop loss doit s'exécuter est déterminé pour se déclencher si le prix évolue dans la direction opposée à celle anticipée. Le take profit, quant à lui, est fixé pour se déclencher si le prix évolue dans la direction prévue. En d'autres termes :

• Pour une position long, le prix du stop loss doit être fixé à un niveau inférieur au prix d'entrée.
• Pour une position short, le prix du stop loss est fixé au-dessus du prix d'entrée.

Pour le take profit, c’est exactement l’inverse dans chaque cas.

Le prix d'exécution est donc le seul paramètre à choisir pour ce type d'ordres. Le choix se fait généralement selon trois approches possibles :

• Un écart par rapport au prix d'entrée en pourcentage.
• Un décalage par rapport au prix d'entrée caractérisé par la valeur d'un indicateur. Par exemple, l'Average True Range (ATR) est souvent utilisé dans ces cas-là. Si vous êtes intéressé par plus de détails sur l'ATR et comment l'utiliser comme filtre de volatilité, rendez-vous ici.
• Un indicateur directement. Par exemple, le prix d’exécution peut être égal à la valeur d'une supertrend ou d'une moyenne mobile au moment de l'entrée en position.

Stratégie de Trading Simple pour Démarrer en Pine Script

Le but de cet article est de comprendre l’implémentation des ordres de take profit et de stop loss en Pine Script, sans entrer dans les détails d’une stratégie complexe. Pour ce faire, nous partirons d'une stratégie la plus simple possible. Cependant, tâchons d'être complets dans notre approche et considérons que notre stratégie inclura des positions long (positions à la hausse) et short (positions à la baisse) afin de bien aborder stop loss et take profit dans les deux cas.

Pour cela, nous utiliserons un indicateur très souvent employé dans le trading : les bandes de Bollinger. Le début de notre code pourrait donc ressembler à ceci :

//@version=5
strategy('TP/SL example', default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, overlay=true)

// *** Indicator *** 
bb_length = input(20, title="BB Length")
bb_mult = input(2, title="BB Multiplier")

bb_stddev = ta.stdev(close, bb_length)
bb_average = ta.sma(close, bb_length)

bb_upper = bb_average + bb_mult * bb_stddev
bb_lower = bb_average - bb_mult * bb_stddev

// *** Signals ***
entry_long = ta.crossover(close, bb_upper)
entry_short = ta.crossunder(close, bb_lower)

L’entête définit la version 5 de Pine Script, la plus récente. Dans strategy, nous définissons le nom de la stratégie, le fait que nous entrerons avec 100 % de notre capital à chaque position et que les frais de trading sont de 0,1 % de la taille des positions.

Ensuite, nous calculons les bandes de Bollinger. Les paramètres, longueur et écartement via le multiplicateur, sont implémentés via input() pour permettre de changer ces valeurs directement sur le graphique TradingView une fois la stratégie complète.

Enfin, nous définissons nos conditions d'entrées long et short :

• entry_long prendra la valeur true lorsque le prix passe au-dessus de la bande de Bollinger supérieure, et false sinon.
• entry_short prendra la valeur true lorsque le prix passe en dessous de la bande de Bollinger inférieure, et false sinon.

Remarquez que nous implémentons cela grâce aux fonctions de la librairie d’analyse technique ta de Pine Script : ta.crossover et ta.crossunder. N’hésitez pas à faire un Ctrl + clic gauche sur ce type de fonction pour afficher le panneau explicatif.

Programmer un Stop Loss et Take Profit en Pine Script sur TradingView

Étapes pour Coder un Stop Loss en Pine Script

Pour illustrer la mise en place d’un stop loss en Pine Script, prenons le cas où le prix du stop loss est fixé à un écart en pourcentage par rapport au prix d'entrée. En Pine Script, cela donne pour le cas d’une position long :

entry_price = close 
percent_diff = 5.

stop_loss_price_long = (1 - percent_diff / 100) * entry_price 

et dans le cas d’une position short, nous inversons simplement le signe :

stop_loss_price_short = (1 + percent_diff / 100) * entry_price

Une fois ces niveaux de prix de stop loss calculés, nous pouvons mettre en place les ordres grâce à la fonction strategy.exit() de Pine Script comme ceci :

entry_price = close 
percent_diff = 5.

stop_loss_price_long = (1 - percent_diff / 100) * entry_price
stop_loss_price_short = (1 + percent_diff / 100) * entry_price 

if entry_long
    strategy.entry("Long", strategy.long)
    strategy.exit("SL Long", "Long", stop = stop_loss_price_long, comment_loss = "SL Long")
    
if entry_short
    strategy.entry("Short", strategy.short)
    strategy.exit("SL short", "Short", stop = stop_loss_price_short, comment_loss = "SL Short")

Vous pouvez observer que le prix d’exécution du stop loss est indiqué dans le paramètre stop de la fonction strategy.exit(), implémentée juste après l'entrée par strategy.entry().

Dans strategy.exit(), avant de renseigner le stop, vous pouvez voir que nous donnons deux paramètres, deux chaînes de caractères. Ce sont des identificateurs caractérisant une entrée ou une sortie : avec SL Long nous définissons cette sortie, alors que Long est l'identificateur de l'entrée qui doit être fermée par cette sortie, identifiant ainsi l'entrée créée dans strategy.entry().

Notez que nous avons également ajouté le paramètre comment_loss pour afficher le tag correspondant sur le graphique TradingView, au niveau de la bougie sur laquelle le stop loss a été déclenché. Vous pouvez voir un exemple ci-dessous.

Un point très important à garder à l'esprit lorsque l'on programme un stop loss est le suivant : le stop loss doit être implémenté lors de l'entrée en position. La fonction strategy.exit() doit être renseignée juste après strategy.entry() avec le même niveau d’indentation. De ce fait, le prix du stop loss fixé est celui calculé au moment de l'entrée en position et le restera.

En opposition, faire ceci est très différent :

if enter_long
    strategy.entry("Long", strategy.long)

strategy.exit("SL Long", "Long", stop = stop_loss_price_long, comment_loss = "SL Long")

Car strategy.exit() est maintenant actualisée à chaque bougie, et donc le prix de déclenchement du stop loss changera continuellement et ne restera pas l’écart que nous avions défini au moment de l'entrée.

Instructions pour Coder un Take Profit en Pine Script

Pour illustrer la mise en place d’un take profit en Pine Script, prenons aussi le cas où le prix du take profit est fixé à un écart en pourcentage par rapport au prix d'entrée. En Pine Script, cela donne pour le cas d’une position long et short:

entry_price = close
percent_diff = 10.0

take_profit_price_long = (1 + percent_diff / 100) * entry_price
take_profit_price_short = (1 - percent_diff / 100) * entry_price

Comme sa définition nous le laisse entendre, vous pouvez observer que le take profit, en termes de signe, est en effet l’opposé d’un stop loss. Une fois ces niveaux de prix de take profit calculés, nous l’implémentons aussi grâce à la fonction strategy.exit() :

entry_price = close 
percent_diff = 5.

take_profit_price_long = (1 + percent_diff / 100) * entry_price
take_profit_price_short = (1 - percent_diff / 100) * entry_price

if entry_long
    strategy.entry("Long", strategy.long)
    strategy.exit("TP Long", "Long", limit = take_profit_price_long, comment_profit = "TP Long")
    
if entry_short
    strategy.entry("Short", strategy.short)
    strategy.exit("TP short", "Short", limit = take_profit_price_short, comment_profit = "TP Short")

Notez que le prix d’exécution du take profit se renseigne dans le paramètre limit et, si l’on veut donner un tag, il faut utiliser comment_profit. Aussi, tout comme le stop loss, le take profit doit en général être placé au même moment que l’entrée en position. Gardez donc en tête la même mise en garde que nous avons faite dans le cas du stop loss.

Combiner les Ordres Stop Loss et Take Profit en Pine Script

En Pine Script, il est tout à fait possible de renseigner un stop loss et un take profit dans le même appel de la fonction strategy.exit(). Si nous regroupons tout cela ensemble, cela donne :

entry_price = close 
percent_diff = 5.

stop_loss_price_long = (1 - percent_diff / 100) * entry_price
stop_loss_price_short = (1 + percent_diff / 100) * entry_price 

take_profit_price_long = (1 + percent_diff / 100) * entry_price
take_profit_price_short = (1 - percent_diff / 100) * entry_price

if entry_long
    strategy.entry("Long", strategy.long)   
    strategy.exit("TP/SL Long", "Long", stop = stop_loss_price_long, limit = take_profit_price_long, comment_loss = "SL Long", comment_profit = "TP Long")
    
if entry_short
    strategy.entry("Short", strategy.short)
    strategy.exit("TP/SL short", "Short", stop = stop_loss_price_short, limit = take_profit_price_short, comment_loss = "SL Short", comment_profit = "TP Short")

Utiliser le Ratio Risk Reward avec Stop Loss et Take Profit en Pine Script

Beaucoup de traders aiment réfléchir en termes de “ratio risk/reward” (ratio de gain versus perte) pour placer le niveau du take profit par rapport à celui du stop loss.

Par exemple, si l’on veut placer un take profit avec un ratio risk/reward de 2:1, il faut que la différence en valeur absolue entre le prix d’entrée et le prix du take profit soit le double de la différence en valeur absolue entre le prix d’entrée et le prix du stop loss. Si l’on reprend notre exemple, cela peut se configurer de la manière suivante en Pine Script :

entry_price = close 
percent_diff = 5.
risk_reward_ratio = 2 

stop_loss_price_long = (1 - percent_diff / 100) * entry_price
stop_loss_price_short = (1 + percent_diff / 100) * entry_price

take_profit_price_long = entry_price + (entry_price - stop_loss_price_long) * risk_reward_ratio
take_profit_price_short = entry_price - (stop_loss_price_short - entry_price) * risk_reward_ratio

Maintenant, compilons tout cela dans un même code pour que vous puissiez le copier directement et ajoutons le plot automatique des bandes de Bollinger. Cela donne :

//@version=5
strategy('TP/SL example', default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, overlay=true)

// *** Indicator *** 
bb_length = input(20, title="BB Length")
bb_mult = input(2, title="BB Multiplier")

bb_stddev = ta.stdev(close, bb_length)
bb_average = ta.sma(close, bb_length)

bb_upper = bb_average + bb_mult * bb_stddev
bb_lower = bb_average - bb_mult * bb_stddev

// *** Signals ***
entry_long = ta.crossover(close, bb_upper)
entry_short = ta.crossunder(close, bb_lower)

// *** SL/TP *** 
entry_price = close 
percent_diff = 5.
risk_reward_ratio = 2 

stop_loss_price_long = (1 - percent_diff / 100) * entry_price
stop_loss_price_short = (1 + percent_diff / 100) * entry_price 

take_profit_price_long = entry_price + (entry_price - stop_loss_price_long) * risk_reward_ratio
take_profit_price_short = entry_price - (stop_loss_price_short - entry_price) * risk_reward_ratio

// *** Entrees/Sorties *** 
if entry_long
    strategy.entry("Long", strategy.long)   
    strategy.exit("TP/SL Long", "Long", stop = stop_loss_price_long, limit = take_profit_price_long, comment_loss = "SL Long", comment_profit = "TP Long")
    
if entry_short
    strategy.entry("Short", strategy.short)
    strategy.exit("TP/SL short", "Short", stop = stop_loss_price_short, limit = take_profit_price_short, comment_loss = "SL Short", comment_profit = "TP Short")

// *** Plots *** 
plot(bb_upper, color=color.rgb(31, 130, 252), linewidth=2)
plot(bb_average, color=color.new(#ffb13b, 0), linewidth=2)
plot(bb_lower, color=color.rgb(31, 130, 252), linewidth=2)

Une fois que vous ajoutez cette stratégie au graphique TradingView, vous devriez obtenir un graphique qui ressemble à ceci :

Vous pouvez aussi désormais accéder aux outils d’analyse de backtest de TradingView.

Pour conclure, il est important de noter que tout ceci était un exemple simple pour vous apprendre comment coder un stop loss et un take profit en Pine Script. Pour qu’une stratégie soit viable et utilisable avec de l’argent réel, il faut beaucoup plus de tests et de validations. Gardez donc cela en tête. Cet article était éducatif et non pas un conseil en investissement. Nous espérons que cela vous a apporté les bases que vous cherchiez pour implémenter vos stratégies.