파이썬 그리드 트레이딩 자동매매: 등간격

그리드 트레이딩이란? 자동매매의 핵심 전략

그리드 트레이딩(Grid Trading)은 일정 가격 간격으로 매수·매도 주문을 격자(Grid)처럼 배치하는 자동매매 전략입니다. 가격이 하락하면 자동으로 매수하고, 상승하면 자동으로 매도하여 횡보장에서 꾸준한 수익을 추구합니다. 추세 추종 전략이 횡보장에서 약한 반면, 그리드 트레이딩은 박스권 시장에서 가장 강력한 성과를 보여줍니다.

바이낸스, 업비트 등 주요 거래소에서 그리드 봇을 기본 제공할 만큼 검증된 전략이며, 파이썬으로 직접 구현하면 수수료 최적화, 그리드 간격 조정, 리스크 관리까지 세밀하게 제어할 수 있습니다.

그리드 트레이딩의 원리와 매매 규칙

그리드 트레이딩의 핵심 파라미터와 매매 규칙을 정리합니다.

• 가격 범위: 상한가(Upper)와 하한가(Lower) 설정
• 그리드 수(N): 범위를 N등분하여 격자 생성
• 그리드 간격 = (상한가 − 하한가) / N
• 매수 규칙: 가격이 그리드 라인 아래로 하락하면 해당 라인에서 매수
• 매도 규칙: 가격이 그리드 라인 위로 상승하면 해당 라인에서 매도
• 주문 크기: 총 투자금 / 그리드 수로 균등 배분

예를 들어 비트코인이 $90,000~$100,000 사이에서 횡보할 때, 10개 그리드를 설정하면 $1,000 간격으로 매수·매도 주문이 배치됩니다. 가격이 오르내릴 때마다 자동으로 저가 매수·고가 매도를 반복하며 수익을 축적합니다.

등간격 그리드 vs 등비 그리드

그리드 간격을 설정하는 두 가지 방식이 있으며, 각각의 특성을 이해하는 것이 중요합니다.

구분	등간격(Arithmetic)	등비(Geometric)
간격 계산	(상한-하한)/N	상한/하한의 N제곱근
낮은 가격대	간격 동일	간격 좁음 (더 많은 거래)
높은 가격대	간격 동일	간격 넓음
수익률 균등성	불균등 (저가에서 높음)	각 거래당 % 수익 동일
적합한 자산	가격 범위가 좁은 자산	변동폭이 큰 자산 (암호화폐)

파이썬으로 그리드 트레이딩 백테스팅 구현

먼저 필요한 라이브러리를 설치하고 데이터를 준비합니다.

pip install yfinance pandas numpy matplotlib

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 데이터 수집 (ETH-USD 예시)
ticker = "ETH-USD"
df = yf.download(ticker, start="2023-01-01", end="2025-12-31", interval="1d")
df = df[['Open', 'High', 'Low', 'Close', 'Volume']]
df.columns = ['open', 'high', 'low', 'close', 'volume']
print(f"데이터 기간: {df.index[0].date()} ~ {df.index[-1].date()}")
print(f"가격 범위: ${df['low'].min():.0f} ~ ${df['high'].max():.0f}")

등간격 그리드 전략 구현

