Programmare una strategia short e disegnare un indicatore (Pt.3)Benvenuto a questo terzo e ultimo tutorial che vuole aiutare trader e investitori a comprendere al meglio il potente linguaggio di programmazione Pine Script.
Nel tutorial di oggi concluderemo la programmazione del nostro semplice algoritmo di tipo strategy, descrivendone attentamente la sintassi.
Nel primo tutorial abbiamo analizzato la dichiarazione di una strategia e le sue funzioni base, mentre nel secondo abbiamo implementato il codice per una strategia long only basata sull' indicatore RSI. Il nostro algoritmo acquista long ogni volta che il l'indicatore entra in ipervenduto-oversold (livello 30) vendendo la posizione quando l'indicatore entra in ipercomprato-overbought (livello 70). Oggi completeremo la nostra opera inserendo una terza parte riguardante la strategia di tipo short. Successivamente disegneremo un indicatore molto semplice di tipo visual che terrà traccia dei livelli di prezzo di entrate e uscite per ogni singolo trade. I prezzi delle entrate saranno disegnati con una linea verde, i prezzi delle uscite saranno disegnati con una linea rossa.
I parametri della strategia di oggi sono i seguenti, apertura short ogni volta che l' indicatore entra in ipercomprato-overbought (livello 70), chiusura della posizione quando l' indicatore entra in ipervenduto-oversold (livello 35).
Una cosa molto importante prima di iniziare: non utilizzare questo script per prendere decisioni di investimento. Utilizza questo codice esclusivamente per esercitarti, testare e comprendere il linguaggio Pine Script.
Qui sotto trovi il codice sorgente, puoi copiarlo e incollarlo all' interno della tua console di Trading View. Salva il codice e aggiungilo allo schermo.
//@version=5
strategy(title = " Strategy Tutorial - The Quant Science™ ",
overlay = false,
initial_capital = 1000,
currency = currency.EUR,
commission_type = strategy.commission.percent,
commission_value = 0.03,
slippage = 10,
default_qty_value = 100,
default_qty_type = strategy.percent_of_equity,
process_orders_on_close = true)
//------------------------------------------------------------ Pt. 2
rsi = ta.rsi(close, 14)
buyLong = ta.crossunder(rsi ,30)
closingLong = ta.crossover(rsi ,70)
priceEntry = ta.valuewhen(buyLong, close, 0)
priceExit = ta.valuewhen(closingLong, close, 0)
if buyLong and strategy.opentrades == 0
strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry)
strategy.entry(id = "Open Long Trade", direction = strategy.long)
if closingLong
strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit)
//------------------------------------------------------------ Pt. 3
sellShort = ta.crossover(rsi, 70)
closingShort = ta.crossunder(rsi, 35)
priceShortEntry = ta.valuewhen(sellShort, close, 0)
priceShortExit = ta.valuewhen(closingShort, close, 0)
if sellShort and strategy.opentrades == 0
strategy.order(id = "Open Short Trade", direction = strategy.short, limit = priceShortEntry)
strategy.entry(id = "Open Short Trade", direction = strategy.short)
if closingShort
strategy.exit(id = "Close Short Trade", from_entry = "Open Short Trade", stop = priceShortExit)
plot(priceShortEntry, style = plot.style_line, color = color.green)
plot(priceShortExit, style = plot.style_line, color = color.red)
Come puoi notare abbiamo separato ogni parte del codice sviluppata in ciascun tutorial.
Iniziamo quindi ad analizzare il nostro nuovo codice sorgente descrivendone la sintassi stringa dopo stringa.
sellShort = ta.crossover(rsi, 70)
Dichiariamo una variabile chiamata "sellShort". Servirà per definire quando il nostro algoritmo dovrà aprire la posizione short. Tramite ta.crossover() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di ingresso. Come pattuito in precedenza acquistiamo sul livello di overbought pari a 70. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 70 (il livello di ipercomprato).
closingShort = ta.crossunder(rsi, 35)
Ora andiamo a dichiarare la variabile che chiameremo "closingShort". Servirà per definire quando il nostro algoritmo dovrà chiudere la posizione short. Tramite ta.crossunder() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di uscita. Come pattuito in precedenza chiudiamo la posizione short sul livello di oversold pari a 35. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 35 (il livello di ipervenduto).
priceShortEntry = ta.valuewhen(sellShort, close, 0)
Isoliamo il prezzo di ingresso dichiarando una variabile "priceShortEntry". Servirà per definire il prezzo esatto dell' ingresso short. Tramite ta.valuewhen() accediamo alla funzione built-in che ci permette di passare tre elementi, il primo elemento è la condizione, il secondo è un elemento di tipo source e il terzo elemento è un elemento di tipo int chiamato occurrence. Passiamo all' interno di questa funzione la condizione sellShort, come source close e come occurrence 0.
priceShortExit = ta.valuewhen(closingShort, close, 0)
Isoliamo il prezzo di uscita dichiarando una variabile "priceShortExit". Servirà per definire il prezzo esatto dell' uscita short. Tramite ta.valuewhen() accediamo alla funzione built-in che ci permette di passare tre elementi, il primo elemento è la condizione, il secondo è un elemento di tipo source e il terzo elemento è un elemento di tipo int chiamato occurrence. Passiamo all' interno di questa funzione la condizione closingShort, come source close e come occurrence 0.
if sellShort and strategy.opentrades == 0
Ora che abbiamo definito le condizioni del nostro algoritmo andiamo a implementare la parte che farà interagire le nostre condizioni creando una vera e propria strategia.
Questa stringa è divisa in quattro differenti parti:
1. if: la condizione 'if' definisce quali azioni vanno eseguite se le condizioni sono soddisfatte
2. sellShort: la nostra condizione di ingresso
3. and: letteralmente 'e' offre la possibilità di combinare una seconda condizione
4. strategy.opentrades == 0: indica i numeri di ordini a mercato aperti che in questo caso dovranno essere uguali a 0.
In definitiva se la condizione di ingresso è soddisfatta e nessun altro ordine è a mercato, allora si eseguirà l' inserimento dell' ordine short, che analizzeremo di seguito.
strategy.order(id = "Open Short Trade", direction = strategy.short, limit = priceShortEntry)
Attraverso la funzione strategy.order() definiremo l'invio dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Short Trade"), direction = strategy.short (la direzione dell'ordine, che in questo caso è di tipo short) e limit = priceShortEntry (prezzo a cui dovrà essere eseguito l'ordine, in questo caso uguale a "priceShortEntry").
strategy.entry(id = "Open Short Trade", direction = strategy.short)
Attraverso la funzione strategy.entry() dichiareremo l'esecuzione dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Short Trade") e direction = strategy.short (la direzione dell'ordine, che in questo caso è di tipo short).
Ora tutte le volte che le condizioni sono soddisfatte e il capitale è libero il nostro algoritmo acquisterà short al prezzo definito dalla nostra condizione.
Continuiamo comunicando al nostro script quando vogliamo chiudere la posizione.
if closingShort
Implementiamo la condizione che dovrà essere soddisfatta per l'uscita del trade, ovvero quando l' indicatore rsi si trova a livello 35, il livello di oversold o ipervenduto (per la strategia short).
strategy.exit(id = "Close Short Trade", from_entry = "Open Short Trade", stop = priceShortExit)
Attraverso la funzione strategy.exit() definiremo la chiusura del trade short. All' interno di questa funzione passiamo un id (nome dell'ordine "Close Short Trade"), from_entry = "Open Short Trade" (indichiamo l'id dell' ordine che deve essere chiuso) e il prezzo di esecuzione stop = priceShortExit (prezzo a cui dovrà essere eseguita la chiusura, in questo caso uguale a "priceShortExit").
Molto bene, ora abbiamo concluso la programmazione operativa del nostro script è il momento di aggiungere un indicatore che ci permetterà di visualizzare i prezzi di entrata e uscita.
In Pine Script, come abbiamo visto nello scorso tutorial, la funzione che si utilizza per disegnare dei valori si chiama plot.
plot(priceShortEntry, style = plot.style_line, color = color.green)
Definiamo dei valori da disegnare tramite plot(), all'interno di questa funzione passeremo il valore della serie da disegnare ovvero il prezzo di entrata, priceShortEntry. Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore verde con color = color.green.
plot(priceShortExit, style = plot.style_line, color = color.red)
Definiamo dei valori da disegnare tramite plot(), all'interno di questa funzione passeremo il valore della seconda serie da disegnare ovvero il prezzo di uscita, priceShortExit. Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore rosso con color = color.red.
Puoi trovare tutti gli stili disponibili e i colori con cui puoi configurare il tuo indicatore all' interno del manuale Pine Script.
NB: è probabile che copiando il codice nella tua console ti ritroverai una dicitura errata al posto di 'rsi'. Questo è un errore (probabilmente momentaneo e dovuto all'aggiornamento) di Trading View. Per risolvere questo problema, dovrai sostituire la dicitura errata con quella corretta. Qui sotto trovi la versione del codice in versione testo che ti aiuterà a risolvere questo problema. Sostituisci quindi le diciture errate con quelle corrette che trovi nel codice in versione testo, qui sotto.
//@version=5
strategy(title = " Strategy Tutorial - The Quant Science™ ",
overlay = false,
initial_capital = 1000,
currency = currency.EUR,
commission_type = strategy.commission.percent,
commission_value = 0.03,
slippage = 10,
default_qty_value = 100,
default_qty_type = strategy.percent_of_equity,
process_orders_on_close = true)
//------------------------------------------------------------ Pt. 2
rsi = ta.rsi(close, 14)
buyLong = ta.crossunder(rsi ,30)
closingLong = ta.crossover(rsi ,70)
priceEntry = ta.valuewhen(buyLong, close, 0)
priceExit = ta.valuewhen(closingLong, close, 0)
if buyLong and strategy.opentrades == 0
strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry)
strategy.entry(id = "Open Long Trade", direction = strategy.long)
if closingLong
strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit)
//------------------------------------------------------------ Pt. 3
sellShort = ta.crossover(rsi, 70)
closingShort = ta.crossunder(rsi, 35)
priceShortEntry = ta.valuewhen(sellShort, close, 0)
priceShortExit = ta.valuewhen(closingShort, close, 0)
if sellShort and strategy.opentrades == 0
strategy.order(id = "Open Short Trade", direction = strategy.short, limit = priceShortEntry)
strategy.entry(id = "Open Short Trade", direction = strategy.short)
if closingShort
strategy.exit(id = "Close Short Trade", from_entry = "Open Short Trade", stop = priceShortExit)
plot(priceShortEntry, style = plot.style_line, color = color.green)
plot(priceShortExit, style = plot.style_line, color = color.red)
Ci vediamo presto con nuovi tutorial !
