자동매매 리스크 관리: 100만원을 지키는 5가지 철칙

"수익보다 손실 관리가 먼저다"

자동매매를 3년 하면서 배운 가장 중요한 교훈입니다.

**월 +10% 수익 → 하루 -30% 손실 = 최종 -20%**

이 글에서는 자산을 지키는 리스크 관리 전략을 알려드립니다.

리스크 관리가 중요한 이유

수익 vs 손실의 비대칭성

| 손실 | 복구에 필요한 수익 |
|------|---------------------|
| -10% | +11.1% |
| -20% | +25% |
| -30% | +42.9% |
| -50% | **+100%** |
| -80% | **+400%** |

**-50% 손실을 복구하려면 +100% 수익이 필요합니다!**

그래서 손실 관리가 더 중요합니다.

실제 사례

**A씨** (리스크 관리 없음):
``
1월: +15% (115만원)
2월: +20% (138만원)
3월: -40% (83만원) ← 한 번의 큰 손실
---
최종: -17% (83만원)
`

**B씨** (리스크 관리 있음):
`
1월: +8% (108만원)
2월: +10% (119만원)
3월: -5% (113만원) ← 손절로 손실 제한
---
최종: +13% (113만원)
`

**리스크 관리가 승패를 가릅니다!**

철칙 1: 포지션 크기 제한

1% 규칙

**한 번의 거래에서 전체 자산의 1%만 리스크**

`python
TOTAL_BALANCE = 1000000 # 총 자산 100만원
RISK_PER_TRADE = 0.01 # 1%
STOP_LOSS = 0.025 # -2.5% 손절

포지션 크기 계산

max_loss_amount = TOTAL_BALANCE * RISK_PER_TRADE # 1만원
position_size = max_loss_amount / STOP_LOSS # 40만원

print(f"최대 포지션 크기: {position_size:,.0f}원")
print(f"최대 손실 금액: {max_loss_amount:,.0f}원")
`

왜 1%인가?

**연속 손실 시**:
- 10번 연속 손실: -9.6% (90.4만원 남음)
- 20번 연속 손실: -18.2% (81.8만원 남음)

**여전히 자산의 81%가 남아있습니다!**

실전 적용

`python
def calculate_position_size(balance, risk_percent, stop_loss_percent):
"""
적정 포지션 크기 계산

Args:
balance: 총 자산
risk_percent: 리스크 비율 (예: 0.01 = 1%)
stop_loss_percent: 손절 비율 (예: 0.025 = 2.5%)

Returns:
포지션 크기
"""
max_loss = balance * risk_percent
position_size = max_loss / stop_loss_percent

return min(position_size, balance * 0.3) # 최대 30% 제한

사용 예

balance = 1000000
position = calculate_position_size(
balance=balance,
risk_percent=0.01, # 1% 리스크
stop_loss_percent=0.025 # 2.5% 손절
)

print(f"적정 포지션: {position:,.0f}원") # 40만원
`

철칙 2: 손절선 고수

절대 손절선

**절대 이동하지 않는 손절선 설정**

`python
STOP_LOSS = -0.025 # -2.5% 고정

def check_stop_loss(buy_price, current_price):
profit_rate = (current_price - buy_price) / buy_price

if profit_rate <= STOP_LOSS:
print("손절 실행! (고정 -2.5%)")
sell_all()
return True

return False
`

트레일링 스톱

**수익이 나면 손절선을 올립니다**

`python
def trailing_stop(buy_price, current_price, highest_price):
profit_rate = (current_price - buy_price) / buy_price

# 수익 5% 이상이면 트레일링 시작
if profit_rate >= 0.05:
# 최고가 대비 -3% 하락 시 손절
trailing_loss = (current_price - highest_price) / highest_price

if trailing_loss <= -0.03:
print(f"트레일링 스톱! 수익 {profit_rate*100:.2f}% 확정")
sell_all()
return True

# 아직 수익 5% 미만이면 기본 손절
elif profit_rate <= -0.025:
print("기본 손절!")
sell_all()
return True

return False
`

시간 손절

**일정 기간 동안 수익이 없으면 매도**

`python
import time

MAX_HOLD_TIME = 86400 * 3 # 3일 (초 단위)

def time_based_stop(buy_time, current_time, profit_rate):
hold_time = current_time - buy_time

