Ethereum / TetherFormazione
Selezione editoriale
Programmare una strategia long e disegnare un indicatore (Pt. 2)
Benvenuto a questo secondo tutorial che vuole aiutare trader e investitori a comprendere al meglio il potente linguaggio di programmazione Pine Script.
Nel tutorial di oggi continueremo a programmare il 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, oggi implementeremo il codice per una strategia long only basata sull' indicatore RSI. Il nostro algoritmo acquisterà 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). 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.
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)
plot(priceEntry,
style = plot.style_line,
color = color.green)
plot(priceExit,
style = plot.style_line,
color = color.red)
Come puoi notare abbiamo separato la prima parte del codice svolta nel primo tutorial con la seconda parte.
Iniziamo quindi ad analizzare il nostro codice sorgente descrivendone la sintassi stringa dopo stringa.
rsi = ta.rsi(close, 14): creiamo una variabile a cui assegnamo la funzione built-in ta.rsi(), questa funzione ci permette di accedere velocemente all' indicatore RSI. All' interno della funzione passiamo il source e il periodo. Impostiamo quindi close e il periodo di 14, in questo modo l' indicatore sarà calcolato sulla chiusura di ogni barra prendendo le ultime 14 barre passate.
buyLong = ta.crossunder(rsi, 30): successivamente andiamo a dichiarare una seconda variabile che chiameremo "buyLong". Servirà per definire quando il nostro algoritmo dovrà aprire la posizione long. Tramite ta.crossunder() 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 oversold pari a 30. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 30 (il livello di ipervenduto).
closingLong = ta.crossover(rsi, 70): ora andiamo a dichiarare la variabile che chiameremo "closingLong". Servirà per definire quando il nostro algoritmo dovrà chiudere la posizione long. Tramite ta.crossover() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di uscita. Come pattuito in precedenza vendiamo la posizione long 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).
priceEntry = ta.valuewhen(buyLong, close, 0): isoliamo il prezzo di ingresso dichiarando una variabile "priceEntry". Servirà per definire il prezzo esatto dell' ingresso long. 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 buyLong, come source close e come occurrence 0.
priceExit = ta.valuewhen(closingLong, close, 0): isoliamo il prezzo di uscita dichiarando una variabile "priceExit". Servirà per definire il prezzo esatto dell' uscita long. 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 closingLong, come source close e come occurrence 0.
if buyLong 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. buyLong: 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 long, che analizzeremo di seguito.
strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry): attraverso la funzione strategy.order() definiremo l'invio dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Long Trade"), direction = strategy.long (la direzione dell'ordine, che in questo caso è di tipo long) e limit = priceEntry (prezzo a cui dovrà essere eseguito l'ordine, in questo caso uguale a "priceEntry").
strategy.entry(id = "Open Long Trade", direction = strategy.long): attraverso la funzione strategy.entry() dichiareremo l'esecuzione dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Long Trade") e direction = strategy.long (la direzione dell'ordine, che in questo caso è di tipo long).
Ora tutte le volte che le condizioni sono soddisfatte e il capitale è libero il nostro algoritmo acquisterà long al prezzo definito dalla nostra condizione.
Continuiamo comunicando al nostro script quando vogliamo chiudere la posizione.
if closingLong: implementiamo la condizione che dovrà essere soddisfatta per l'uscita del trade, ovvero quando l' indicatore rsi si trova a livello 70, il livello di overbought o ipercomprato.
strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit): attraverso la funzione strategy.exit() definiremo la chiusura del trade long. All' interno di questa funzione passiamo un id (nome dell'ordine "Close Long Trade"), from_entry = "Open Long Trade"
(indichiamo l'id dell' ordine che deve essere chiuso) e il prezzo di esecuzione stop = priceExit (prezzo a cui dovrà essere eseguita la chiusura, in questo caso uguale a "priceExit").
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 la funzione che si utilizza per disegnare dei valori si chiama plot.
plot(priceEntry, 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, priceEntry. Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore verde con color = color.green.
plot(priceExit, 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, priceExit. 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.
Ci vediamo al prossimo tutorial dove analizzeremo il codice della strategia per la versione short.
Se riscontri problemi durante il salvataggio dello script, copia e incolla il codice qui sotto, se continui a riscontrare problemi non esitare a contattarci.
//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)
plot(priceEntry, style = plot.style_line, color = color.green)
plot(priceExit, style = plot.style_line, color = color.red)
Nel tutorial di oggi continueremo a programmare il 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, oggi implementeremo il codice per una strategia long only basata sull' indicatore RSI. Il nostro algoritmo acquisterà 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). 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.
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)
plot(priceEntry,
style = plot.style_line,
color = color.green)
plot(priceExit,
style = plot.style_line,
color = color.red)
Come puoi notare abbiamo separato la prima parte del codice svolta nel primo tutorial con la seconda parte.
Iniziamo quindi ad analizzare il nostro codice sorgente descrivendone la sintassi stringa dopo stringa.
rsi = ta.rsi(close, 14): creiamo una variabile a cui assegnamo la funzione built-in ta.rsi(), questa funzione ci permette di accedere velocemente all' indicatore RSI. All' interno della funzione passiamo il source e il periodo. Impostiamo quindi close e il periodo di 14, in questo modo l' indicatore sarà calcolato sulla chiusura di ogni barra prendendo le ultime 14 barre passate.
buyLong = ta.crossunder(rsi, 30): successivamente andiamo a dichiarare una seconda variabile che chiameremo "buyLong". Servirà per definire quando il nostro algoritmo dovrà aprire la posizione long. Tramite ta.crossunder() 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 oversold pari a 30. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 30 (il livello di ipervenduto).
closingLong = ta.crossover(rsi, 70): ora andiamo a dichiarare la variabile che chiameremo "closingLong". Servirà per definire quando il nostro algoritmo dovrà chiudere la posizione long. Tramite ta.crossover() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di uscita. Come pattuito in precedenza vendiamo la posizione long 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).
priceEntry = ta.valuewhen(buyLong, close, 0): isoliamo il prezzo di ingresso dichiarando una variabile "priceEntry". Servirà per definire il prezzo esatto dell' ingresso long. 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 buyLong, come source close e come occurrence 0.
priceExit = ta.valuewhen(closingLong, close, 0): isoliamo il prezzo di uscita dichiarando una variabile "priceExit". Servirà per definire il prezzo esatto dell' uscita long. 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 closingLong, come source close e come occurrence 0.
if buyLong 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. buyLong: 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 long, che analizzeremo di seguito.
strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry): attraverso la funzione strategy.order() definiremo l'invio dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Long Trade"), direction = strategy.long (la direzione dell'ordine, che in questo caso è di tipo long) e limit = priceEntry (prezzo a cui dovrà essere eseguito l'ordine, in questo caso uguale a "priceEntry").
strategy.entry(id = "Open Long Trade", direction = strategy.long): attraverso la funzione strategy.entry() dichiareremo l'esecuzione dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Long Trade") e direction = strategy.long (la direzione dell'ordine, che in questo caso è di tipo long).
Ora tutte le volte che le condizioni sono soddisfatte e il capitale è libero il nostro algoritmo acquisterà long al prezzo definito dalla nostra condizione.
Continuiamo comunicando al nostro script quando vogliamo chiudere la posizione.
if closingLong: implementiamo la condizione che dovrà essere soddisfatta per l'uscita del trade, ovvero quando l' indicatore rsi si trova a livello 70, il livello di overbought o ipercomprato.
strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit): attraverso la funzione strategy.exit() definiremo la chiusura del trade long. All' interno di questa funzione passiamo un id (nome dell'ordine "Close Long Trade"), from_entry = "Open Long Trade"
(indichiamo l'id dell' ordine che deve essere chiuso) e il prezzo di esecuzione stop = priceExit (prezzo a cui dovrà essere eseguita la chiusura, in questo caso uguale a "priceExit").
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 la funzione che si utilizza per disegnare dei valori si chiama plot.
plot(priceEntry, 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, priceEntry. Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore verde con color = color.green.
plot(priceExit, 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, priceExit. 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.
Ci vediamo al prossimo tutorial dove analizzeremo il codice della strategia per la versione short.
Se riscontri problemi durante il salvataggio dello script, copia e incolla il codice qui sotto, se continui a riscontrare problemi non esitare a contattarci.
//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)
plot(priceEntry, style = plot.style_line, color = color.green)
plot(priceExit, style = plot.style_line, color = color.red)
Pubblicazioni correlate
Declinazione di responsabilità
Le informazioni ed i contenuti pubblicati non costituiscono in alcun modo una sollecitazione ad investire o ad operare nei mercati finanziari. Non sono inoltre fornite o supportate da TradingView. Maggiori dettagli nelle Condizioni d'uso.