# 김종봉 주식 전략 퀀트 구현 상세 가이드

## 📌 전략 개요

### 출처
- **영상 1**: "이 방법만 알고 있으면 종잣돈 천만원으로 금방 1억 법니다" (GZw3wTgMTwE, 2023-08-09)
- **영상 2**: "이 방법만 알고 있다면 종잣돈 천만원으로 금방 1억 법니다" (Ps9tzVhHpu0, 2024-01-30)
- **채널**: 월급쟁이부자들TV
- **전략가**: 김종봉

### 핵심 철학
- **목표 수익률**: 월 10% (연 약 120%)
- **자금 증대 목표**: 1,000만원 → 1억원 (1년 내)
- **투자 기간**: 단기~중기 (보유 기간 수일~수주)
- **핵심 원칙**: "시장(코스피)을 이기는 종목"에만 투자

---

## 🎯 구체적 매매 규칙

### 1. 초기 자금 및 포트폴리오 구성

| 항목 | 기준 |
|------|------|
| **시드 머니** | 1,000만원 (초보자는 100만원 연습 추천) |
| **분산 종목 수** | 5~10개 |
| **종목당 투자금** | 100만원 (1,000만원 기준) 또는 5~10만원 (100만원 기준) |
| **현금 비중** | 약 30% (하락장 대비) |
| **리밸런싱 주기** | 3개월 (분기별 성과 검증) |

### 2. 종목 선정 기준 (필수 필터)

#### A. 유동성 필터
```
✅ 일 거래대금 >= 2,000억원 (2조 아님, 2천억)
```

**대상 종목 예시**:
- 삼성전자
- SK하이닉스
- LG전자
- LG이노텍
- 네이버
- 카카오
- LG에너지솔루션

#### B. 시가총액 필터
```
✅ 시가총액 순위: 1~30위 (대형주 중심)
```

#### C. 상대강도 필터 (핵심)
```
✅ 종목 수익률 > 코스피 수익률 (최근 2주~1개월)
✅ 특히 삼성전자 > 코스피 일 때 시장 강세 신호
```

**구현 방법**:
```python
# 상대강도 지수 (Relative Strength Index vs Market)
RS = (종목 수익률 / 코스피 수익률) * 100
# RS > 100이면 시장 대비 강함
```

#### D. 차트 패턴 필터
```
✅ 장대양봉 출현 (전일 대비 5% 이상 상승 + 거래량 폭증)
✅ 박스권 돌파 (직전 고점 갱신)
✅ 상승 추세 중 조정 후 지지선 터치
```

**장대양봉 정의**:
- 종가 >= 시가 + (고가 - 저가) × 0.7
- 거래대금 >= 직전 20일 평균 × 1.5

### 3. 진입 규칙

#### 시나리오 작성 (필수)
매매 전 반드시 기록:
```
1. 진입가: [예시] 삼성전자 72,000원
2. 목표가: [예시] 75,600원 (+5%)
3. 손절가: [예시] 69,840원 (-3%)
4. 근거: 코스피 지지선 반등 + 삼성전자 박스권 상단 돌파
```

#### 진입 타이밍
| 조건 | 설명 |
|------|------|
| **조건 1** | 코스피 3선(지지·저항·추세) 차트에서 지지선 근처 |
| **조건 2** | 박스권 상단 돌파 후 재진입 (돌파 확인 1~2일 후) |
| **조건 3** | 장대양봉 발생 다음날 시초가 근처 |
| **진입 방식** | 지정가 주문 (고점 근처에서 대기) |

### 4. 청산 규칙

#### A. 익절 (Profit Taking)
```
✅ 1차 익절: +5% 도달 시 50% 물량 청산
✅ 2차 익절: +10% 도달 시 나머지 50% 청산
✅ 목표: 주당 5% 수익 (주 1~2회 매매)
```

#### B. 손절 (Stop Loss)
```
❌ 손절 기준: -3% ~ -10%
❌ 원칙: 시나리오 이탈 시 즉시 손절
❌ 예시: 진입가 72,000원 → 손절가 69,840원 (-3%)
```