class GridTrader:
    """등간격 그리드 트레이딩 백테스터"""

    def __init__(self, lower, upper, num_grids, investment):
        self.lower = lower
        self.upper = upper
        self.num_grids = num_grids
        self.investment = investment

        # 그리드 라인 생성
        self.grid_lines = np.linspace(lower, upper, num_grids + 1)
        self.grid_spacing = (upper - lower) / num_grids
        self.order_size = investment / num_grids

        # 상태 추적
        self.positions = {}  # {grid_level: qty}
        self.cash = investment
        self.trades = []
        self.portfolio_values = []

    def _find_grid_level(self, price):
        """현재 가격이 속한 그리드 레벨 반환"""
        if price <= self.lower:
            return 0
        if price >= self.upper:
            return self.num_grids
        return int((price - self.lower) / self.grid_spacing)

    def run(self, df):
        """백테스팅 실행"""
        prev_level = self._find_grid_level(df['close'].iloc[0])

        for i, row in df.iterrows():
            price = row['close']
            curr_level = self._find_grid_level(price)

            # 가격 하락 → 매수
            if curr_level < prev_level:
                for level in range(curr_level, prev_level):
                    grid_price = self.grid_lines[level]
                    if level not in self.positions and self.cash >= self.order_size:
                        qty = self.order_size / grid_price
                        self.positions[level] = {
                            'qty': qty, 'entry': grid_price
                        }
                        self.cash -= self.order_size
                        self.trades.append({
                            'date': i, 'action': 'BUY',
                            'price': grid_price, 'qty': qty,
                            'level': level
                        })

            # 가격 상승 → 매도
            elif curr_level > prev_level:
                for level in range(prev_level, curr_level):
                    if level in self.positions:
                        pos = self.positions[level]
                        sell_price = self.grid_lines[level + 1]
                        revenue = pos['qty'] * sell_price
                        profit = revenue - self.order_size
                        self.cash += revenue
                        self.trades.append({
                            'date': i, 'action': 'SELL',
                            'price': sell_price, 'qty': pos['qty'],
                            'level': level, 'profit': profit
                        })
                        del self.positions[level]

            # 포트폴리오 가치 기록
            holdings_value = sum(
                p['qty'] * price for p in self.positions.values()
            )
            self.portfolio_values.append({
                'date': i,
                'total': self.cash + holdings_value,
                'cash': self.cash,
                'holdings': holdings_value,
                'price': price
            })
            prev_level = curr_level

        return self

    def summary(self):
        """성과 요약"""
        pv = pd.DataFrame(self.portfolio_values)
        trades_df = pd.DataFrame(self.trades)
        sells = trades_df[trades_df['action'] == 'SELL']

        total_return = (pv['total'].iloc[-1] / self.investment - 1) * 100
        num_trades = len(trades_df)
        num_sells = len(sells)
        total_profit = sells['profit'].sum() if len(sells) > 0 else 0
        win_rate = (sells['profit'] > 0).mean() * 100 if len(sells) > 0 else 0

        print(f"=== 그리드 트레이딩 백테스트 결과 ===")
        print(f"투자금: ${self.investment:,.0f}")
        print(f"그리드 수: {self.num_grids}개")
        print(f"그리드 간격: ${self.grid_spacing:,.0f}")
        print(f"총 거래 횟수: {num_trades}회 (매도: {num_sells}회)")
        print(f"실현 수익: ${total_profit:,.2f}")
        print(f"승률: {win_rate:.1f}%")
        print(f"총 수익률: {total_return:.1f}%")
        print(f"최종 포트폴리오: ${pv['total'].iloc[-1]:,.0f}")

        return pv, trades_df


# 실행
grid = GridTrader(
    lower=1500, upper=4000,
    num_grids=25, investment=10000
)
grid.run(df)
pv, trades_df = grid.summary()

등비(Geometric) 그리드 구현

등비 그리드는 각 거래에서 동일한 비율의 수익을 추구하므로, 변동성이 큰 암호화폐에 더 적합합니다.

class GeometricGridTrader(GridTrader):
    """등비 그리드 트레이딩 백테스터"""

    def __init__(self, lower, upper, num_grids, investment):
        self.lower = lower
        self.upper = upper
        self.num_grids = num_grids
        self.investment = investment

        # 등비 그리드 라인: 각 간격의 비율이 동일
        ratio = (upper / lower) ** (1 / num_grids)
        self.grid_lines = np.array([
            lower * (ratio ** i) for i in range(num_grids + 1)
        ])
        self.grid_ratio = ratio
        self.order_size = investment / num_grids

        self.positions = {}
        self.cash = investment
        self.trades = []
        self.portfolio_values = []

    def _find_grid_level(self, price):
        """등비 기준 그리드 레벨"""
        if price <= self.lower:
            return 0
        if price >= self.upper:
            return self.num_grids
        return int(np.log(price / self.lower) / np.log(self.grid_ratio))


# 등비 그리드 실행
geo_grid = GeometricGridTrader(
    lower=1500, upper=4000,
    num_grids=25, investment=10000
)
geo_grid.run(df)
geo_pv, geo_trades = geo_grid.summary()

그리드 파라미터 최적화

그리드 수와 가격 범위에 따라 성과가 크게 달라집니다. 최적 파라미터 조합을 탐색하는 코드입니다.

