Lewati ke isi

Cara membuat bot trading di Python

Artikel dan video ini menawarkan instruksi langkah demi langkah untuk membuat robot trading di Python.

Catatan

cTrader adalah satu-satunya platform trading utama dengan dukungan Python asli, memungkinkan Anda untuk menulis kode dalam Python dan membangun bot, indikator teknis dan alat langsung di cTrader Windows atau Mac. Tidak diperlukan adapter atau solusi rumit.

Membuat robot trading

Di tab cBots pada aplikasi Algo, klik tombol New untuk mulai membuat bot trading baru.

Beri nama cBot dan pilih Python sebagai bahasa pemrograman.

Catatan

cTrader menyediakan beberapa algoritma siap pakai dalam Python yang mencakup berbagai strategi dan tindakan trading otomatis. Template algoritma ini sudah berisi logika trading dan parameter yang dapat disesuaikan dan siap dijalankan setelah Anda menyimpan dan membangunnya.

Pilih Using template sebagai metode pembuatan, pilih Grid Sample, lalu klik Create.

Grid cBot menerapkan strategi trading grid di mana beberapa order beli atau jual untuk suatu simbol ditempatkan pada interval atau langkah harga yang teratur, menghasilkan grid posisi.

Mari kita build cBot kita untuk memvalidasi kodenya.

Tekan Ctrl+B atau klik Build.

Tekan Cmd+B atau klik ikon Build.

Tambahkan indikator

Mari kita masukkan indikator ke dalam bot trading kita untuk meningkatkan akurasinya.

Relative Strength Index (RSI) adalah indikator populer yang menandakan kondisi overbought atau oversold di pasar. Indikator ini dapat membantu cBot kita menghindari pembukaan posisi baru ketika pasar terlalu jauh ke satu arah.

Integrasikan RSI ke dalam logika robot. Inisialisasi indikator dengan periode default 14 dan atur level overbought dan oversold masing-masing ke 70 dan 30. Gunakan harga penutupan simbol untuk membuat RSI.

1
2
3
4
self.rsi_period = getattr(api, "RsiPeriod", 14)
self.rsi_overbought = getattr(api, "RsiOverbought", 70)
self.rsi_oversold = getattr(api, "RsiOversold", 30)
self.rsi = api.Indicators.RelativeStrengthIndex(api.Bars.ClosePrices, self.rsi_period)

Tambahkan logika untuk memeriksa apakah kondisi RSI memungkinkan trading sebelum membuka posisi. Jika filter memblokir trading, catat pesan yang menunjukkan nilai RSI saat ini.

1
2
3
4
5
6
if len(self.get_grid_positions()) == 0:
    # self.open_position()
    if self.passes_rsi_filter():
        self.open_position()
    else:
        api.Print("RSI filter blocked initial entry (RSI={:.2f})".format(self.get_rsi_value()))

Tulis kode yang memastikan bahwa posisi grid dibuka hanya jika harga telah bergerak cukup dan nilai RSI berada dalam rentang netral. Gunakan nilai RSI bar terakhir yang ditutup untuk stabilitas dan cetak pesan saat diblokir oleh filter RSI.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
if distance >= api.StepPips:
    # self.open_position()
    if self.passes_rsi_filter():
        self.open_position()
    else:
        api.Print("RSI filter: no new entry (RSI={:.2f}, range {}-{})"
                    .format(self.get_rsi_value(), self.rsi_oversold, self.rsi_overbought))

def get_rsi_value(self):
    # Use the last CLOSED bar for stability
    return self.rsi.Result.Last(1)

def passes_rsi_filter(self):
    r = self.get_rsi_value()
    return (r > self.rsi_oversold) and (r < self.rsi_overbought)

Sesuaikan logika perhitungan untuk jarak dalam pip antara harga pasar saat ini dan harga entri posisi.

1
2
3
4
5
6
7
def get_distance_in_pips(self, position):
    # return (position.EntryPrice - api.Symbol.Ask if position.TradeType == TradeType.Buy else api.Symbol.Bid - position.EntryPrice) / api.Symbol.PipSize
    if position.TradeType == TradeType.Buy:
        diff = position.EntryPrice - api.Symbol.Ask
    else:
        diff = api.Symbol.Bid - position.EntryPrice
    return diff / api.Symbol.PipSize

