Step 1: fetch_ohlcv() で過去OHLCVデータを取得
        ↓
Step 2: pandasでデータ整形・インジケーター計算
        ↓
Step 3: 手数料・スリッページを考慮してシミュレーション
        ↓
Step 4: シャープレシオ・ドローダウン・プロフィットファクター等の指標を算出・評価

import ccxt
import pandas as pd
import time

exchange = ccxt.binance({
    'rateLimit': 1200,
    'enableRateLimit': True,
    'timeout': 30000,
    'options': {
        'defaultType': 'spot',
        'adjustForTimeDifference': True,
    },
})

def fetch_all_ohlcv(symbol, timeframe, days=365, max_retries=3):
    """大量データを分割取得する関数"""
    all_ohlcv = []
    since = exchange.parse8601(
        (pd.Timestamp.now() - pd.Timedelta(days=days)).strftime('%Y-%m-%dT00:00:00Z')
    )
    limit = 500  # 1回あたりの最大取得数

    while True:
        retries = 0
        ohlcv = None
        while retries < max_retries:
            try:
                ohlcv = exchange.fetch_ohlcv(symbol, timeframe, since=since, limit=limit)
                break
            except ccxt.BaseError as e:
                retries += 1
                print(f"データ取得エラー ({retries}/{max_retries}): {e}")
                if retries >= max_retries:
                    raise
                time.sleep(5 * retries)

        if not ohlcv:
            break
        all_ohlcv.extend(ohlcv)
        since = ohlcv[-1][0] + 1  # 最後のタイムスタンプの次から
        time.sleep(exchange.rateLimit / 1000)  # レートリミット対策

        # 直近データに達したら終了
        if len(ohlcv) < limit:
            break

    if not all_ohlcv:
        raise ValueError("OHLCVデータを取得できませんでした")

    # DataFrameに変換
    df = pd.DataFrame(all_ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    df = df.set_index('timestamp')
    df = df[~df.index.duplicated(keep='first')]  # 重複除去
    return df

# 実行
try:
    df = fetch_all_ohlcv('BTC/USDT', '1d', days=365)
    print(df.head())
    print(f"取得件数: {len(df)}件")
except ccxt.BaseError as e:
    print(f"取引所エラー: {e}")
except Exception as e:
    print(f"予期しないエラー: {e}")

import ccxt
import pandas as pd
import numpy as np

# --- データ取得 ---
exchange = ccxt.binance({
    'enableRateLimit': True,
    'timeout': 30000,
    'options': {
        'defaultType': 'spot',
        'adjustForTimeDifference': True,
    },
})

try:
    ohlcv = exchange.fetch_ohlcv('BTC/USDT', '1d', limit=300)
except ccxt.BaseError as e:
    raise RuntimeError(f"OHLCVデータの取得に失敗しました: {e}")

if not ohlcv:
    raise ValueError("取得したOHLCVデータが空です")

df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df = df.set_index('timestamp')

# --- インジケーター計算 ---
df['MA40'] = df['close'].rolling(40).mean()
df['MA100'] = df['close'].rolling(100).mean()

# シグナル生成：MA40がMA100を上回ったら買い(1)、下回ったら売り(0)
df['signal'] = (df['MA40'] > df['MA100']).astype(int)
df['position'] = df['signal'].diff()  # 1=買いエントリー、-1=売りエグジット

# --- シミュレーション ---
FEE_RATE = 0.001    # 手数料 0.1%（Binance Takerの場合）
SLIPPAGE = 0.0005   # スリッページ 0.05%
INITIAL_CAPITAL = 10000  # 初期資金（USDT）

capital = INITIAL_CAPITAL
position_size = 0
entry_price = 0
trades = []

for idx, row in df.dropna().iterrows():
    if row['position'] == 1:  # 買いエントリー
        # 手数料＋スリッページ込みの実効価格
        entry_price = row['close'] * (1 + FEE_RATE + SLIPPAGE)
        position_size = capital / entry_price
        capital = 0

    elif row['position'] == -1 and position_size > 0:  # 売りエグジット
        exit_price = row['close'] * (1 - FEE_RATE - SLIPPAGE)
        profit = (exit_price - entry_price) * position_size
        capital = position_size * exit_price
        trades.append({
            'exit_time': idx,
            'entry_price': entry_price,
            'exit_price': exit_price,
            'profit': profit,
            'return_pct': (exit_price - entry_price) / entry_price * 100
        })
        position_size = 0

# --- パフォーマンス指標 ---
trades_df = pd.DataFrame(trades)
if len(trades_df) > 0:
    total_return = (capital - INITIAL_CAPITAL) / INITIAL_CAPITAL * 100
    win_rate = len(trades_df[trades_df['profit'] > 0]) / len(trades_df) * 100
    avg_profit = trades_df[trades_df['profit'] > 0]['return_pct'].mean()
    avg_loss = trades_df[trades_df['profit'] < 0]['return_pct'].mean()
    profit_factor = (
        trades_df[trades_df['profit'] > 0]['profit'].sum() /
        abs(trades_df[trades_df['profit'] < 0]['profit'].sum())
        if trades_df[trades_df['profit'] < 0]['profit'].sum() != 0 else float('inf')
    )

    print(f"=== バックテスト結果 ===")
    print(f"総リターン        : {total_return:.2f}%")
    print(f"取引数            : {len(trades_df)}件")
    print(f"勝率              : {win_rate:.1f}%")
    print(f"平均利益          : {avg_profit:.2f}%")
    print(f"平均損失          : {avg_loss:.2f}%")
    print(f"プロフィットFactor: {profit_factor:.2f}")
else:
    print("取引が発生しませんでした")

import numpy as np

def calculate_sharpe_ratio(
    returns: pd.Series,
    risk_free_rate: float = 0.0,
    periods_per_year: int = 252
) -> float:
    """
    シャープレシオを計算する関数

    Parameters
    ----------
    returns : pd.Series
        各取引・各期間のリターン（小数表記。例：0.05 は5%）
    risk_free_rate : float
        年率リスクフリーレート（デフォルト 0.0）
    periods_per_year : int
        年間の取引期間数（日足なら252、時間足なら8760など）

    Returns
    -------
    float
        シャープレシオ
    """
    if len(returns) == 0 or returns.std() == 0:
        return 0.0
    excess_returns = returns - risk_free_rate / periods_per_year
    return float((excess_returns.mean() / excess_returns.std()) * np.sqrt(periods_per_year))


def calculate_max_drawdown(equity_curve: pd.Series) -> float:
    """
    最大ドローダウンを計算する関数

    Parameters
    ----------
    equity_curve : pd.Series
        資産推移の時系列データ（例：[10000, 10300, 9800, ...]）

    Returns
    -------
    float
        最大ドローダウン（0〜1の小数。例：-0.20 は -20%）
    """
    rolling_max = equity_curve.cummax()
    drawdown = (equity_curve - rolling_max) / rolling_max
    return float(drawdown.min())


# trades_df が取得済みの前提で使用例
if len(trades_df) > 0:
    # 各取引のリターンをSeries化（パーセント→小数に変換）
    returns_series = trades_df['return_pct'] / 100

    # 資産推移（初期資金から累積計算）
    equity_curve = (1 + returns_series).cumprod() * INITIAL_CAPITAL

    sharpe = calculate_sharpe_ratio(returns_series)
    max_dd = calculate_max_drawdown(equity_curve)

    print(f"シャープレシオ    : {sharpe:.3f}")
    print(f"最大ドローダウン  : {max_dd * 100:.2f}%")

def calculate_kelly_fraction(
    win_rate: float,
    avg_win: float,
    avg_loss: float
) -> float:
    """
    ケリー基準によるポジション比率を計算する関数

    Parameters
    ----------
    win_rate : float
        勝率（0〜1の小数。例：0.55 は55%）
    avg_win : float
        平均利益（小数表記の正の値。例：0.08 は8%）
    avg_loss : float
        平均損失（小数表記の正の絶対値。例：0.04 は4%損失）

    Returns
    -------
    float
        推奨ポジション比率（0〜1の小数）。
        計算結果がマイナスの場合は0を返す（期待値がないため）
    """
    if avg_loss == 0:
        return 0.0

    b = abs(avg_win / avg_loss)  # ペイオフレシオ（平均利益÷平均損失）
    p = win_rate                 # 勝率
    q = 1.0 - win_rate           # 負け率

    kelly = (b * p - q) / b      # ケリー公式

    # 期待値がゼロ以下（トレードしない方がいい）なら0を返す
    return max(0.0, kelly)


def get_position_size(
    capital: float,
    kelly_fraction: float,
    half_kelly: bool = True
) -> float:
    """
    実際のポジションサイズ（USDT建て）を計算する関数

    Parameters
    ----------
    capital : float
        現在の資産額（USDT）
    kelly_fraction : float
        calculate_kelly_fraction() の返り値
    half_kelly : bool
        True の場合、ハーフケリー（ケリー値の半分）を使用する

    Returns
    -------
    float
        投入すべき資金量（USDT）
    """
    multiplier = 0.5 if half_kelly else 1.0
    position_ratio = kelly_fraction * multiplier
    # 安全のため最大25%以上は張らない
    position_ratio = min(position_ratio, 0.25)
    return capital * position_ratio


# バックテスト結果から直接計算する使用例
if len(trades_df) > 0:
    avg_win_pct  = trades_df[trades_df['profit'] > 0]['return_pct'].mean() / 100
    avg_loss_pct = abs(trades_df[trades_df['profit'] < 0]['return_pct'].mean()) / 100
    win_rate_dec = len(trades_df[trades_df['profit'] > 0]) / len(trades_df)

    kelly = calculate_kelly_fraction(win_rate_dec, avg_win_pct, avg_loss_pct)
    position_usdt = get_position_size(capital=10000, kelly_fraction=kelly, half_kelly=True)

    print(f"ケリー比率 (full) : {kelly * 100:.1f}%")
    print(f"推奨ポジション   : {position_usdt:.2f} USDT（ハーフケリー）")

class DrawdownGuard:
    """
    最大ドローダウンを監視してトレードを制御するクラス

    Parameters
    ----------
    initial_capital : float
        初期資産額
    max_drawdown_limit : float
        これを超えたらトレードを停止するドローダウン上限
        （正の値で指定。例：0.20 は20%）
    """

    def __init__(self, initial_capital: float, max_drawdown_limit: float = 0.20):
        self.initial_capital = initial_capital
        self.peak_capital = initial_capital
        self.max_drawdown_limit = max_drawdown_limit
        self.is_trading_allowed = True

    def update(self, current_capital: float) -> bool:
        """
        現在の資産額をもとにドローダウンを更新し、トレード可否を返す

        Parameters
        ----------
        current_capital : float
            現在の資産額

        Returns
        -------
        bool
            True: トレード可、False: トレード停止
        """
        if current_capital > self.peak_capital:
            self.peak_capital = current_capital

        drawdown = (self.peak_capital - current_capital) / self.peak_capital

        if drawdown >= self.max_drawdown_limit:
            self.is_trading_allowed = False

        return self.is_trading_allowed

    def get_current_drawdown(self, current_capital: float) -> float:
        """現在のドローダウン率を返す（0〜1の小数）"""
        if self.peak_capital == 0:
            return 0.0
        return (self.peak_capital - current_capital) / self.peak_capital


# 使用例
guard = DrawdownGuard(initial_capital=10000, max_drawdown_limit=0.20)

current_balance = 8500  # ある時点での残高
can_trade = guard.update(current_balance)
dd = guard.get_current_drawdown(current_balance)

print(f"現在のドローダウン : {dd * 100:.1f}%")
print(f"トレード可否       : {'可' if can_trade else '停止中'}")