자동매매 포트폴리오 분산: 100만원을 5개로 나누는 이유

"비트코인만 거래하면 안 되나요?"

3년 전 제 질문이었습니다.

**결과**: 비트코인 -30% 하락 시 전체 손실 -30%

**지금**: 5개 코인 분산 → 안정적 수익

이 글에서는 포트폴리오 분산 전략을 알려드립니다.

분산 투자의 원리

계란을 한 바구니에 담지 마라

**분산 전 **:
``
전액 BTC: 100만원
BTC -20% 하락
손실: -20만원 (-20%)
`

**분산 후**:
`
BTC 40만원: -20% = -8만원
ETH 30만원: +10% = +3만원
리플 20만원: -5% = -1만원
현금 10만원: 0%

총 손실: -6만원 (-6%)
`

**손실이 1/3로 줄었습니다!**

상관관계

**높은 상관관계** (함께 움직임):
- BTC ↔ ETH: 0.8
- BTC ↔ 알트코인: 0.7

**낮은 상관관계**:
- BTC ↔ 현금: 0
- BTC ↔ 금: -0.2

**목표**: 상관관계 낮은 자산 조합

기본 포트폴리오: 5개 분산

구성

| 자산 | 비율 | 금액 (100만원) | 특징 |
|------|------|----------------|------|
| BTC | 40% | 40만원 | 안정성, 대장주 |
| ETH | 30% | 30만원 | 성장성 |
| 알트1 | 15% | 15만원 | 고수익 |
| 알트2 | 10% | 10만원 | 고수익 |
| 현금 | 5% | 5만원 | 비상금 |

Python 코드

`python
import pyupbit

class Portfolio:
def __init__(self, total_balance):
self.total_balance = total_balance
self.allocation = {
'BTC': 0.40,
'ETH': 0.30,
'XRP': 0.15,
'DOGE': 0.10,
'CASH': 0.05
}

def get_allocation(self):
"""각 자산별 배분 금액"""
result = {}
for asset, ratio in self.allocation.items():
result[asset] = self.total_balance * ratio

return result

def rebalance(self, upbit):
"""리밸런싱 실행"""
target = self.get_allocation()

# 현재 보유량
current = {
'BTC': upbit.get_balance('BTC') * pyupbit.get_current_price('KRW-BTC'),
'ETH': upbit.get_balance('ETH') * pyupbit.get_current_price('KRW-ETH'),
'XRP': upbit.get_balance('XRP') * pyupbit.get_current_price('KRW-XRP'),
'DOGE': upbit.get_balance('DOGE') * pyupbit.get_current_price('KRW-DOGE'),
'CASH': upbit.get_balance('KRW')
}

# 차이 계산 및 조정
for asset, target_amount in target.items():
if asset == 'CASH':
continue

current_amount = current[asset]
diff = target_amount - current_amount

symbol = f'KRW-{asset}'

if diff > 10000: # 1만원 이상 차이
# 매수
upbit.buy_market_order(symbol, abs(diff))
print(f"{asset} 매수: {diff:,.0f}원")

elif diff < -10000:
# 매도
price = pyupbit.get_current_price(symbol)
amount = abs(diff) / price
upbit.sell_market_order(symbol, amount)
print(f"{asset} 매도: {diff:,.0f}원")

사용 예

portfolio = Portfolio(1000000)
allocation = portfolio.get_allocation()

for asset, amount in allocation.items():
print(f"{asset}: {amount:,.0f}원")
`

전략별 포트폴리오

보수적 (안정 우선)

| 자산 | 비율 | 특징 |
|------|------|------|
| BTC | 60% | 안정적 대장주 |
| ETH | 25% | 2위 코인 |
| 스테이블 | 10% | USDT, USDC |
| 현금 | 5% | 비상금 |

**기대 수익**: 월 3~5%
**리스크**: 낮음

`python
conservative_portfolio = {
'BTC': 0.60,
'ETH': 0.25,
'USDT': 0.10,
'CASH': 0.05
}
`

균형적 (중도)

| 자산 | 비율 | 특징 |
|------|------|------|
| BTC | 40% | 대장주 |
| ETH | 30% | 성장성 |
| 알트코인 | 25% | 고수익 |
| 현금 | 5% | 비상금 |

**기대 수익**: 월 5~10%
**리스크**: 보통

`python
balanced_portfolio = {
'BTC': 0.40,
'ETH': 0.30,
'XRP': 0.15,
'DOGE': 0.10,
'CASH': 0.05
}
`

공격적 (수익 우선)

| 자산 | 비율 | 특징 |
|------|------|------|
| BTC | 30% | 기본 |
| ETH | 20% | 보조 |
| 알트코인 | 45% | 고수익 |
| 현금 | 5% | 비상금 |

**기대 수익**: 월 10~20%
**리스크**: 높음

`python
aggressive_portfolio = {
'BTC': 0.30,
'ETH': 0.20,
'XRP': 0.15,
'DOGE': 0.15,
'SOL': 0.15,
'CASH': 0.05
}
`

리밸런싱 전략

1. 정기 리밸런싱

**매월 1일 실행**

`python
import schedule
from datetime import datetime

def monthly_rebalance():
"""매월 1일 리밸런싱"""
today = datetime.now()

if today.day == 1:
print(f"=== {today.date()} 리밸런싱 ===")

portfolio = Portfolio(get_total_balance())
portfolio.rebalance(upbit)

print("리밸런싱 완료!")

매일 체크 (1일이면 실행)

schedule.every().day.at("09:00").do(monthly_rebalance)