# 3일 지났는데 수익 2% 미만이면 매도
if hold_time >= MAX_HOLD_TIME and profit_rate < 0.02:
print(f"시간 손절! {hold_time/86400:.1f}일 보유, 수익 {profit_rate*100:.2f}%")
sell_all()
return True

return False
`

철칙 3: 분산 투자

자산 배분

**100만원을 한 곳에 몰빵 금지!**

`python
TOTAL_BALANCE = 1000000

자산 배분

allocation = {
'BTC': 0.4, # 40% (40만원)
'ETH': 0.3, # 30% (30만원)
'altcoins': 0.2, # 20% (20만원)
'cash': 0.1 # 10% (10만원, 비상금)
}

for asset, ratio in allocation.items():
amount = TOTAL_BALANCE * ratio
print(f"{asset}: {amount:,.0f}원 ({ratio*100}%)")
`

시간 분산 (DCA: Dollar Cost Averaging)

**한 번에 다 사지 말고 나눠서 매수**

`python
def dollar_cost_averaging(total_amount, num_buys, interval_hours):
"""
분할 매수

Args:
total_amount: 총 투자금
num_buys: 매수 횟수
interval_hours: 매수 간격 (시간)
"""
amount_per_buy = total_amount / num_buys

for i in range(num_buys):
current_price = get_bitcoin_price()
btc_amount = amount_per_buy / current_price

buy(btc_amount)
print(f"{i+1}차 매수: {current_price:,.0f}원, {btc_amount:.6f} BTC")

if i < num_buys - 1:
time.sleep(interval_hours * 3600)

100만원을 4번에 걸쳐 6시간 간격으로 매수

dollar_cost_averaging(1000000, 4, 6)
`

철칙 4: 레버리지 제한

안전한 레버리지

| 경험 수준 | 권장 레버리지 | 최대 손실 |
|-----------|---------------|-----------|
| 초보 (0~3개월) | 1~3배 | -33% |
| 중급 (3~12개월) | 5~10배 | -10% |
| 고급 (12개월+) | 10~15배 | -6.7% |

**절대 금지**: 레버리지 20배 이상 ❌

레버리지별 위험도

`python
def calculate_liquidation_price(entry_price, leverage):
"""
청산 가격 계산

Args:
entry_price: 진입 가격
leverage: 레버리지 배수

Returns:
청산 가격
"""
# 롱 포지션 청산가
liquidation_price = entry_price * (1 - 1/leverage)
return liquidation_price

예시

entry_price = 50000000
leverages = [5, 10, 20, 50, 100]

for lev in leverages:
liq_price = calculate_liquidation_price(entry_price, lev)
loss_percent = (entry_price - liq_price) / entry_price * 100

print(f"레버리지 {lev:3d}배: 청산가 {liq_price:,.0f}원 ({loss_percent:.1f}% 하락)")

출력:

레버리지 5배: 청산가 40,000,000원 (20.0% 하락)

레버리지 10배: 청산가 45,000,000원 (10.0% 하락)

레버리지 20배: 청산가 47,500,000원 (5.0% 하락)

레버리지 50배: 청산가 49,000,000원 (2.0% 하락)

레버리지 100배: 청산가 49,500,000원 (1.0% 하락)

`

철칙 5: 일일 손실 한도

데일리 스톱

**하루 손실이 일정 금액을 넘으면 당일 거래 중단**

`python
DAILY_LOSS_LIMIT = -0.03 # -3%

class DailyLossTracker:
def __init__(self, initial_balance):
self.start_balance = initial_balance
self.current_balance = initial_balance
self.trading_enabled = True

def update_balance(self, new_balance):
self.current_balance = new_balance

# 손실률 계산
loss_rate = (new_balance - self.start_balance) / self.start_balance

if loss_rate <= DAILY_LOSS_LIMIT:
self.trading_enabled = False
print(f"⚠️ 일일 손실 한도 도달! ({loss_rate*100:.2f}%)")
print("오늘 거래 중단. 내일 다시 시작합니다.")

def can_trade(self):
return self.trading_enabled

def reset_daily(self):
"""매일 자정에 실행"""
self.start_balance = self.current_balance
self.trading_enabled = True
print("새로운 거래일 시작!")

사용 예

tracker = DailyLossTracker(1000000)