def optimize_grid(df, lower_range, upper_range, grid_range):
    """그리드 파라미터 최적화"""
    results = []

    for n_grids in grid_range:
        for lower in lower_range:
            for upper in upper_range:
                if upper <= lower:
                    continue
                try:
                    grid = GridTrader(lower, upper, n_grids, 10000)
                    grid.run(df)
                    pv = pd.DataFrame(grid.portfolio_values)

                    total_ret = (pv['total'].iloc[-1] / 10000 - 1) * 100
                    # MDD 계산
                    peak = pv['total'].cummax()
                    mdd = ((pv['total'] - peak) / peak).min() * 100

                    sells = pd.DataFrame(grid.trades)
                    sells = sells[sells['action'] == 'SELL'] if len(sells) > 0 else pd.DataFrame()
                    num_sells = len(sells)

                    results.append({
                        'grids': n_grids,
                        'lower': lower,
                        'upper': upper,
                        'return': round(total_ret, 1),
                        'mdd': round(mdd, 1),
                        'trades': num_sells
                    })
                except Exception:
                    continue

    results_df = pd.DataFrame(results)
    return results_df.sort_values('return', ascending=False).head(10)


# 최적화 실행
best = optimize_grid(
    df,
    lower_range=[1000, 1500, 2000],
    upper_range=[3500, 4000, 4500],
    grid_range=[15, 20, 25, 30, 40]
)
print(best.to_string(index=False))

리스크 관리: 손절·이격도·자금 관리

그리드 트레이딩의 가장 큰 리스크는 가격이 그리드 범위를 이탈하는 것입니다. 하방 이탈 시 미실현 손실이 누적되고, 상방 이탈 시 기회비용이 발생합니다.

1. 범위 이탈 손절

def add_stoploss(grid_trader, df, stop_pct=0.10):
    """
    그리드 하한 대비 stop_pct만큼 추가 하락 시 전량 손절
    """
    stop_price = grid_trader.lower * (1 - stop_pct)
    stopped = False

    for i, row in df.iterrows():
        if row['low'] <= stop_price and grid_trader.positions:
            # 전량 청산
            total_loss = 0
            for level, pos in grid_trader.positions.items():
                loss = pos['qty'] * stop_price - grid_trader.order_size
                total_loss += loss
                grid_trader.cash += pos['qty'] * stop_price
            grid_trader.positions.clear()
            stopped = True
            print(f"⚠️ 손절 발동! 가격: ${stop_price:.0f}, 손실: ${total_loss:.0f}")
            break

    return stopped

2. 동적 그리드 재설정

def dynamic_grid_reset(df, lookback=30, num_grids=20, investment=10000):
    """
    N일마다 최근 가격 범위 기반으로 그리드를 재설정
    - 시장 변화에 적응하는 동적 그리드
    """
    all_values = []
    current_cash = investment

    for start in range(0, len(df) - lookback, lookback):
        window = df.iloc[start:start + lookback]
        recent = df.iloc[max(0, start-lookback):start + lookback]

        # 최근 데이터 기반 범위 설정 (±10% 버퍼)
        lower = recent['low'].min() * 0.95
        upper = recent['high'].max() * 1.05

        grid = GridTrader(lower, upper, num_grids, current_cash)
        grid.run(window)

        pv = pd.DataFrame(grid.portfolio_values)
        if len(pv) > 0:
            current_cash = pv['total'].iloc[-1]
            all_values.extend(grid.portfolio_values)

    return pd.DataFrame(all_values)

성과 시각화: 수익 곡선과 거래 분포

# 그리드 전략 수익 곡선 시각화
pv = pd.DataFrame(grid.portfolio_values)

fig, axes = plt.subplots(2, 2, figsize=(16, 10))

# 1. 포트폴리오 가치 추이
axes[0][0].plot(pv['date'], pv['total'], label='Grid Strategy', linewidth=2)
axes[0][0].axhline(y=10000, color='gray', linestyle='--', label='Initial')
axes[0][0].set_title('Portfolio Value Over Time')
axes[0][0].legend()
axes[0][0].grid(True, alpha=0.3)

# 2. 가격과 그리드 라인
axes[0][1].plot(pv['date'], pv['price'], color='black', linewidth=1)
for gl in grid.grid_lines:
    axes[0][1].axhline(y=gl, color='lightblue', linewidth=0.5, alpha=0.7)
axes[0][1].set_title('Price with Grid Lines')
axes[0][1].grid(True, alpha=0.3)

