ETF 포트폴리오 리밸런싱 전략 완벽 가이드 — 개발자를 위한 자산 배분과 자동화

# 초기 포트폴리오 (목표 비중)
portfolio = {
    "국내주식(KODEX 200)": 0.30,    # 30%
    "미국주식(VOO)": 0.40,           # 40%
    "채권(TLT)": 0.20,               # 20%
    "금(GLD)": 0.10                   # 10%
}

# 1년 후 (주식 상승, 채권 하락 시)
# 국내주식: 30% -> 28% (-2%)
# 미국주식: 40% -> 48% (+8%)  ← 목표 초과!
# 채권:     20% -> 16% (-4%)  ← 목표 미달!
# 금:       10% -> 8%  (-2%)

# 리밸런싱 없이 방치하면:
# - 주식 비중 76%로 과도한 위험 노출
# - 원래 의도한 분산 투자 효과 상실

1. 위험 관리: 특정 자산에 편중되는 것을 방지
2. 매수 저가/매도 고가: 올라간 자산을 팔고, 떨어진 자산을 사는 역발상 효과
3. 규율 유지: 감정적 투자 결정 방지
4. 장기 수익률 개선: 변동성 대비 수익률(샤프 비율) 향상

# 정해진 주기마다 리밸런싱
# 장점: 단순하고 실행하기 쉬움
# 단점: 시장 상황과 무관하게 실행

# 분기별 리밸런싱 (가장 보편적)
REBALANCE_SCHEDULE = "quarterly"  # monthly, quarterly, semi-annually, annually

# 추천 주기:
# - 월별: 거래 비용이 낮은 경우 (수수료 무료 증권사)
# - 분기별: 대부분의 투자자에게 적합
# - 반기/연간: 세금 효율 중시

# 목표 비중에서 일정 범위를 벗어나면 리밸런싱
# 장점: 큰 변동에 즉시 대응
# 단점: 시장 급변 시 잦은 거래 발생

THRESHOLD = 0.05  # 5% 이탈 시 리밸런싱

def needs_rebalancing(current_weights: dict, target_weights: dict, threshold: float) -> bool:
    """리밸런싱 필요 여부 판단"""
    for asset, target in target_weights.items():
        current = current_weights.get(asset, 0)
        if abs(current - target) > threshold:
            return True
    return False

# 예시: 미국주식이 40% -> 46% (6% 이탈) → 리밸런싱 필요!

# 분기 체크 + 5% 임계값 조합
# - 매 분기 포트폴리오 확인
# - 5% 이상 이탈한 자산이 있으면 리밸런싱
# - 이탈이 없으면 다음 분기까지 대기

def hybrid_rebalancing_check(
    current_weights: dict,
    target_weights: dict,
    threshold: float = 0.05,
    last_rebalance_date: str = None,
    max_interval_days: int = 180  # 6개월
) -> dict:
    """혼합 리밸런싱 전략"""
    from datetime import datetime, timedelta

    needs_rebal = False
    reason = ""

    # 임계값 체크
    for asset, target in target_weights.items():
        current = current_weights.get(asset, 0)
        drift = abs(current - target)
        if drift > threshold:
            needs_rebal = True
            reason = f"{asset}: {current:.1%} (목표 {target:.1%}, 이탈 {drift:.1%})"
            break

    # 최대 간격 체크
    if last_rebalance_date and not needs_rebal:
        last_date = datetime.strptime(last_rebalance_date, "%Y-%m-%d")
        if (datetime.now() - last_date).days > max_interval_days:
            needs_rebal = True
            reason = f"최대 리밸런싱 간격 {max_interval_days}일 초과"

    return {
        "needs_rebalancing": needs_rebal,
        "reason": reason
    }

def calculate_rebalancing(
    portfolio: dict,
    target_weights: dict,
    total_value: float
) -> dict:
    """리밸런싱 거래 계산"""
    trades = {}

    for asset, target_weight in target_weights.items():
        current_value = portfolio.get(asset, {}).get("value", 0)
        target_value = total_value * target_weight
        diff = target_value - current_value

        trades[asset] = {
            "current_value": current_value,
            "current_weight": current_value / total_value if total_value > 0 else 0,
            "target_value": target_value,
            "target_weight": target_weight,
            "trade_amount": diff,
            "action": "매수" if diff > 0 else "매도" if diff < 0 else "유지"
        }

    return trades


# 사용 예시
portfolio = {
    "KODEX 200": {"value": 2800000, "price": 35000},
    "VOO": {"value": 4800000, "price": 550000},
    "TLT": {"value": 1600000, "price": 85000},
    "GLD": {"value": 800000, "price": 260000}
}

target_weights = {
    "KODEX 200": 0.30,
    "VOO": 0.40,
    "TLT": 0.20,
    "GLD": 0.10
}

total_value = sum(a["value"] for a in portfolio.values())
trades = calculate_rebalancing(portfolio, target_weights, total_value)

for asset, trade in trades.items():
    if trade["action"] != "유지":
        print(f"{asset}: {trade['action']} {abs(trade['trade_amount']):,.0f}원")
        print(f"  현재: {trade['current_weight']:.1%} → 목표: {trade['target_weight']:.1%}")

