Python dasar untuk trading algo

Trader menggunakan Python untuk membangun bot trading, indikator teknikal, plugin, dan alat lain untuk membantu trading algo atau operasi manual, dan artikel ini menjelaskan dasar-dasar coding di Python.

Python adalah bahasa pemrograman serbaguna tingkat tinggi yang populer yang digunakan untuk pengembangan web, ilmu data, otomatisasi dan baru-baru ini, trading algoritmik di cTrader. Baik Anda membuat bot trading berbasis sinyal sederhana atau strategi multi-indikator yang kompleks, Python membuat prosesnya lebih cepat, lebih efisien dan lebih mudah dikelola.

Variabel dan tipe data

Di Python, variabel memiliki tipe dinamis, yang berarti Anda tidak perlu mendeklarasikan tipe datanya secara eksplisit. Interpreter menentukan tipe pada saat runtime berdasarkan nilai yang ditetapkan.

Anda membuat variabel hanya dengan menetapkan nilai ke variabel tersebut:

1
2
3
4

price = 105.50         # float
enabled = True         # boolean
symbol = "EURUSD"      # string
orders = []            # empty list

Tipe data umum

Dalam algoritma cTrader, variabel menyimpan data penting terkait informasi pasar, keputusan trading, dan konfigurasi cBot. Variabel-variabel ini sering mewakili volume trading yang dihitung, nilai indikator, bendera Boolean, nama simbol, label, dan lainnya.

Berikut contohnya:

1
2
3
4

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

Dalam kasus ini, self.volumeInUnits adalah float yang digunakan untuk menempatkan order, sementara self.enoughMoney adalah bool yang mengontrol apakah akan terus membuka posisi dalam strategi grid.

Kelas dan objek

Python adalah bahasa pemrograman berorientasi objek (OOP), menyediakan alat untuk mengorganisir kode melalui kelas dan objek yang memodelkan entitas dan perilaku dunia nyata. Sebuah kelas mendefinisikan cetak biru untuk membuat objek, yang merupakan instance dari kelas tersebut dengan data dan perilaku unik mereka sendiri. Konsep utamanya diuraikan di bawah ini:

• Kelas didefinisikan menggunakan kata kunci class.
• Metode __init__ (konstruktor) umumnya digunakan untuk menginisialisasi keadaan objek.
• Metode instance mendefinisikan perilaku.
• Atribut menyimpan data spesifik untuk setiap objek.

Misalnya, Anda dapat membuat kelas Car:

1
2
3
4
5
6
7

class Car:
    def __init__(self, color, speed):
        self.color = color
        self.speed = speed

    def accelerate(self):
        self.speed += 10

Kemudian Anda dapat membuat objek dari kelas Car dan berinteraksi dengannya:

1
2
3

my_car = Car("red", 50)
my_car.accelerate()
print(my_car.speed)  # This returns 60

Dalam konteks cTrader

Di cTrader, cBot, indikator, dan plugin diimplementasikan sebagai kelas yang merangkum seluruh logika mereka. Algo berinteraksi dengan platform cTrader menggunakan objek api khusus yang menyediakan akses ke simbol, grafik, order, indikator, dan lainnya.

Anda dapat membuat kelas SimplecBot di cTrader dengan cara ini:

1
2
3

class SimplecBot():
    def on_start(self):
        api.Print("cBot started")

Kelas SimplecBot mencakup satu metode (on_start(self)) yang dieksekusi sekali ketika bot trading dimulai. Fungsi api.Print menulis pesan ke log, menunjukkan bagaimana metode objek merangkum perilaku trading.

Setiap instance dari kelas secara efektif mewakili algoritma trading mandiri yang mengelola siklus hidup dan keputusan tradingnya sendiri menggunakan prinsip OOP. Dalam cBot cTrader standar, sebuah kelas mungkin menyimpan data keadaan internal, seperti volume, hasil indikator, dll., dan menggunakan beberapa metode untuk mengelola logika trading.

Pertimbangkan contoh crossover MACD ini yang menginisialisasi indikator MACD saat dimulai dan menempatkan order beli ketika sinyal crossover MACD terjadi:

1
2
3
4
5
6
7