# 3. 현금 vs 보유 자산 비율
axes[1][0].stackplot(pv['date'], pv['cash'], pv['holdings'],
                     labels=['Cash', 'Holdings'], alpha=0.7)
axes[1][0].set_title('Cash vs Holdings')
axes[1][0].legend()

# 4. 거래별 수익 분포
sells = trades_df[trades_df['action'] == 'SELL']
if len(sells) > 0:
    axes[1][1].hist(sells['profit'], bins=30, color='steelblue', edgecolor='white')
    axes[1][1].axvline(x=0, color='red', linestyle='--')
    axes[1][1].set_title('Profit Distribution per Trade')

plt.tight_layout()
plt.savefig('grid_trading_analysis.png', dpi=150)
plt.show()

그리드 트레이딩 vs 다른 자동매매 전략 비교

전략	최적 시장	장점	단점
그리드 트레이딩	횡보장	꾸준한 소액 수익	강한 추세에서 손실
변동성 돌파	추세장	큰 움직임 포착	횡보장 잦은 손절
페어 트레이딩	모든 시장	시장 중립	페어 관계 붕괴 리스크
RSI 역추세	횡보~약추세	과매도 반등 포착	강한 하락장 손실

실전 적용 시 핵심 고려사항

• 수수료 영향: 그리드 트레이딩은 거래 빈도가 높아 수수료가 수익을 크게 잠식할 수 있습니다. 메이커 수수료가 0.1% 이하인 거래소를 선택하세요.
• 그리드 간격 vs 수수료: 그리드 간격이 수수료의 최소 3배 이상이어야 수익을 확보할 수 있습니다. 간격이 1%면 왕복 수수료 0.2% 기준 순수익은 0.8%입니다.
• 자본 효율성: 그리드 범위가 넓을수록 많은 자본이 유휴 상태로 대기합니다. 범위를 좁히면 효율성은 높아지지만 이탈 리스크가 커집니다.
• API 안정성: 거래소 API 장애 시 주문이 누락될 수 있으므로, 주문 상태를 주기적으로 확인하고 복구 로직을 구현하세요.
• 세금: 잦은 거래는 과세 이벤트를 다량 생성합니다. 거래 기록을 자동 저장하여 세무 처리에 대비하세요.

자주 묻는 질문 (FAQ)

그리드 트레이딩은 무조건 수익이 나나요?

아닙니다. 가격이 그리드 하한 아래로 지속 하락하면 미실현 손실이 누적됩니다. 횡보장에서는 강하지만 일방향 추세장에서는 손실이 발생할 수 있어 반드시 손절 라인을 설정해야 합니다.

그리드 수는 몇 개가 적당한가요?

일반적으로 15~30개가 적당합니다. 너무 적으면 거래 기회가 줄고, 너무 많으면 거래당 수익이 수수료에 잠식됩니다. 자산의 일일 변동폭 대비 그리드 간격이 최소 0.5% 이상이 되도록 설정하세요.

어떤 자산에 그리드 트레이딩이 적합한가요?

일정 범위에서 등락을 반복하는 자산이 가장 적합합니다. ETH, BTC 같은 암호화폐, SPY·QQQ 같은 대형 ETF, 또는 환율(EUR/USD)이 대표적입니다. 한 방향으로만 움직이는 성장주나 하락 추세의 자산은 피해야 합니다.

결론: 그리드 트레이딩 실전 로드맵

그리드 트레이딩은 횡보장에서 꾸준한 수익을 창출하는 자동매매 전략의 대표 주자입니다. 본 가이드에서 다룬 내용을 단계별로 적용해 보세요.

1. 기본 구현 → 등간격 그리드로 백테스팅하여 전략 이해
2. 등비 그리드 → 변동성 높은 자산에 등비 그리드 적용
3. 파라미터 최적화 → 그리드 수와 범위를 자산 특성에 맞게 조정
4. 리스크 관리 → 손절매와 동적 재설정으로 하방 리스크 방어
5. 실전 배포 → API 연동과 모니터링 시스템 구축

그리드 트레이딩을 마스터했다면, 변동성 돌파 전략과 결합하여 추세장에서는 돌파 전략, 횡보장에서는 그리드 전략을 자동 전환하는 복합 시스템을 구축해 보세요. 또한 페어 트레이딩의 시장 중립 특성과 조합하면 더욱 안정적인 포트폴리오를 만들 수 있습니다.