def cash_flow_rebalancing(
    portfolio: dict,
    target_weights: dict,
    total_value: float,
    new_cash: float
) -> dict:
    """신규 자금으로 리밸런싱 (매도 최소화)"""
    new_total = total_value + new_cash

    # 각 자산의 부족분 계산
    shortfalls = {}
    for asset, target_weight in target_weights.items():
        current_value = portfolio.get(asset, {}).get("value", 0)
        target_value = new_total * target_weight
        shortfall = max(0, target_value - current_value)
        shortfalls[asset] = shortfall

    total_shortfall = sum(shortfalls.values())

    # 신규 자금을 부족분 비율로 배분
    allocations = {}
    for asset, shortfall in shortfalls.items():
        if total_shortfall > 0:
            allocation = new_cash * (shortfall / total_shortfall)
        else:
            allocation = new_cash * target_weights[asset]
        allocations[asset] = round(allocation)

    return allocations


# 예시: 100만원 추가 투자
allocations = cash_flow_rebalancing(portfolio, target_weights, total_value, 1000000)
print("신규 자금 배분:")
for asset, amount in allocations.items():
    print(f"  {asset}: {amount:,}원 매수")

# 매도 없이 신규 자금만으로 비중 조절!

def tax_loss_harvesting(
    holdings: list,
    threshold_loss_pct: float = -0.05
) -> list:
    """손실 난 포지션을 매도하여 세금 절감"""
    harvest_candidates = []

    for holding in holdings:
        gain_pct = (holding["current_price"] - holding["avg_cost"]) / holding["avg_cost"]

        if gain_pct < threshold_loss_pct:
            harvest_candidates.append({
                "asset": holding["asset"],
                "loss_amount": (holding["current_price"] - holding["avg_cost"]) * holding["quantity"],
                "gain_pct": gain_pct,
                "action": "매도 후 유사 ETF로 대체"
            })

    return harvest_candidates

# 한국의 경우:
# - 국내 주식 ETF: 비과세 (매매차익)
# - 해외 ETF: 양도소득세 22% (250만원 공제)
# - 배당소득세: 15.4%
#
# Tax-Loss Harvesting은 해외 ETF에 효과적

# 1. 보수적 포트폴리오 (안정 추구)
conservative = {
    "국내채권(KOSEF 국고채10년)": 0.40,
    "미국채권(TLT)": 0.20,
    "국내주식(KODEX 200)": 0.15,
    "미국주식(VOO)": 0.15,
    "금(GLD)": 0.10
}

# 2. 균형 포트폴리오 (일반적)
balanced = {
    "국내주식(KODEX 200)": 0.25,
    "미국주식(VOO)": 0.30,
    "선진국(VEA)": 0.10,
    "채권(AGG)": 0.25,
    "금(GLD)": 0.10
}

# 3. 공격적 포트폴리오 (성장 추구)
aggressive = {
    "미국주식(VOO)": 0.35,
    "나스닥(QQQ)": 0.20,
    "국내주식(KODEX 200)": 0.15,
    "신흥국(VWO)": 0.10,
    "채권(AGG)": 0.15,
    "금(GLD)": 0.05
}

# 4. 올웨더(All Weather) - 레이 달리오
all_weather = {
    "미국주식(VOO)": 0.30,
    "미국장기채(TLT)": 0.40,
    "미국중기채(IEF)": 0.15,
    "금(GLD)": 0.075,
    "원자재(DBC)": 0.075
}

#!/usr/bin/env python3
"""rebalance_checker.py - 리밸런싱 필요 여부 체크 스크립트"""
import json
from datetime import datetime


def check_and_notify():
    # 포트폴리오 데이터 (실제로는 증권사 API나 수동 입력)
    portfolio = {
        "KODEX 200": {"value": 2800000, "shares": 80},
        "VOO": {"value": 4800000, "shares": 8},
        "TLT": {"value": 1600000, "shares": 18},
        "GLD": {"value": 800000, "shares": 3}
    }

    target = {
        "KODEX 200": 0.30,
        "VOO": 0.40,
        "TLT": 0.20,
        "GLD": 0.10
    }

    total = sum(a["value"] for a in portfolio.values())

    # 드리프트 확인
    alerts = []
    for asset, target_w in target.items():
        current_w = portfolio[asset]["value"] / total
        drift = current_w - target_w
        if abs(drift) > 0.05:
            direction = "초과" if drift > 0 else "부족"
            alerts.append(
                f"⚠️ {asset}: 현재 {current_w:.1%} (목표 {target_w:.1%}, {abs(drift):.1%} {direction})"
            )

    if alerts:
        message = f"📊 리밸런싱 알림 ({datetime.now().strftime('%Y-%m-%d')})\n\n"
        message += "\n".join(alerts)
        message += f"\n\n총 자산: {total:,.0f}원"
        print(message)
        # 여기에 텔레그램/슬랙 알림 연동
    else:
        print("✅ 포트폴리오 정상 — 리밸런싱 불필요")


if __name__ == "__main__":
    check_and_notify()

# crontab으로 매주 월요일 체크
# 0 9 * * 1 python3 /path/to/rebalance_checker.py