class MACDCrossover():
    def on_start(self):
        self.macd = api.Indicators.MacdCrossOver(api.Source, api.LongCycle, api.ShortCycle, api.SignalPeriods)

    def on_bar_closed(self):
        if self.macd.MACD.Last(0) > self.macd.Signal.Last(0):
            api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, volume)

Kata kunci self

Di dalam kelas, self merujuk pada instance kelas dan menyediakan akses ke variabel dan metodenya. self digunakan untuk:

• Menyimpan data seperti hasil indikator, volume posisi, dan nilai konfigurasi.
• Melacak keadaan internal di berbagai panggilan metode seperti on_start(), on_tick() atau on_bar_closed().

Contoh ini menunjukkan bagaimana self digunakan:

1
2
3
4

class MACDCrossover():
    def on_start(self):
        self.volume = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
        self.macd = api.Indicators.MacdCrossOver(api.Source, api.LongCycle, api.ShortCycle, api.SignalPeriods)

Dalam kasus ini, self.volume menyimpan volume yang dihitung untuk digunakan dalam trading, sementara self.macd menyimpan objek indikator MACD, memungkinkan akses ke nilainya sepanjang siklus hidup cBot. Tanpa self, variabel-variabel ini akan bersifat lokal untuk on_start() dan tidak dapat diakses di on_bar_closed() di mana keputusan trading mungkin dibuat.

Metode dan fungsi

Fungsi adalah blok kode yang dapat digunakan kembali untuk melakukan tugas tertentu. Ketika fungsi didefinisikan di dalam kelas, mereka disebut metode, dan mereka beroperasi pada keadaan internal kelas melalui parameter self. Dalam konteks trading algoritmik dengan cTrader, metode mendefinisikan bagaimana algoritma trading Anda berperilaku dalam kondisi berbeda, seperti tick pasar, penutupan bar, atau inisialisasi.

Platform secara otomatis memanggil metode khusus (dikenal sebagai penangan event) pada waktu yang tepat, seperti:

on_start(self) – dipanggil sekali ketika bot diinisialisasi.

1
2

def on_start(self):
    api.Print("cBot started")

on_tick(self) – dipanggil pada setiap tick pasar yang masuk.

1
2

def on_tick(self):
    api.Print("Tick received")

on_bar_closed(self) – dipanggil ketika candle/bar baru ditutup (ideal untuk strategi berbasis waktu).

1
2
3
4

def on_bar_closed(self):
    if Functions.HasCrossedAbove(...):
        self.close_positions(TradeType.Sell)
        api.ExecuteMarketOrder(...)

Metode kustom atau pembantu

Untuk menghindari penulisan ulang dan duplikasi kode, Anda dapat mendefinisikan metode Anda sendiri. Metode kustom tersebut harus merangkum logika umum yang mungkin digunakan kembali oleh robot trading Anda.

Metode di bawah ini mengembalikan semua posisi terbuka yang terkait dengan label cBot saat ini, memudahkan untuk melacak atau menutup posisi secara konsisten.

1
2

def get_bot_positions(self):
    return api.Positions.FindAll(api.Label)

Pertimbangkan metode lain yang menghitung jarak dalam pip antara harga saat ini dan entri posisi, yang penting untuk keputusan dalam strategi berbasis grid.

1
2

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

Setelah metode didefinisikan, Anda dapat memanggilnya dari dalam kelas yang sama menggunakan kata kunci self. Pendekatan ini memungkinkan Anda menggunakan kembali logika di mana saja dalam bot Anda tanpa menduplikasi kode.

Misalnya, setelah mendefinisikan get_bot_positions(), Anda mungkin memanggilnya di dalam metode lain untuk menutup semua posisi:

1
2
3
4

def close_positions(self, tradeType):
    for position in self.get_bot_positions():   # Helper method call
        if position.TradeType == tradeType:
            api.ClosePosition(position)

Di sini, self.get_bot_positions() memanggil metode pembantu, mengembalikan hanya posisi yang terkait dengan label bot saat ini.

Demikian pula, metode get_distance_in_pips() dapat digunakan kembali untuk membuat keputusan trading. Misalnya, dalam strategi grid, Anda mungkin ingin membuka order baru hanya jika pasar telah bergerak cukup jauh dari posisi terakhir:

1
2
3
4
5
6
7

def on_tick(self):
    grid_positions = self.get_bot_positions()
    if len(grid_positions) > 0:
        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)  # Helper method call
        if distance >= api.StepPips:
            self.open_position()

Konsep lainnya

Namespace dan impor

Namespace di Python membantu mengorganisir kode dan menghindari tabrakan nama dengan mengelompokkan pengidentifikasi terkait (variabel, fungsi, kelas). Impor memungkinkan Anda membawa masuk modul eksternal, pustaka atau paket untuk memperluas fungsionalitas di luar fitur standar Python.

Di Python, Anda dapat mengimpor modul standar atau paket kustom:

1
2

import math
print(math.sqrt(16))  # 4.0

Anda juga dapat mengimpor fungsi atau kelas tertentu:

1
2

from math import sqrt
print(sqrt(25))  # 5.0

Saat menulis algoritma untuk cTrader dalam Python, impor bekerja sedikit berbeda karena cTrader terintegrasi dengan cTrader Algo API berbasis .NET. Pengaturan ini melibatkan jembatan yang memungkinkan kode Python berinteraksi dengan assembly .NET, dan ini menjelaskan mengapa cBot biasanya dimulai dengan:

1
2
3
4
5
6
7
8
9

import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

Di mana:

• import clr memuat Common Language Runtime (CLR), memungkinkan Python berinteroperasi dengan pustaka .NET.
• clr.AddReference("cAlgo.API") mereferensikan assembly cAlgo API, yang berisi semua kelas, metode, dan objek terkait trading.
• from cAlgo.API import * membawa masuk semua tipe dari API (misalnya, TradeType, Color, Position).
• from robot_wrapper import * memuat fungsi pembantu dan pembungkus yang menyederhanakan operasi trading umum.

Sistem namespace memastikan bahwa:

• Nama bawaan Python (seperti print) menghindari konflik dengan nama cTrader (seperti api.Print).
• Semua objek khusus trading (api.Symbol, api.Indicators, api.ExecuteMarketOrder) berasal dari namespace cTrader Algo API, menjaga mereka terorganisir dan berbeda.
• Anda dapat memperluas fungsionalitas dengan mengimpor paket kustom Anda sendiri untuk bekerja bersama tipe bawaan cTrader.

Loop

Loop memungkinkan Anda mengulang operasi pada urutan nilai atau sampai kondisi terpenuhi. Dalam trading algoritmik, loop sering digunakan untuk memproses posisi (misalnya, menutup, memfilter atau memperbaruinya), memeriksa kondisi di beberapa aset atau indikator, menerapkan strategi grid atau martingale di mana penempatan order berulang diperlukan dan lainnya.

Di Python, iterasi mudah dilakukan dan mendukung baik loop for (untuk iterasi melalui koleksi) dan loop while (untuk pengulangan sampai kondisi berubah).

Anda dapat menulis loop untuk menutup posisi:

1
2
3
4

def close_positions(self, tradeType):
    for position in self.get_bot_positions():
        if position.TradeType == tradeType:
            api.ClosePosition(position)

Dalam kasus ini:

• self.get_bot_positions() mengembalikan semua posisi yang dimiliki oleh cBot saat ini.
• Loop for melalui setiap posisi.
• Posisi yang cocok ditutup dengan api.ClosePosition.

Pertimbangkan loop berbeda yang melakukan iterasi pada semua posisi grid terbuka, menutupnya satu per satu dan secara rekursif memeriksa apakah ada posisi yang tersisa (pengamanan jika terjadi penutupan parsial).

1
2
3
4
5
6

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()

Pernyataan kondisional

Pernyataan kondisional mengontrol alur eksekusi di Python dengan memungkinkan algoritma Anda membuat keputusan berdasarkan ekspresi logis. Kondisional adalah tulang punggung logika strategi, menentukan kapan harus masuk, keluar atau mengelola posisi.

Python mendukung tiga konstruksi kondisional utama:

• if – mengeksekusi kode ketika kondisi benar.
• elif (else if) – memeriksa kondisi lain jika yang pertama salah.
• else – memberikan fallback ketika tidak ada kondisi yang terpenuhi.