거래 전 확인

if tracker.can_trade():
execute_trade()
tracker.update_balance(get_current_balance())
else:
print("오늘은 거래 불가")
`

실전 리스크 관리 시스템

통합 코드

`python
import time
from datetime import datetime

class RiskManager:
def __init__(self, balance):
self.balance = balance
self.daily_start_balance = balance
self.risk_per_trade = 0.01 # 1%
self.stop_loss_percent = 0.025 # 2.5%
self.daily_loss_limit = -0.03 # -3%
self.max_leverage = 10

def calculate_position_size(self):
"""적정 포지션 크기"""
max_loss = self.balance * self.risk_per_trade
position = max_loss / self.stop_loss_percent
return min(position, self.balance * 0.3)

def check_daily_limit(self):
"""일일 손실 한도 확인"""
loss_rate = (self.balance - self.daily_start_balance) / self.daily_start_balance
return loss_rate > self.daily_loss_limit

def check_stop_loss(self, buy_price, current_price):
"""손절 확인"""
loss_rate = (current_price - buy_price) / buy_price
return loss_rate <= -self.stop_loss_percent

def validate_trade(self, leverage):
"""거래 가능 여부 검증"""
# 일일 손실 한도 확인
if not self.check_daily_limit():
print("❌ 일일 손실 한도 도달!")
return False

# 레버리지 확인
if leverage > self.max_leverage:
print(f"❌ 레버리지 {leverage}배는 허용되지 않습니다 (최대 {self.max_leverage}배)")
return False

return True

def update_balance(self, new_balance):
"""잔고 업데이트"""
old_balance = self.balance
self.balance = new_balance

profit = new_balance - old_balance
profit_rate = profit / old_balance * 100

print(f"잔고 변화: {old_balance:,.0f}원 → {new_balance:,.0f}원 ({profit_rate:+.2f}%)")

def reset_daily(self):
"""매일 리셋"""
self.daily_start_balance = self.balance
print(f"\n=== {datetime.now().date()} 거래 시작 ===")
print(f"시작 잔고: {self.balance:,.0f}원")

사용 예

rm = RiskManager(1000000)

거래 전 검증

if rm.validate_trade(leverage=10):
position_size = rm.calculate_position_size()
print(f"적정 포지션: {position_size:,.0f}원")

# 거래 실행
buy_price = 50000000
execute_trade(position_size)

# 손절 모니터링
while True:
current_price = get_current_price()

if rm.check_stop_loss(buy_price, current_price):
print("손절 실행!")
break

time.sleep(10)
``

리스크 관리 체크리스트

거래 전

- [ ] 포지션 크기가 자산의 30% 이하인가?
- [ ] 1% 리스크 규칙을 지키는가?
- [ ] 손절선이 설정되어 있는가?
- [ ] 일일 손실 한도 내인가?
- [ ] 레버리지가 10배 이하인가?

거래 중

- [ ] 실시간 모니터링 가능한가?
- [ ] 손절선을 이동하지 않았는가?
- [ ] 감정적 판단을 배제하고 있는가?

거래 후

- [ ] 거래 일지를 작성했는가?
- [ ] 손익을 분석했는가?
- [ ] 다음 거래 계획을 세웠는가?

추천 학습 자료

리스크 관리를 체계적으로 배우고 싶다면:

파이썬 비트코인 자동매매 봇 강의

**포함 내용**:
- ✅ 리스크 관리 시스템 구현
- ✅ 손절/익절 자동화
- ✅ 포지션 크기 계산
- ✅ 일일 손실 한도 설정

**검증된 리스크 관리로 안전하게 시작하세요.**

---

결론: 지키는 자가 승리한다

핵심 정리

1. **포지션 크기 제한** - 1% 리스크 규칙
2. **손절선 고수** - 절대 이동 금지
3. **분산 투자** - 계란을 한 바구니에 담지 말기
4. **레버리지 제한** - 10배 이하
5. **일일 손실 한도** - -3% 초과 시 중단

마지막 조언

"공격이 최선의 방어다" ❌

"방어가 최선의 공격이다" ✅

**자산을 지키는 자가 결국 승리합니다.**

---

**면책 조항**: 리스크 관리는 손실을 완전히 방지하지 못합니다. 모든 투자는 본인의 책임입니다.