Die Ressourcen sind geladen. Beförderung...

Schildkrötenhandelsstrategie

Schriftsteller:ChaoZhang, Datum: 2023-12-25 17:12:05
Tags:

Übersicht

Die Schildkröten-Handelsstrategie ist eine Trend-Folge-Strategie, die Momentum-Breakouts verfolgt. Sie wurde von dem berühmten Trader Richard Dennis in den 1980er Jahren entwickelt, um zu beweisen, dass Händler durch Regeln genährt werden können, anstatt geboren zu werden. Die Kernidee der Strategie besteht darin, Preis-Breakouts zu verfolgen und Trends zu verfolgen, während man sich strikt an Geldmanagementprinzipien hält, um das Abwärtstrisiko zu begrenzen.

Strategie Logik

Die Schildkrötenhandelsstrategie verwendet zwei Parameter N und N/2 zum Aufbau von Kanälen. Insbesondere berechnet sie die höchsten und niedrigsten Preise über die letzten N Tage und N/2 Tage. Wenn der Preis den N-Tage-Kanal überschreitet, wird eine Long-Position eingerichtet. Wenn der Preis unter den N/2-Tage-Kanal fällt, wird die Position geschlossen. Ebenso wird eine Short-Position eingerichtet, wenn der Preis den N-Tage-Kanal nach unten bricht, und geschlossen, wenn der Preis über den N/2-Tage-Kanal steigt.

In dem Code entspricht N:enter_slowund N/2 entsprichtenter_fastDie höchsten Preise (slowLundfastL) und niedrigsten Preisen (slowSundfastSDie langen Positionen werden eröffnet, wenn der Preis den 55-Tage-Kanal überschreitet (enterL2) und wird geschlossen, wenn der Preis unter den 20-Tage-Kanal fällt (exitL1Die Short-Positionen werden eröffnet, wenn der Kurs den 55-Tage-Kanal nach unten durchbricht (enterS2) und wird geschlossen, wenn der Preis über den 20-Tage-Kanal steigt (exitS1).

Analyse der Vorteile

Der größte Vorteil der Schildkrötenhandelsstrategie ist die Risikokontrolle. Durch die Festlegung von Positionen bei Preisbruch und das schnelle Stoppen von Pullbacks werden Verluste bei einzelnen Trades effektiv kontrolliert.

Ein weiterer Vorteil ist die einfache Parameterwahl. Die gesamte Strategie hat nur 4 Parameter, die leicht zu verstehen und einzustellen sind. Die Parameter selbst sind auch ziemlich stabil, ohne häufige Optimierung zu benötigen.

Risikoanalyse

Das größte Risiko der Schildkrötenhandelsstrategie ist die Unfähigkeit, langfristige Trends zu verfolgen. Es kann Eintrittsmöglichkeiten verpassen, wenn sich Trends bilden. Auch in unruhigen Preisschwankungen wird die Strategie häufige Ein- und Ausstiege auslösen, was die Transaktionskosten und das Rutschrisiko erhöht.

Darüber hinaus könnten die festen Parameter-Einstellungen bei verschiedenen Produkten und Marktsystemen sehr unterschiedlich funktionieren, so dass eine manuelle Einstellung auf der Grundlage der Erfahrungen erforderlich ist.

Möglichkeiten zur Verbesserung

Die Schildkrötenhandelsstrategie kann auf verschiedene Weise verbessert werden:

Zusätzliche Anpassungsmöglichkeiten für die Parameter N und N/2 basierend auf Marktvolatilität und Signalfrequenz sollen das System für verschiedene Szenarien robuster machen.
Einbeziehung von Regeln für die Tendenzerkennung vor dem Eintritt, um falsche Eintritte in unruhige Märkte zu vermeiden.
Ein Mehrzeitrahmenansatz zur Bestätigung von Trends in höheren Zeitabschnitten und zum Aufnehmen von Geschäften in niedrigeren Zeitabschnitten.
Optimieren Sie Stop-Loss-Regeln mit Trailing-Stops oder zeitbasierten Stops, um Drawdowns zu reduzieren.

Schlussfolgerung

Die Turtle Trading Strategie verfolgt Trends effektiv durch ein einfaches Breakout-System. Die Risikokontrolle ist ihre größte Stärke, dank schneller Stopps und einer festen fraktionalen Positionsgröße. Gleichzeitig sehen wir mehrere Dimensionen, an denen die Strategie erweitert und optimiert werden kann, um mehr Instrumenten und Marktbedingungen zu entsprechen. Insgesamt bietet sie eine risikokontrollierte Möglichkeit, Preistrends zu erfassen, die eine wichtige Referenz für den quantitativen Handel ist.

/*backtest
start: 2022-12-24 00:00:00
end: 2023-12-24 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=2
//oringinally coded by tmr0, modified by timchep
//original idea from «Way of the Turtle: The Secret Methods that Turned Ordinary People into Legendary Traders» (2007) CURTIS FAITH
strategy("Turtles", shorttitle = "Turtles", overlay=true, pyramiding=1, default_qty_type= strategy.percent_of_equity, default_qty_value = 100)
//////////////////////////////////////////////////////////////////////
// Component Code Start
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(12, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)

// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=false)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
// Component Code Stop
//////////////////////////////////////////////////////////////////////

shortingEnabled = input(title="Enable Shorting?", type=bool, defval=true)

enter_fast = input(20, minval=1)
exit_fast = input(10, minval=1)
enter_slow = input(55, minval=1)
exit_slow = input(20, minval=1)

fastL = highest(enter_fast)
fastLC = lowest(exit_fast)
fastS = lowest(enter_fast)
fastSC = highest(exit_fast)

slowL = highest(enter_slow)
slowLC = lowest(exit_slow)
slowS = lowest(enter_slow)
slowSC = highest(exit_slow)

enterL1 = high > fastL[1] 
exitL1 = low <= fastLC[1] 
enterS1 = low < fastS[1]
exitS1 = high >= fastSC[1]

enterL2 = high > slowL[1] 
exitL2 = low <= slowLC[1] 
enterS2 = low < slowS[1]
exitS2 = high >= slowSC[1]


if testPeriod()
    strategy.entry("fast L", strategy.long, when = enterL1) 
    
    if not enterL1
        strategy.entry("slow L", strategy.long, when = enterL2)
        
    strategy.close("fast L", when = exitL1)
    strategy.close("slow L", when = exitL2)

if shortingEnabled and testPeriod()
    strategy.entry("fast S", strategy.short, when = enterS1)
    if not enterS2
        strategy.entry("slow S", strategy.short, when = enterS2)
        
    strategy.close("fast S", when = exitS1)
    strategy.close("slow S", when = exitS2)

Mehr