#### C. 트레일링 스톱
```
- 5% 이상 수익 발생 시 손절선을 진입가(본전)로 상향
- 10% 이상 수익 시 손절선을 +5% 지점으로 상향
```

### 5. 리스크 관리

| 항목 | 기준 |
|------|------|
| **종목당 최대 손실** | -3% (초기 자본의 0.3%) |
| **포트폴리오 최대 손실** | -10% (초기 자본 기준) |
| **승률 목표** | 60% 이상 |
| **손익비** | 1:1.5 이상 (손실 3% vs 수익 5%) |
| **월간 목표 수익률** | 10% |
| **연간 목표 수익률** | 120% (복리 고려 시 약 113%) |

---

## 🔧 퀀트 구현 상세

### 필요 데이터

#### 1. 시장 데이터
- **코스피 지수**: 일봉 OHLCV (최소 1년 이상)
- **삼성전자**: 일봉 OHLCV (선행지표로 활용)

#### 2. 종목 데이터
```python
필수 컬럼:
- 날짜 (Date)
- 시가 (Open)
- 고가 (High)
- 저가 (Low)
- 종가 (Close)
- 거래량 (Volume)
- 거래대금 (Value = Close × Volume)
- 시가총액 (Market Cap)
```

#### 3. 데이터 소스
- **한국거래소 API** (공식, 실시간)
- **FinanceDataReader** (무료, Python 라이브러리)
- **증권사 API** (키움, 이베스트 등, 실전 매매 시)
- **야후 파이낸스** (yfinance, 해외 주식 포함)

### 구현 단계

#### Phase 1: 데이터 수집 및 전처리
```python
import pandas as pd
import FinanceDataReader as fdr

# 1. 코스피 지수
kospi = fdr.DataReader('KS11', '2020-01-01')

# 2. 시가총액 상위 30개 종목
krx = fdr.StockListing('KRX')
top30 = krx.nlargest(30, 'Marcap')

# 3. 개별 종목 데이터
stocks = {}
for code in top30['Code']:
    stocks[code] = fdr.DataReader(code, '2020-01-01')
```

#### Phase 2: 필터링 로직
```python
def filter_liquidity(df, threshold=200_000_000_000):
    """거래대금 2000억 이상 필터"""
    df['Value'] = df['Close'] * df['Volume']
    return df[df['Value'] >= threshold]

def relative_strength(stock_return, market_return):
    """상대강도 계산"""
    return (stock_return / market_return) * 100

def detect_breakout(df, lookback=20):
    """박스권 돌파 감지"""
    df['Highest'] = df['High'].rolling(lookback).max()
    df['Breakout'] = df['Close'] > df['Highest'].shift(1)
    return df

def detect_large_candle(df, threshold=0.05):
    """장대양봉 감지 (5% 이상)"""
    df['Daily_Return'] = df['Close'].pct_change()
    df['Volume_Ratio'] = df['Volume'] / df['Volume'].rolling(20).mean()
    df['Large_Candle'] = (df['Daily_Return'] >= threshold) & (df['Volume_Ratio'] >= 1.5)
    return df
```

#### Phase 3: 신호 생성
```python
def generate_signals(stock_df, kospi_df):
    """매수/매도 신호 생성"""
    signals = pd.DataFrame(index=stock_df.index)
    
    # 상대강도
    stock_ret = stock_df['Close'].pct_change(10)  # 2주
    market_ret = kospi_df['Close'].pct_change(10)
    signals['RS'] = (stock_ret / market_ret) * 100
    
    # 매수 신호
    signals['Buy'] = (
        (signals['RS'] > 100) &  # 시장 대비 강함
        (stock_df['Breakout']) &  # 박스권 돌파
        (stock_df['Large_Candle'])  # 장대양봉
    )
    
    return signals
```

