Algorytmiczny trading: jak pisać własne strategie z użyciem Pythona

Algorytmiczny trading już dawno przestał być domeną funduszy hedgingowych i wielkich graczy rynkowych. Dzięki Pythonowi i otwartym bibliotekom każdy może napisać własne strategie handlowe, zautomatyzować proces i nawet stworzyć dochodowy system. W tym artykule omówimy, jak pisać algorytmy do tradingu, jakie narzędzia wykorzystać i jak testować strategie przed wdrożeniem.

1. Dlaczego Python?

Python jest głównym językiem programowania w algorytmicznym tradingu z kilku powodów:

• Prosta składnia – pozwala szybko pisać i testować kod.
• Bogaty ekosystem – biblioteki do analizy danych, machine learningu i API giełdowych.
• Elastyczność – łatwa integracja z brokerami, giełdami kryptowalut, serwerami i chmurą.

Najpopularniejsze biblioteki do tradingu w Pythonie:

• pandas – analiza i przetwarzanie danych.
• numpy – szybkie obliczenia matematyczne.
• ccxt – połączenie z giełdami kryptowalut przez API.
• backtrader lub zipline – testowanie strategii.
• ta – wskaźniki analizy technicznej.

2. Architektura bota tradingowego

Standardowy algorytmiczny system tradingowy składa się z następujących modułów:

1. Pobieranie danych
   • Pobieranie cen z giełdy przez API.
   • Przechowywanie danych w pamięci podręcznej lub bazie danych.
2. Analiza danych
   • Obliczanie wskaźników (SMA, RSI, MACD itp.).
   • Wykrywanie wzorców i trendów.
3. Podejmowanie decyzji
   • Algorytm określający punkty wejścia i wyjścia.
   • Zarządzanie ryzykiem (stop-loss, take-profit).
4. Realizacja transakcji
   • Wysyłanie zleceń przez API giełdy.
   • Monitorowanie wykonania.
5. Logowanie i monitoring
   • Rejestrowanie transakcji.
   • Śledzenie błędów i optymalizacja strategii.

3. Połączenie z giełdą i pobieranie danych

Połączmy się z giełdą Binance za pomocą ccxt i pobierzmy dane historyczne:

import ccxt
import pandas as pd

# Połączenie z Binance
exchange = ccxt.binance()

# Pobranie danych historycznych dla BTC/USDT
bars = exchange.fetch_ohlcv('BTC/USDT', timeframe='1h', limit=100)

# Konwersja do DataFrame
df = pd.DataFrame(bars, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')

print(df.tail())

Teraz mamy dane, z którymi możemy pracować.

4. Tworzenie prostej strategii (SMA crossover)

Jedną z najprostszych strategii jest crossover dwóch średnich kroczących (SMA). Gdy krótsza SMA przecina dłuższą od dołu – kupujemy, gdy od góry – sprzedajemy.

Implementacja w Pythonie:

import numpy as np

# Obliczanie średnich kroczących
df['SMA_50'] = df['close'].rolling(window=50).mean()
df['SMA_200'] = df['close'].rolling(window=200).mean()

# Generowanie sygnałów
df['signal'] = np.where(df['SMA_50'] > df['SMA_200'], 1, -1)

print(df.tail())

Kolumna signal zawiera wartość 1 (kupno) lub -1 (sprzedaż).

5. Backtesting strategii

Przed wdrożeniem strategii należy ją przetestować na danych historycznych. Użyjemy do tego backtrader:

import backtrader as bt

class SmaCross(bt.Strategy):
    params = dict(short_period=50, long_period=200)

    def __init__(self):
        self.sma_short = bt.indicators.SimpleMovingAverage(period=self.params.short_period)
        self.sma_long = bt.indicators.SimpleMovingAverage(period=self.params.long_period)

    def next(self):
        if self.sma_short[0] > self.sma_long[0]:
            self.buy()
        elif self.sma_short[0] < self.sma_long[0]:
            self.sell()

# Tworzenie systemu backtestingu
cerebro = bt.Cerebro()
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
cerebro.addstrategy(SmaCross)
cerebro.run()
cerebro.plot()

Ten kod sprawdza, jak strategia działałaby w przeszłości.

6. Automatyczne wykonywanie transakcji

Po przetestowaniu strategii możemy zautomatyzować trading. Przykładowe zlecenie kupna na Binance:

api_key = "TWÓJ_API_KEY"
api_secret = "TWÓJ_API_SECRET"

exchange = ccxt.binance({
    'apiKey': api_key,
    'secret': api_secret
})

# Złożenie zlecenia rynkowego na zakup 0.01 BTC
order = exchange.create_market_buy_order('BTC/USDT', 0.01)
print(order)

7. Zarządzanie ryzykiem

Przy tworzeniu bota tradingowego kluczowe jest zarządzanie kapitałem:

• Stop-loss – ogranicza straty.
• Trailing-stop – pozwala zabezpieczyć zyski.
• Wielkość pozycji – dostosowanie wielkości transakcji do kapitału.

Kod do obliczania wielkości pozycji (ryzyko 2%):

capital = 10000  # Kapitał początkowy
risk_per_trade = 0.02  # 2% ryzyka
stop_loss = 200  # Maksymalna strata na transakcję
trade_size = (capital * risk_per_trade) / stop_loss

print(f"Zalecana wielkość pozycji: {trade_size} USDT")

Podsumowanie

Teraz masz podstawową wiedzę na temat pisania strategii algorytmicznych w Pythonie:
✅ Pobieranie danych przez API
✅ Użycie wskaźników analizy technicznej
✅ Backtesting na danych historycznych
✅ Automatyczne wykonywanie transakcji
✅ Zarządzanie ryzykiem

Możesz teraz rozwijać strategię, dodając machine learning, zaawansowane wskaźniki i optymalizację parametrów.

Jeśli chcesz poznać bardziej zaawansowane tematy, jak market making, HFT czy strategie arbitrażowe – daj znać w komentarzach, a omówimy je w kolejnych artykułach! 🚀