while True:
schedule.run_pending()
time.sleep(3600) # 1시간마다 확인
`

2. 비율 이탈 시 리밸런싱

**±5% 이탈 시 조정**

`python
def check_rebalance_needed(portfolio, current_holdings, threshold=0.05):
"""리밸런싱 필요 여부 확인"""
target = portfolio.get_allocation()
total = sum(current_holdings.values())

for asset, target_ratio in portfolio.allocation.items():
if asset == 'CASH':
continue

current_amount = current_holdings.get(asset, 0)
current_ratio = current_amount / total

diff = abs(current_ratio - target_ratio)

if diff > threshold:
print(f"⚠️ {asset} 이탈: {diff*100:.1f}% (목표 {target_ratio*100}% vs 현재 {current_ratio*100:.1f}%)")
return True

return False

매일 체크

if check_rebalance_needed(portfolio, current_holdings):
portfolio.rebalance(upbit)
`

자동매매 적용

포트폴리오별 전략

`python
class PortfolioTrader:
def __init__(self, upbit, portfolio):
self.upbit = upbit
self.portfolio = portfolio

def trade_asset(self, symbol, strategy):
"""개별 자산 거래"""
# 현재 가격
price = pyupbit.get_current_price(f'KRW-{symbol}')

# 보유량
balance = self.upbit.get_balance(symbol)

# 전략 실행
action = strategy.decide(price, balance)

if action == 'BUY':
# 할당된 금액 범위 내에서 매수
allocation = self.portfolio.get_allocation()[symbol]
self.upbit.buy_market_order(f'KRW-{symbol}', allocation * 0.1)

elif action == 'SELL':
# 전량 매도
self.upbit.sell_market_order(f'KRW-{symbol}', balance * 0.9995)

사용 예

trader = PortfolioTrader(upbit, portfolio)

각 자산에 대해 전략 실행

for asset in ['BTC', 'ETH', 'XRP']:
trader.trade_asset(asset, strategy)
`

실전 통합 시스템

`python
import time
from datetime import datetime

class AutoTradingSystem:
def __init__(self, upbit, initial_balance):
self.upbit = upbit
self.portfolio = Portfolio(initial_balance)
self.strategies = {
'BTC': TrendFollowingStrategy(), # 추세 추종
'ETH': MeanReversionStrategy(), # 평균 회귀
'XRP': BreakoutStrategy() # 돌파 전략
}

def run(self):
"""메인 루프"""
print("🤖 자동매매 시스템 시작!")

while True:
try:
# 1. 각 자산 거래
for asset, strategy in self.strategies.items():
symbol = f'KRW-{asset}'
price = pyupbit.get_current_price(symbol)

action = strategy.decide(price)

if action == 'BUY':
allocation = self.portfolio.allocation[asset]
amount = self.portfolio.total_balance * allocation * 0.1

if amount > 5000: # 5천원 이상
self.upbit.buy_market_order(symbol, amount)
print(f"✅ {asset} 매수: {amount:,.0f}원")

elif action == 'SELL':
balance = self.upbit.get_balance(asset)
if balance > 0.00001:
self.upbit.sell_market_order(symbol, balance * 0.9995)
print(f"✅ {asset} 매도")

# 2. 리밸런싱 체크 (매월 1일)
if datetime.now().day == 1 and datetime.now().hour == 9:
self.portfolio.rebalance(self.upbit)

# 3. 10분 대기
time.sleep(600)

except Exception as e:
print(f"❌ 에러: {e}")
time.sleep(60)

실행

system = AutoTradingSystem(upbit, 1000000)
system.run()
`

성과 비교 (3개월)

단일 자산 vs 분산

**BTC만** (100만원):
`
1월: +15% (115만원)
2월: -20% (92만원)
3월: +10% (101만원)
---
최종: +1% (101만원)
최대 낙폭: -20%
`

**5개 분산** (100만원):
`
1월: +12% (112만원)
2월: -8% (103만원)
3월: +7% (110만원)
---
최종: +10% (110만원)
최대 낙폭: -8%
``

**분산 투자가 더 안정적이고 수익도 높습니다!**

주의사항

1. 과도한 분산 금지

**나쁜 예** ❌:
- 20개 코인에 분산
- 관리 어려움
- 수수료 증가

**좋은 예** ✅:
- 3~5개 코인
- 집중 관리
- 효율적 운영

2. 상관관계 확인

**비효율적 분산**:
- BTC 40%, BCH 30%, BSV 30%
- 비슷한 코인들 (상관관계 높음)

**효율적 분산**:
- BTC 40%, ETH 30%, XRP 30%
- 다른 특성 코인 (상관관계 낮음)

3. 현금 비율 유지

**필수**:
- 최소 5% 현금 보유
- 기회 포착용
- 비상 대응

추천 학습 자료

포트폴리오 분산을 포함한 완전한 자동매매 시스템을 배우고 싶다면:

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

**포함 내용**:
- ✅ 포트폴리오 구성 전략
- ✅ 자동 리밸런싱 시스템
- ✅ 다중 코인 거래 봇
- ✅ 리스크 관리 도구

**안정적인 수익을 위한 필수 강의!**

---

결론: 분산은 보험

핵심 정리

1. **3~5개 코인 분산** - 적정 개수
2. **정기 리밸런싱** - 매월 1일
3. **현금 5% 유지** - 비상금
4. **상관관계 확인** - 다른 특성 코인
5. **지속 모니터링** - 성과 추적

마지막 조언

"높은 수익 = 높은 리스크" ❌

"분산으로 리스크 줄이고 안정적 수익" ✅

**포트폴리오 분산으로 안전하게 자동매매하세요!**

---

**면책 조언**: 분산 투자도 손실 가능성이 있습니다. 자신의 리스크 허용도에 맞게 구성하세요.