#### Phase 4: 백테스팅 엔진
```python
class KimJongBongStrategy:
    def __init__(self, initial_capital=10_000_000):
        self.capital = initial_capital
        self.cash = initial_capital * 0.7  # 30% 현금 보유
        self.positions = {}
        self.max_stocks = 10
        self.position_size = initial_capital / self.max_stocks
        
    def enter_position(self, code, price, date):
        """진입"""
        shares = int(self.position_size / price)
        cost = shares * price
        if cost <= self.cash:
            self.positions[code] = {
                'shares': shares,
                'entry_price': price,
                'entry_date': date,
                'stop_loss': price * 0.97,  # -3%
                'target': price * 1.05  # +5%
            }
            self.cash -= cost
            return True
        return False
    
    def exit_position(self, code, price, date, reason):
        """청산"""
        if code in self.positions:
            pos = self.positions[code]
            proceeds = pos['shares'] * price
            self.cash += proceeds
            profit = (price / pos['entry_price'] - 1) * 100
            del self.positions[code]
            return profit
        return 0
    
    def check_exits(self, date, prices):
        """익절/손절 체크"""
        for code in list(self.positions.keys()):
            pos = self.positions[code]
            current_price = prices[code]
            
            # 손절
            if current_price <= pos['stop_loss']:
                self.exit_position(code, current_price, date, 'stop_loss')
            
            # 익절
            elif current_price >= pos['target']:
                self.exit_position(code, current_price, date, 'take_profit')
```

#### Phase 5: 성과 평가
```python
def calculate_metrics(returns):
    """성과 지표"""
    total_return = (returns + 1).prod() - 1
    sharpe = returns.mean() / returns.std() * (252 ** 0.5)
    max_dd = (returns.cumsum() - returns.cumsum().cummax()).min()
    
    return {
        'Total Return': f"{total_return:.2%}",
        'Sharpe Ratio': f"{sharpe:.2f}",
        'Max Drawdown': f"{max_dd:.2%}",
        'Win Rate': f"{(returns > 0).sum() / len(returns):.2%}"
    }
```

---

## 📊 백테스팅 파라미터

### 권장 설정
| 파라미터 | 값 | 설명 |
|----------|-----|------|
| **백테스팅 기간** | 2020-01-01 ~ 2024-12-31 | 최소 3년 이상 |
| **초기 자본** | 10,000,000원 | 영상 기준 |
| **리밸런싱** | 분기별 (3개월) | 성과 검증 및 종목 교체 |
| **수수료** | 0.015% (매수) + 0.25% (매도, 세금 포함) | 실전 반영 |
| **슬리피지** | 0.1% | 체결가 불리함 |
| **벤치마크** | 코스피 지수 (KS11) | 비교 대상 |

### 최적화 대상
1. **상대강도 기간**: 10일 (2주) vs 20일 (1개월) vs 60일 (3개월)
2. **손절 비율**: -3% vs -5% vs -10%
3. **익절 비율**: +5% vs +7% vs +10%
4. **종목 수**: 5개 vs 10개 vs 15개
5. **현금 비중**: 20% vs 30% vs 50%

---

## 🚀 실전 적용 로드맵

### Step 1: 백테스팅 (1~2주)
- 과거 데이터로 전략 검증
- 연평균 수익률, 최대 낙폭, 승률 확인
- 벤치마크 대비 초과 수익 여부 평가

### Step 2: 페이퍼 트레이딩 (1개월)
- 실시간 데이터로 모의 투자
- 신호 발생 빈도 및 정확도 체크
- 감정 개입 없이 기계적 실행 연습

### Step 3: 소액 실전 (3개월)
- 100만원으로 시작
- 5~10개 종목, 종목당 10~20만원
- 매매 일지 기록 (진입/청산 근거, 수익률)

### Step 4: 본격 운용 (6개월 이후)
- 1,000만원 투입
- 분기별 성과 리뷰
- 전략 개선 (필터 추가, 파라미터 최적화)

---

## ⚠️ 주의사항