Pertimbangkan kondisi persilangan MACD yang dinyatakan dalam kode ini:

1
2
3
4

if self.macd.MACD.Last(0) > self.macd.Signal.Last(0):
    api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, self.volumeInUnits, api.Label, api.StopLossInPips, api.TakeProfitInPips)
elif self.macd.MACD.Last(0) < self.macd.Signal.Last(0):
    api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, self.volumeInUnits, api.Label, api.StopLossInPips, api.TakeProfitInPips)

Struktur ini:

• Menempatkan order beli ketika garis MACD berada di atas garis sinyal.
• Menempatkan order jual ketika garis MACD berada di bawah garis sinyal.
• Melewatkan trading jika tidak ada sinyal yang jelas.

Daftar

Python menyediakan alat yang kuat dan ringkas untuk bekerja dengan kumpulan data, seperti trading, harga atau indikator. Dua yang paling umum adalah list comprehension dan fungsi agregasi bawaan seperti sum().

Misalnya, Anda dapat menulis kode yang melakukan iterasi pada numbers dan hanya menyimpan angka genap dengan cara ini:

1
2

numbers = [1, 2, 3, 4, 5]
squares = [n**2 for n in numbers if n % 2 == 0]

Anda dapat menggunakan list comprehension untuk memilih hanya posisi untuk simbol saat ini, menghasilkan daftar terfilter yang berguna dalam lingkungan multi-simbol.

1

positions = [p for p in api.Positions if p.SymbolName == api.SymbolName]

Mengagregasi laba atau volume menggunakan sum() adalah pendekatan standar dalam strategi trading grid untuk menentukan kapan total laba memenuhi target.

1

net_profit_sum = sum([p.NetProfit for p in grid_positions])

Anda dapat menggabungkan penyaringan dan agregasi dengan cara ini:

1
2

buy_positions = [p for p in api.Positions if p.TradeType == TradeType.Buy]
avg_buy_price = sum([p.EntryPrice * p.VolumeInUnits for p in buy_positions]) / sum([p.VolumeInUnits for p in buy_positions])

Operasi sinkron dan asinkron

Python mengikuti model eksekusi sinkron secara default. Metode siklus hidup algoritma Anda, seperti on_start, on_tick dan on_bar_closed, dipicu oleh loop event platform, satu per satu.

Berikut adalah representasi dasar alur trading sinkron:

graph TD
    A(Menemui sinyal) ==> B(Mengeksekusi order)
    B ==> C(Posisi mencapai TP/SL)
    C ==> D(Menutup posisi)
    D ==> A

Dalam alur sinkron, operasi yang berjalan lama dapat memblokir thread, berpotensi menunda event berikutnya. Namun, dalam strategi dunia nyata, algoritma biasanya memulai tindakan non-blocking, seperti mengirimkan order atau mengatur stop-loss dan take-profit, kemudian menunggu event di masa depan (seperti tick atau bar baru) untuk menangani hasilnya. Pengaturan ini menghasilkan orkestrasi mirip asinkron, meskipun konstruksi async/await Python tidak digunakan.

cTrader mengelola konkurensi dengan menserialkan callback berbasis event Anda. Setiap metode dipanggil secara independen dan tidak pernah secara paralel, menghilangkan kebutuhan untuk pengamanan multithreading. Desain ini memungkinkan strategi untuk merespons beberapa kondisi trading sekaligus, dalam arti logis, tanpa memblokir.

Dalam contoh di bawah ini, strategi mengevaluasi sinyal beli dan jual secara independen dan merespons sesuai, tanpa tumpang tindih dalam konteks eksekusi.

graph TD
    A([Menerima sinyal]) ==> B([Membuka order beli]) & C([Membuka order jual untuk<br> lindung nilai]) ==> D([Sebuah order mencapai<br>take profit atau stop loss])
    D ==> E([Menutup posisi])
    E ==> A

Meskipun keputusan mungkin tampak paralel, mereka ditangani secara berurutan oleh sistem antrian internal cTrader. Arsitektur platform bertujuan untuk mencegah masalah konkurensi sambil menjaga robot trading responsif terhadap perubahan pasar.