Anda dapat menyalin kode Python lengkap dengan indikator RSI terintegrasi di bawah ini:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

class SupercBot():
    def on_start(self):
        self.volumeInUnits = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
        self.enoughMoney = True

        self.rsi_period = getattr(api, "RsiPeriod", 14)
        self.rsi_overbought = getattr(api, "RsiOverbought", 70)
        self.rsi_oversold = getattr(api, "RsiOversold", 30)
        self.rsi = api.Indicators.RelativeStrengthIndex(api.Bars.ClosePrices, self.rsi_period)

        if len(self.get_grid_positions()) == 0:
            if self.passes_rsi_filter():
                self.open_position()
            else:
                api.Print("RSI filter blocked initial entry (RSI={:.2f})".format(self.get_rsi_value()))

    def on_tick(self):
        grid_positions = self.get_grid_positions()
        net_profit_sum = sum([p.NetProfit for p in grid_positions])
        if net_profit_sum >= api.TargetProfit:
            api.Print("Target profit is reached. Closing all grid positions")
            self.close_grid_positions()
            api.Print("All grid positions are closed. Stopping cBot")
            api.Stop()

        if len(grid_positions) > 0 and self.enoughMoney == True:
            position_with_highest_pips = sorted(grid_positions, key=lambda pos: pos.Pips, reverse=True)[0]
            distance = self.get_distance_in_pips(position_with_highest_pips)          
            if distance >= api.StepPips:
                if self.passes_rsi_filter():
                    self.open_position()
                else:
                    api.Print("RSI filter: no new entry (RSI={:.2f}, range {}-{})"
                              .format(self.get_rsi_value(), self.rsi_oversold, self.rsi_overbought))

    def get_rsi_value(self):
        # Use the last CLOSED bar for stability
        return self.rsi.Result.Last(1)

    def passes_rsi_filter(self):
        r = self.get_rsi_value()
        return (r > self.rsi_oversold) and (r < self.rsi_overbought)

    def get_grid_positions(self):
        return [pos for pos in api.Positions if pos.SymbolName == api.SymbolName and pos.TradeType == api.TradeType]

    def open_position(self):
        result = api.ExecuteMarketOrder(api.TradeType, api.SymbolName, self.volumeInUnits, "Grid")
        if result.Error == ErrorCode.NoMoney:
            self.enoughMoney = False
            api.Print("Not enough money to open additional positions")

    def close_grid_positions(self):
        for position in self.get_grid_positions():
            position.Close()

        if len(self.get_grid_positions()) > 0:
            self.close_grid_positions()

    def get_distance_in_pips(self, position):
        if position.TradeType == TradeType.Buy:
            diff = position.EntryPrice - api.Symbol.Ask
        else:
            diff = api.Symbol.Bid - position.EntryPrice
        return diff / api.Symbol.PipSize

Mulai instance

Mari kembali ke cBot kita dan membangunnya. Sekarang, klik ikon Mulai cBot untuk instance mana pun, dan bot trading akan mulai berjalan.

Atau, Anda dapat mengklik Tambah instance, tentukan parameter instance yang Anda inginkan, tambahkan instance baru dan mulai.

Dengan menambahkan dan menyesuaikan instance baru, Anda dapat menjalankan cBot secara bersamaan pada simbol, periode, atau parameter yang berbeda.

Jalankan bot di tempat lain

Dengan sinkronisasi cloud diaktifkan, cBot muncul secara otomatis di semua aplikasi cTrader di mana cTID Anda aktif. Kita dapat memulai robot trading yang sama di Cloud pada semua aplikasi cTrader, termasuk cTrader Mobile dan Web.

Di cTrader Algo, mulai cBot.

Artikel ini telah mendemonstrasikan cara membuat robot trading Python dan memulainya, memberdayakan Anda untuk mengotomatisasi strategi dan menjalankan algo di perangkat apa pun.

Image title