### 전략의 한계
1. **백테스팅 없음**: 영상은 실제 통계 검증 없이 경험 기반
2. **생존 편향**: 성공 사례 중심, 실패 사례 미공개
3. **시장 환경 의존**: 상승장에서 유리, 하락장에서 취약
4. **거래 비용**: 잦은 매매 시 수수료+세금 누적

### 리스크 관리 필수
- **과최적화 주의**: 과거 데이터에만 맞춘 전략은 미래 실패
- **레버리지 금지**: 신용/미수 사용 시 손실 확대
- **분산 투자**: 한 종목에 30% 이상 투자 금지
- **감정 통제**: 손절/익절 원칙 엄수

---

## 📦 필요 기술 스택

### Python 라이브러리
```bash
pip install pandas numpy yfinance FinanceDataReader
pip install backtrader vectorbt ta-lib
pip install matplotlib seaborn plotly
```

### 개발 환경
- **로컬**: Jupyter Notebook / VS Code
- **클라우드**: Google Colab (무료) / AWS SageMaker
- **데이터베이스**: SQLite (소규모) / PostgreSQL (대규모)

### 자동매매 연동 (선택)
- **증권사 API**: 키움증권 Open API, 이베스트투자증권 xingAPI
- **프레임워크**: PyQt5 (키움), gRPC (이베스트)

---

## 📚 참고 자료

### 추가 학습
1. **책**: "퀀트 투자 무작정 따라하기", "파이썬을 이용한 금융 데이터 분석"
2. **강의**: 패스트캠퍼스 퀀트 트레이딩, 인프런 주식 자동매매
3. **커뮤니티**: 네이버 카페 "시스템트레이딩", GitHub quant 저장소

### 관련 전략
- **모멘텀 전략**: 과거 수익률 상위 종목 매수
- **브레이크아웃**: 52주 신고가 돌파
- **평균회귀**: 과매도 구간 매수

---

## ✅ 체크리스트

### 구현 전 확인사항
- [ ] 데이터 소스 확보 (최소 3년 일봉)
- [ ] 백테스팅 환경 구축 (Python + 라이브러리)
- [ ] 초기 자본 및 목표 수익률 설정
- [ ] 리스크 허용 범위 결정 (최대 손실 -10%?)
- [ ] 매매 일지 양식 작성

### 실전 전 확인사항
- [ ] 백테스팅 결과 만족 (연 10% 이상, 샤프 1 이상)
- [ ] 페이퍼 트레이딩 1개월 이상
- [ ] 손절 원칙 테스트 (감정 개입 없이 실행 가능?)
- [ ] 증권사 계좌 개설 (API 사용 가능 여부 확인)
- [ ] 세금 및 수수료 계산 완료

---

## 🎯 최종 목표

| 기간 | 시드 | 목표 | 월 수익률 | 비고 |
|------|------|------|-----------|------|
| **0개월** | 1,000만원 | - | - | 시작 |
| **3개월** | 1,000만원 | 1,300만원 | 10% | 1분기 |
| **6개월** | 1,300만원 | 1,700만원 | 10% | 2분기 |
| **9개월** | 1,700만원 | 2,200만원 | 10% | 3분기 |
| **12개월** | 2,200만원 | **1억원** | 10% | 목표 달성 |

**복리 효과 시뮬레이션**:
```
월 10% × 12개월 = 약 213% (단리)
월 10% 복리 = (1.1)^12 - 1 = 약 213.8%
1,000만원 × 3.138 = 3,138만원 (현실적 목표)
```

---

## 💬 추가 문의사항

구현 과정에서 필요한 사항을 알려주시면:
1. **전체 Python 코드** (백테스팅 시스템)
2. **단계별 모듈** (데이터 수집 → 신호 생성 → 백테스팅)
3. **Jupyter Notebook** (인터랙티브 실습)
4. **자동매매 연동** (증권사 API 통합)

맞춤형으로 제공해 드리겠습니다.

---

**작성일**: 2026-02-19  
**버전**: 1.0  
**출처**: 김종봉 전략 유튜브 영상 (월급쟁이부자들TV)