今回は、手元の解析環境(Core i5-8500 @ 3.00GHz / 6コア6スレッド / RAM 32GB / M.2 SSD 1TB)を使って、Python と Go(Golang) のどちらでバックテストを回すべきか、実測ベンチマークをもとに整理した備忘録です。
第8世代CPUの中古PCにメモリ増設とM.2 SSD換装を加えた、お小遣いレベルで作れる庶民環境です。
「Pythonは基本シングルスレッド、Goは6コアを使って1レコードずつループ処理する」という大枠のイメージから一歩踏み込み、実際の3,404万行ティックデータ(tick_master.npy → tick_master_col4.bin)で速度差を数値化しました。
1. まず押さえておきたい仕組みの整理
- Goは「自動的に6コア全部を使う」わけではない:通常の
forループを書いただけでは1コア(1ゴルーチン)で動きます。6コアを活かすには、ゴルーチン(go func())で処理を分割する設計が必要です。 - Pythonは「配列・列演算」が得意、1行ループは苦手:NumPyやPolarsなどの内部処理は高速ですが、建玉・SL/TP・スプレッドなどの状態を1ティックずつ更新するループはPythonの純粋な
forだと重くなります。 - .npy を生の .bin(int32)にすると相性抜群:既存のNumPy配列を連続メモリで
.bin書き出ししておくと、Go側でパースの手間なく一気に読み込め、RAM 32GB+M.2 SSDの恩恵を最大限に受けられます。
2. ベンチマーク実測結果(34,045,105行 × 10回)
tick_master.npy(形状 (34045106, 16)・int32)から対象列を切り出し、tick_master_col4.bin(129.9MB)を生成(読み込み&書き出しは 0.158秒)。同一条件のティック状態遷移ループを10回連続実行した実測値は以下の通りです。
| 実行方式 | 1回あたり平均 | 10回合計(約3.4億行) | 対Pythonループ倍率 | 100条件回した場合の目安 |
|---|---|---|---|---|
| Python(生 for ループ) | 約 21.63 秒 | 約 216.35 秒(約3分36秒) | 基準(1倍) | 約 36.1 分 |
| Go(1コア / 単一ゴルーチン) | 約 57.45 ms(0.0575秒) | 約 574.54 ms(0.575秒) | 約 377 倍 | 約 5.7 秒 |
| Go(6コア / 6ゴルーチン並列) | 約 11.47 ms(0.0115秒) | 約 114.68 ms(0.115秒) | 約 1,887 倍 | 約 1.15 秒 |
実測メモ:Go 1コアは
trades=291044, pnl_pts=-649742でPythonと完全一致。Go 6コアはtrades=291049, pnl_pts=-649772とわずかに差が出ましたが、これは6分割したチャンク境界(5箇所)で建玉保有中の状態がリセットされたためです。
3. Python と Go の現実的な使い分け
- ざっくり傾向を見る・前処理・可視化 → Python:仮説出し、データ整形、指標・集計、グラフ描画など「試行錯誤の速さ」や「表現力」が活きる工程はPythonが快適です。
- パラメータを大量に試す・重い1行ループ → Go:グリッド/ランダム探索や、約定・建玉管理を伴う数千万〜数億行ループはGoのコンパイル済みバイナリ+6コア並列が圧倒的です。
- 注意点(カーブフィッティング):探索が速くなるほど大量に試せてしまいますが、最適値周辺でパラメータをズラしても成績が崩れないか、別期間でも傾向が再現するかの確認は忘れずに行います。
4. 今回使ったベンチマークコード(記録用)
Python側(.npy → .bin 出力 + 10回ループ計測)
import time
import numpy as np
NPY_PATH = "tick_master.npy"
BIN_PATH = "tick_master_col4.bin"
BID_COL = 4
START_ROW = 1
RUNS = 10
t_load0 = time.perf_counter()
arr = np.load(NPY_PATH, mmap_mode="r")
bid = np.ascontiguousarray(arr[START_ROW:, BID_COL], dtype=np.int32)
t_load1 = time.perf_counter()
//Go用の.binファイルを生成
np.ascontiguousarray(bid, dtype=np.int32).tofile(BIN_PATH)
n_rows = len(bid)
print(f"Loaded & sliced rows={n_rows:,} in {t_load1 - t_load0:.3f}s | Exported {BIN_PATH} ({bid.nbytes / (1024**2):.1f} MB)\n")
//ベンチマーク開始
entry_thresh = 4
sl = 15
tp = 25
spread = 3
sentinel = -2147483648
times = []
for r in range(1, RUNS + 1):
t0 = time.perf_counter()
pos = 0
entry = 0
pnl_sum = 0
trades = 0
for i in range(1, n_rows):
p = int(bid[i])
prev = int(bid[i - 1])
if p == sentinel or prev == sentinel:
continue
if pos == 0:
if p > prev + entry_thresh:
pos = 1
entry = p + spread
trades += 1
else:
diff = p - entry
if diff <= -sl or diff >= tp:
pnl_sum += diff
pos = 0
dt = time.perf_counter() - t0
times.append(dt)
print(f"[Python Loop] Run {r:02d}: {dt:.4f}s | trades={trades} | pnl_pts={pnl_sum}")
print(f"\n[Python Loop] Avg ({RUNS} runs, {n_rows:,} rows/run): {sum(times)/len(times):.4f}s | Total: {sum(times):.4f}s")
Go側(.bin 読み込み + 1コア / 6コア並列で10回計測)
package main
import (
"encoding/binary"
"fmt"
"os"
"sync"
"time"
)
func loadInt32Bin(path string) ([]int32, error) {
raw, err := os.ReadFile(path)
if err != nil {
return nil, err
}
count := len(raw) / 4
out := make([]int32, count)
for i := 0; i < count; i++ {
out[i] = int32(binary.LittleEndian.Uint32(raw[i*4 : (i+1)*4]))
}
return out, nil
}
func runChunk(bid []int32, entryThresh, sl, tp, spread int32) (int, int64) {
const sentinel int32 = -2147483648
pos := 0
var entry int32 = 0
trades := 0
var pnlSum int64 = 0
for i := 1; i < len(bid); i++ {
p := bid[i]
prev := bid[i-1]
if p == sentinel || prev == sentinel {
continue
}
if pos == 0 {
if p > prev+entryThresh {
pos = 1
entry = p + spread
trades++
}
} else {
diff := int64(p) - int64(entry)
if diff <= int64(-sl) || diff >= int64(tp) {
pnlSum += diff
pos = 0
}
}
}
return trades, pnlSum
}
func main() {
const binPath = "tick_master_col4.bin"
const runs = 10
const entryThresh int32 = 4
const sl int32 = 15
const tp int32 = 25
const spread int32 = 3
tLoad := time.Now()
bid, err := loadInt32Bin(binPath)
if err != nil {
panic(err)
}
fmt.Printf("Loaded %d int32 rows in %v\n\n", len(bid), time.Since(tLoad))
var sum1 time.Duration
for r := 1; r <= runs; r++ {
t0 := time.Now()
tr, pnl := runChunk(bid, entryThresh, sl, tp, spread)
dt := time.Since(t0)
sum1 += dt
fmt.Printf("[Go 1-Core] Run %02d: %v | trades=%d | pnl_pts=%d\n", r, dt, tr, pnl)
}
fmt.Printf("[Go 1-Core] Avg (%d runs): %v | Total: %v\n\n", runs, sum1/runs, sum1)
const workers = 6
var sum6 time.Duration
chunkSize := len(bid) / workers
for r := 1; r <= runs; r++ {
t0 := time.Now()
var wg sync.WaitGroup
trArr := make([]int, workers)
pnlArr := make([]int64, workers)
for w := 0; w < workers; w++ {
start := w * chunkSize
end := start + chunkSize
if w == workers-1 {
end = len(bid)
}
wg.Add(1)
go func(idx, s, e int) {
defer wg.Done()
trArr[idx], pnlArr[idx] = runChunk(bid[s:e], entryThresh, sl, tp, spread)
}(w, start, end)
}
wg.Wait()
totalTr := 0
var totalPnl int64 = 0
for w := 0; w < workers; w++ {
totalTr += trArr[w]
totalPnl += pnlArr[w]
}
dt := time.Since(t0)
sum6 += dt
fmt.Printf("[Go 6-Core] Run %02d: %v | trades=%d | pnl_pts=%d\n", r, dt, totalTr, totalPnl)
}
fmt.Printf("[Go 6-Core] Avg (%d runs): %v | Total: %v\n", runs, sum6/runs, sum6)
}
