Algoritmik işlem yapma için Python temelleri

Trader'lar, algoritmik işlem yapmaya veya manuel işlemlere yardımcı olmak için işlem botları, teknik göstergeler, eklentiler ve diğer araçları oluşturmak için Python kullanır ve bu makale Python'daki kodlama temellerini açıklar.

Python, web geliştirme, veri bilimi, otomasyon ve daha yakın zamanda cTrader'da algoritmik işlem yapma için kullanılan popüler, üst düzey, genel amaçlı bir programlama dilidir. İster basit sinyal tabanlı işlem botları ister karmaşık çoklu gösterge stratejileri oluşturuyor olun, Python süreci daha hızlı, daha verimli ve yönetimi daha kolay hale getirir.

Değişkenler ve veri türleri

Python'da değişkenler dinamik olarak yazılır, bu da veri türlerini açıkça belirtmenize gerek olmadığı anlamına gelir. Yorumlayıcı, atanan değere göre türü çalışma zamanında belirler.

Değişkenleri basitçe birine değer atayarak oluşturursunuz:

1
2
3
4

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

Yaygın veri türleri

cTrader algoritmalarında, değişkenler piyasa bilgileri, işlem kararları ve cBot yapılandırmasıyla ilgili önemli verileri depolar. Bu değişkenler genellikle hesaplanmış işlem hacimlerini, gösterge değerlerini, Boole bayraklarını, sembol adlarını, etiketleri ve daha fazlasını temsil eder.

İşte bir örnek:

1
2
3
4

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

Bu durumda,self.volumeInUnits emir vermek için kullanılan bir float iken, self.enoughMoney bir grid stratejisinde pozisyon açmaya devam edip etmeyeceğini kontrol eden bir bool'dur.

Sınıflar ve nesneler

Python, gerçek dünya varlıklarını ve davranışlarını modelleyen sınıflar ve nesneler aracılığıyla kodu düzenlemek için araçlar sağlayan nesne yönelimli bir programlama (OOP) dilidir. Bir sınıf, kendi benzersiz verileri ve davranışları olan o sınıfın örnekleri olan nesneler oluşturmak için bir taslak tanımlar. Temel kavramlar aşağıda özetlenmiştir:

• Bir sınıf, class anahtar kelimesi kullanılarak tanımlanır.
• __init__ metodu (yapıcı), nesne durumunu başlatmak için yaygın olarak kullanılır.
• Örnek metotlar davranışı tanımlar.
• Öznitelikler, her nesneye özgü verileri tutar.

Örneğin, bir Car sınıfı oluşturabilirsiniz:

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

Ardından Car sınıfının nesnelerini oluşturabilir ve onlarla etkileşim kurabilirsiniz:

1
2
3

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

cTrader bağlamında

cTrader'da cBot'lar, göstergeler ve eklentiler, tüm mantıklarını kapsayan sınıflar olarak uygulanır. Algoritmalar, sembollere, grafiklere, emirlere, göstergelere ve daha fazlasına erişim sağlayan özel bir api nesnesi kullanarak cTrader platformuyla etkileşim kurar.

cTrader'da SimplecBot sınıfını bu şekilde oluşturabilirsiniz:

1
2
3

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

SimplecBot sınıfı, işlem botu başladığında bir kez yürütülen tek bir metot (on_start(self)) içerir. api.Print fonksiyonu, nesne metotlarının işlem davranışını nasıl kapsadığını göstererek günlüğe bir mesaj yazar.

Bir sınıfın her örneği, OOP prensiplerini kullanarak kendi yaşam döngüsünü ve işlem kararlarını yöneten, kendi içinde bağımsız bir işlem algoritmasını etkili bir şekilde temsil eder. Standart bir cTrader cBot'unda, bir sınıf hacim, gösterge sonuçları vb. gibi dahili durum verilerini depolayabilir ve işlem mantığını yönetmek için çeşitli metotlar kullanabilir.

Başlatıldığında MACD göstergesini başlatan ve bir MACD kesişim sinyali oluştuğunda bir alış emri veren bu MACD kesişim örneğini ele alalım:

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)

self anahtar kelimesi

Bir sınıfın içinde, self sınıfın örneğine atıfta bulunur ve değişkenlerine ve metotlarına erişim sağlar. self şunlar için kullanılır:

• Gösterge sonuçları, pozisyon hacimleri ve yapılandırma değerleri gibi verileri depolamak.
• on_start(), on_tick() veya on_bar_closed() gibi farklı metot çağrıları arasında dahili durumu izlemek.

Bu örnek, self'in nasıl kullanıldığını gösterir:

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)

Bu durumda,self.volume işlemler için kullanılacak hesaplanmış hacmi depolarken, self.macd MACD gösterge nesnesini depolar ve cBot'un yaşam döngüsü boyunca değerlerine erişim sağlar. self olmadan, bu değişkenler on_start()'a yerel olur ve işlem kararlarının alınabileceği on_bar_closed()'da erişilemez olurdu.

Metotlar ve fonksiyonlar

Fonksiyonlar, belirli bir görevi gerçekleştirmek için kullanılan yeniden kullanılabilir kod bloklarıdır. Fonksiyonlar bir sınıfın içinde tanımlandığında, metot olarak adlandırılırlar ve self parametresi aracılığıyla sınıfın dahili durumu üzerinde çalışırlar. cTrader ile algoritmik işlem yapma bağlamında, metotlar işlem algoritmanızın piyasa tick'leri, bar kapanışları veya başlatma gibi farklı koşullar altında nasıl davrandığını tanımlar.

Platform, uygun zamanlarda özel metotları (olay işleyicileri olarak bilinir) otomatik olarak çağırır, örneğin:

on_start(self) – bot başlatıldığında bir kez çağrılır.

1
2

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

on_tick(self) – gelen her piyasa tick'inde çağrılır.

1
2

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

on_bar_closed(self) – yeni bir mum/bar kapandığında çağrılır (zaman tabanlı stratejiler için idealdir).

1
2
3
4

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

Özel veya yardımcı metotlar

Kodu yeniden yazmaktan ve çoğaltmaktan kaçınmak için kendi metotlarınızı tanımlayabilirsiniz. Bu tür özel metotlar, işlem robotunuzun yeniden kullanabileceği ortak mantığı kapsüllemelidir.

Aşağıdaki metot, mevcut cBot'un etiketiyle ilişkili tüm açık pozisyonları döndürerek pozisyonları tutarlı bir şekilde izlemeyi veya kapatmayı kolaylaştırır.

1
2

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

Mevcut fiyat ile pozisyonun giriş fiyatı arasındaki pip cinsinden mesafeyi hesaplayan başka bir metodu ele alalım; bu, grid tabanlı stratejilerdeki kararlar için kritik öneme sahiptir.

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

Bir metot tanımlandıktan sonra, self anahtar kelimesini kullanarak aynı sınıf içinden çağırabilirsiniz. Bu yaklaşım, kodu kopyalamadan mantığı botunuzun herhangi bir yerinde yeniden kullanmanızı sağlar.

Örneğin, get_bot_positions() tanımladıktan sonra, tüm pozisyonları kapatmak için onu başka bir metodun içinde çağırabilirsiniz:

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)

Burada, self.get_bot_positions() yardımcı metodu çağırır ve yalnızca mevcut bot etiketine bağlı pozisyonları döndürür.

Benzer şekilde, get_distance_in_pips() metodu işlem kararları vermek için yeniden kullanılabilir. Örneğin, bir grid stratejisinde, yeni bir emir açmak için piyasanın son pozisyondan yeterince uzaklaşmış olmasını isteyebilirsiniz:

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

Diğer kavramlar

Ad alanları ve içe aktarmalar

Python'daki ad alanları, ilgili tanımlayıcıları (değişkenler, fonksiyonlar, sınıflar) gruplandırarak kodu düzenlemeye ve ad çakışmalarını önlemeye yardımcı olur. İçe aktarmalar, Python'ın standart özelliklerinin ötesinde işlevselliği genişletmek için harici modüller, kütüphaneler veya paketler getirmenizi sağlar.

Python'da standart modülleri veya özel paketleri içe aktarabilirsiniz:

1
2

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

Belirli fonksiyonları veya sınıfları da içe aktarabilirsiniz:

1
2

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

Python'da cTrader için algoritmalar yazarken, içe aktarmalar biraz farklı çalışır çünkü cTrader, .NET tabanlı cTrader Algo API ile entegre olur. Bu kurulum, Python kodunun .NET derlemeleriyle etkileşime girmesini sağlayan bir köprü içerir ve bu, tipik bir cBot'un neden şununla başladığını açıklar:

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 *

Burada:

• import clr, Python'ın .NET kütüphaneleriyle birlikte çalışmasını sağlayan Ortak Dil Çalışma Zamanı'nı (CLR) yükler.
• clr.AddReference("cAlgo.API"), tüm işlemle ilgili sınıfları, metodları ve nesneleri içeren cAlgo API derlemesine referans verir.
• from cAlgo.API import *, API'den tüm türleri (örn., TradeType, Color, Position) getirir.
• from robot_wrapper import *, yaygın işlem operasyonlarını basitleştiren yardımcı fonksiyonları ve sarmalayıcıları yükler.

Ad alanı sistemi şunları sağlar:

• Python'ın yerleşik adları (örneğin print), cTrader'ın adlarıyla (örneğin api.Print) çakışmaları önler.
• Tüm işleme özel nesneler (api.Symbol, api.Indicators, api.ExecuteMarketOrder) cTrader Algo API ad alanından gelir ve onları düzenli ve farklı tutar.
• cTrader'ın yerleşik türleriyle birlikte çalışmak için kendi özel paketlerinizi içe aktararak işlevselliği genişletebilirsiniz.

Döngüler

Döngüler, işlemleri bir değer dizisi üzerinde veya bir koşul karşılanana kadar tekrarlamanızı sağlar. Algoritmik işlem yapmada, döngüler genellikle pozisyonları işlemek (örn., kapatmak, filtrelemek veya güncellemek), birden fazla varlık veya gösterge genelinde koşulları kontrol etmek, tekrarlanan emir yerleştirmenin gerektiği grid veya martingale stratejilerini uygulamak ve daha fazlası için kullanılır.

Python'da yineleme basittir ve hem for döngülerini (koleksiyonlar arasında yineleme için) hem de while döngülerini (bir koşul değişene kadar tekrarlamak için) destekler.

Pozisyonları kapatmak için bir döngü yazabilirsiniz:

1
2
3
4

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

Bu durumda:

• self.get_bot_positions(), mevcut cBot'a ait tüm pozisyonları döndürür.
• for döngüsü her pozisyonu dolaşır.
• Eşleşen pozisyonlar api.ClosePosition ile kapatılır.

Tüm açık grid pozisyonları üzerinde yineleyen, onları tek tek kapatan ve herhangi bir pozisyonun kalıp kalmadığını özyinelemeli olarak kontrol eden (kısmi kapanışlar durumunda güvenlik için) farklı bir döngü düşünün.

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

Koşullu ifadeler

Koşullu ifadeler, algoritmanızın mantıksal ifadelere dayalı kararlar almasını sağlayarak Python'da yürütme akışını kontrol eder. Koşullular, strateji mantığının omurgasıdır ve pozisyonlara ne zaman girileceğini, çıkılacağını veya yönetileceğini belirler.

Python üç ana koşullu yapıyı destekler:

• if – koşul doğru olduğunda kodu yürütür.
• elif (else if) – ilk koşul yanlışsa başka bir koşulu kontrol eder.
• else – hiçbir koşul karşılanmadığında bir yedek sağlar.

Bu kodda ifade edilen MACD geçiş koşullarını düşünün:

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)

Bu yapı:

• MACD çizgisi sinyal çizgisinin üzerinde olduğunda bir alış emri verir.
• MACD çizgisi sinyal çizgisinin altında olduğunda bir satış emri verir.
• Net bir sinyal yoksa işlem yapmayı atlar.

Listeler

Python, işlemler, fiyatlar veya göstergeler gibi veri koleksiyonlarıyla çalışmak için güçlü ve özlü araçlar sağlar. En yaygın ikisi, liste anlama ve sum() gibi yerleşik toplama fonksiyonlarıdır.

Örneğin, numbers üzerinde yineleyen ve bu şekilde yalnızca çift sayıları tutan bir kod yazabilirsiniz:

1
2

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

Mevcut sembol için yalnızca pozisyonları seçmek üzere bir liste anlama kullanabilir, çoklu sembol ortamlarında faydalı olan filtrelenmiş bir liste üretebilirsiniz.

1

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

sum() kullanarak kar veya hacmi toplamak, toplam karın hedefi ne zaman karşıladığını belirlemek için grid işlem stratejilerinde standart bir yaklaşımdır.

1

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

Filtrelemeyi ve toplamayı bu şekilde birleştirebilirsiniz:

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

Senkron ve asenkron işlemler

Python varsayılan olarak senkron bir yürütme modelini takip eder. Algoritmanızın on_start, on_tick ve on_bar_closed gibi yaşam döngüsü metodları, platformun olay döngüsü tarafından birer birer tetiklenir.

İşte senkron bir işlem akışının temel bir gösterimi:

graph TD
    A(Sinyal algılama) ==> B(Emir yürütme)
    B ==> C(Pozisyon TP/SL'ye<br>ulaşır)
    C ==> D(Pozisyonu kapatma)
    D ==> A

Senkron akışlarda, herhangi bir uzun süreli işlem iş parçacığını bloke edebilir, bir sonraki olayı potansiyel olarak geciktirerek. Ancak, gerçek dünya stratejilerinde, algoritmalar genellikle bir emir göndermek veya zarar durdur ve kâr al ayarlamak gibi engellemeyen eylemleri başlatır, sonra sonuçları işlemek için gelecekteki olayları (yeni bir tik veya çubuk gibi) beklerler. Bu kurulum, Python'ın async/await yapıları kullanılmasa bile asenkron benzeri bir orkestrasyonla sonuçlanır.

cTrader, olay tabanlı geri çağrılarınızı serileştirerek eşzamanlılığı yönetir. Her metod bağımsız olarak çağrılır ve asla paralel olarak değil, çoklu iş parçacığı korumalarına olan ihtiyacı ortadan kaldırır. Bu tasarım, stratejilerin mantıksal anlamda, engellemeden birden fazla işlem koşuluna aynı anda yanıt vermesini sağlar.

Aşağıdaki örnekte, strateji alış ve satış sinyallerini bağımsız olarak değerlendirir ve yürütme bağlamında herhangi bir çakışma olmadan buna göre yanıt verir.

graph TD
    A([Sinyal algılama]) ==> B([Alış emri<br>açma]) & C([Riskten<br>korunma için<br>satış emri açma]) ==> D([Bir emir<br>kâr al veya<br>zarar durdur<br>seviyesine ulaşır])
    D ==> E([Pozisyonu kapatma])
    E ==> A

Kararlar paralel gibi görünse de, cTrader'ın dahili kuyruklama sistemi tarafından sıralı olarak ele alınır. Platform mimarisi, işlem robotlarını piyasa değişikliklerine duyarlı tutarken eşzamanlılık sorunlarını önlemeyi amaçlar.