REITs 부동산 투자 분석 완전 가이드: DCF 모델·수익률 시뮬레이션·직접투자 비교

# REITs 유형별 특성 정리
reit_types = {
    "Equity REITs (지분형)": {
        "description": "실물 부동산을 직접 소유하고 운영",
        "revenue_source": "임대 수익 + 자산 가치 상승",
        "risk_level": "중간",
        "example": "오피스, 리테일, 물류센터, 데이터센터",
        "market_share": "약 90%"
    },
    "Mortgage REITs (모기지형)": {
        "description": "부동산 담보 대출 및 MBS에 투자",
        "revenue_source": "이자 수익 (금리 스프레드)",
        "risk_level": "높음 (금리 민감도)",
        "example": "주택담보대출, 상업용 모기지",
        "market_share": "약 7%"
    },
    "Hybrid REITs (혼합형)": {
        "description": "지분형 + 모기지형 혼합 운영",
        "revenue_source": "임대 수익 + 이자 수익",
        "risk_level": "중간~높음",
        "example": "복합 포트폴리오 운영",
        "market_share": "약 3%"
    }
}

for reit_type, info in reit_types.items():
    print(f"\n{'='*50}")
    print(f"  {reit_type}")
    print(f"{'='*50}")
    for key, value in info.items():
        print(f"  {key}: {value}")

# 주요 K-REITs 종목 분석 (2025년 기준 예시 데이터)
k_reits = [
    {
        "name": "SK리츠",
        "ticker": "395400",
        "sector": "오피스/물류",
        "assets": "SK서린빌딩, 물류센터 등",
        "dividend_yield": 5.8,
        "market_cap_billion_krw": 1200,
    },
    {
        "name": "ESR켄달스퀘어리츠",
        "ticker": "365550",
        "sector": "물류",
        "assets": "국내 주요 물류센터",
        "dividend_yield": 6.2,
        "market_cap_billion_krw": 800,
    },
    {
        "name": "신한알파리츠",
        "ticker": "293940",
        "sector": "오피스",
        "assets": "판교 알파돔타워 등",
        "dividend_yield": 5.5,
        "market_cap_billion_krw": 600,
    },
    {
        "name": "롯데리츠",
        "ticker": "330590",
        "sector": "리테일/호텔",
        "assets": "롯데마트, 롯데호텔 등",
        "dividend_yield": 7.1,
        "market_cap_billion_krw": 500,
    },
    {
        "name": "제이알글로벌리츠",
        "ticker": "348950",
        "sector": "해외오피스",
        "assets": "벨기에 오피스 등 해외 자산",
        "dividend_yield": 8.5,
        "market_cap_billion_krw": 400,
    },
]

print(f"{'종목명':<18} {'섹터':<12} {'배당수익률':>8} {'시총(억원)':>10}")
print("-" * 55)
for reit in k_reits:
    print(f"{reit['name']:<18} {reit['sector']:<12} {reit['dividend_yield']:>7.1f}% {reit['market_cap_billion_krw']:>10,}")

Cap Rate = NOI / 자산 가격 x 100

예시: 연 NOI 5억 원, 자산 가격 100억 원
Cap Rate = 5억 / 100억 x 100 = 5.0%

FFO = 순이익 + 감가상각비 - 부동산 매각 차익

AFFO = FFO - 유지보수 자본지출 - 임대료 직선화 조정

# REITs 핵심 지표 계산 예시
class REITMetrics:
    def __init__(self, name, noi, property_value, net_income,
                 depreciation, gain_on_sale, capex, shares, price):
        self.name = name
        self.noi = noi
        self.property_value = property_value
        self.net_income = net_income
        self.depreciation = depreciation
        self.gain_on_sale = gain_on_sale
        self.capex = capex
        self.shares = shares
        self.price = price

    def cap_rate(self):
        return self.noi / self.property_value * 100

    def ffo(self):
        return self.net_income + self.depreciation - self.gain_on_sale

    def affo(self):
        return self.ffo() - self.capex

    def ffo_per_share(self):
        return self.ffo() / self.shares

    def p_ffo(self):
        return self.price / self.ffo_per_share()

    def nav_per_share(self, total_debt):
        nav = self.property_value - total_debt
        return nav / self.shares

    def premium_discount(self, total_debt):
        nav = self.nav_per_share(total_debt)
        return (self.price - nav) / nav * 100

    def report(self, total_debt):
        print(f"\n{'='*45}")
        print(f"  {self.name} 투자 지표 분석")
        print(f"{'='*45}")
        print(f"  Cap Rate:         {self.cap_rate():.2f}%")
        print(f"  FFO:              {self.ffo():,.0f} 백만원")
        print(f"  AFFO:             {self.affo():,.0f} 백만원")
        print(f"  FFO/주:           {self.ffo_per_share():,.0f} 원")
        print(f"  P/FFO:            {self.p_ffo():.2f}x")
        print(f"  NAV/주:           {self.nav_per_share(total_debt):,.0f} 원")
        premium = self.premium_discount(total_debt)
        label = "프리미엄" if premium > 0 else "디스카운트"
        print(f"  NAV {label}:   {abs(premium):.1f}%")


# 예시 REITs 분석
example_reit = REITMetrics(
    name="예시 오피스 리츠",
    noi=5000,           # NOI 50억 원 (백만원 단위)
    property_value=100000,  # 자산가치 1000억 원
    net_income=2000,     # 순이익 20억 원
    depreciation=3500,   # 감가상각 35억 원
    gain_on_sale=500,    # 매각차익 5억 원
    capex=800,           # 유지보수 CapEx 8억 원
    shares=10000000,     # 발행주식 1000만 주
    price=5500           # 현재 주가 5,500원
)

example_reit.report(total_debt=40000)  # 부채 400억 원

import numpy as np

class REITsDCFModel:
    """REITs DCF 가치평가 모델"""

    def __init__(self, current_affo, growth_rates, discount_rate,
                 terminal_growth_rate, shares_outstanding):
        """
        Parameters:
        - current_affo: 현재 연간 AFFO (백만원)
        - growth_rates: 연도별 AFFO 성장률 리스트
        - discount_rate: 할인율 (WACC)
        - terminal_growth_rate: 영구 성장률
        - shares_outstanding: 발행 주식 수
        """
        self.current_affo = current_affo
        self.growth_rates = growth_rates
        self.discount_rate = discount_rate
        self.terminal_growth_rate = terminal_growth_rate
        self.shares = shares_outstanding

    def project_cash_flows(self):
        """미래 AFFO 현금흐름 예측"""
        cash_flows = []
        affo = self.current_affo
        for rate in self.growth_rates:
            affo = affo * (1 + rate)
            cash_flows.append(affo)
        return cash_flows

    def calculate_terminal_value(self, final_affo):
        """영구가치(Terminal Value) 계산 - Gordon Growth Model"""
        tv = final_affo * (1 + self.terminal_growth_rate) / \
             (self.discount_rate - self.terminal_growth_rate)
        return tv

    def calculate_present_values(self, cash_flows, terminal_value):
        """현재가치 계산"""
        pv_cash_flows = []
        for i, cf in enumerate(cash_flows):
            pv = cf / (1 + self.discount_rate) ** (i + 1)
            pv_cash_flows.append(pv)

        n = len(cash_flows)
        pv_terminal = terminal_value / (1 + self.discount_rate) ** n
        return pv_cash_flows, pv_terminal

    def intrinsic_value_per_share(self):
        """주당 내재가치 산출"""
        cash_flows = self.project_cash_flows()
        terminal_value = self.calculate_terminal_value(cash_flows[-1])
        pv_cfs, pv_tv = self.calculate_present_values(cash_flows, terminal_value)

        total_value = sum(pv_cfs) + pv_tv
        value_per_share = total_value / self.shares
        return value_per_share, pv_cfs, pv_tv, cash_flows, terminal_value

    def sensitivity_analysis(self, discount_rates, terminal_rates):
        """민감도 분석: 할인율 x 영구성장률 매트릭스"""
        results = []
        for dr in discount_rates:
            row = []
            for tg in terminal_rates:
                self.discount_rate = dr
                self.terminal_growth_rate = tg
                val, _, _, _, _ = self.intrinsic_value_per_share()
                row.append(val)
            results.append(row)
        return np.array(results)


# DCF 모델 실행 예시
model = REITsDCFModel(
    current_affo=4200,           # 현재 AFFO 42억 원
    growth_rates=[0.05, 0.05, 0.04, 0.04, 0.03,
                  0.03, 0.03, 0.02, 0.02, 0.02],  # 10년 성장률
    discount_rate=0.08,          # 할인율 8%
    terminal_growth_rate=0.02,   # 영구 성장률 2%
    shares_outstanding=10000000  # 발행주식 1000만 주
)

value, pv_cfs, pv_tv, cfs, tv = model.intrinsic_value_per_share()

print("="*55)
print("  REITs DCF 가치평가 결과")
print("="*55)
print(f"\n  [미래 AFFO 전망]")
for i, cf in enumerate(cfs):
    print(f"    Year {i+1}: {cf:>10,.0f} 백만원")

print(f"\n  영구가치 (Terminal Value): {tv:>15,.0f} 백만원")
print(f"\n  [현재가치]")
print(f"    예측기간 PV 합계:       {sum(pv_cfs):>12,.0f} 백만원")
print(f"    영구가치 PV:            {pv_tv:>12,.0f} 백만원")
print(f"    기업가치 합계:          {sum(pv_cfs)+pv_tv:>12,.0f} 백만원")
print(f"\n  주당 내재가치: {value:,.0f} 원")

# 민감도 분석
print(f"\n{'='*55}")
print("  민감도 분석 (주당 내재가치)")
print("="*55)
d_rates = [0.07, 0.08, 0.09, 0.10]
t_rates = [0.01, 0.015, 0.02, 0.025]

matrix = model.sensitivity_analysis(d_rates, t_rates)
header = "할인율 \\ 영구성장률"
print(f"\n  {header:<18}", end="")
for tg in t_rates:
    print(f"  {tg*100:>5.1f}%", end="")
print()
print("  " + "-" * 45)
for i, dr in enumerate(d_rates):
    print(f"  {dr*100:>5.1f}%           ", end="")
    for j in range(len(t_rates)):
        print(f"  {matrix[i][j]:>6,.0f}", end="")
    print()

import numpy as np

def monte_carlo_reit_simulation(
    initial_investment,
    annual_dividend_yield,
    expected_price_return,
    volatility,
    years,
    n_simulations=10000,
    dividend_reinvest=True
):
    """
    REITs 투자 몬테카를로 시뮬레이션

    Parameters:
    - initial_investment: 초기 투자금 (원)
    - annual_dividend_yield: 연간 배당수익률
    - expected_price_return: 기대 주가 수익률 (연)
    - volatility: 연간 변동성
    - years: 투자 기간 (년)
    - n_simulations: 시뮬레이션 횟수
    - dividend_reinvest: 배당 재투자 여부
    """
    np.random.seed(42)
    results = np.zeros((n_simulations, years + 1))
    results[:, 0] = initial_investment

    for sim in range(n_simulations):
        portfolio_value = initial_investment
        for year in range(1, years + 1):
            # 주가 수익률 (로그정규분포)
            price_return = np.random.normal(
                expected_price_return, volatility
            )
            # 배당 수익
            dividend = portfolio_value * annual_dividend_yield

            if dividend_reinvest:
                portfolio_value = portfolio_value * (1 + price_return) + dividend
            else:
                portfolio_value = portfolio_value * (1 + price_return)

            # 최소 0 제한
            portfolio_value = max(portfolio_value, 0)
            results[sim, year] = portfolio_value

    return results


# 시뮬레이션 실행
results = monte_carlo_reit_simulation(
    initial_investment=50_000_000,  # 5000만 원
    annual_dividend_yield=0.055,     # 배당수익률 5.5%
    expected_price_return=0.03,      # 기대 주가상승률 3%
    volatility=0.15,                 # 변동성 15%
    years=20,                        # 20년
    n_simulations=10000
)

final_values = results[:, -1]
print("="*55)
print("  REITs 투자 몬테카를로 시뮬레이션 결과 (20년)")
print("="*55)
print(f"  초기 투자금:     {50_000_000:>15,} 원")
print(f"  시뮬레이션 횟수: {10000:>15,} 회")
print(f"\n  [최종 포트폴리오 가치 분포]")
print(f"  평균:            {np.mean(final_values):>15,.0f} 원")
print(f"  중앙값:          {np.median(final_values):>15,.0f} 원")
print(f"  하위 5% (VaR):   {np.percentile(final_values, 5):>15,.0f} 원")
print(f"  상위 95%:        {np.percentile(final_values, 95):>15,.0f} 원")
print(f"  최솟값:          {np.min(final_values):>15,.0f} 원")
print(f"  최댓값:          {np.max(final_values):>15,.0f} 원")

total_return = (np.median(final_values) / 50_000_000 - 1) * 100
annualized = ((np.median(final_values) / 50_000_000) ** (1/20) - 1) * 100
print(f"\n  중앙값 기준 총 수익률:  {total_return:>8.1f}%")
print(f"  중앙값 기준 연환산 수익률: {annualized:>6.1f}%")

| 비교 항목      | REITs          | 직접 부동산 투자    | 부동산 펀드      |
|--------------|----------------|-----------------|----------------|
| 최소 투자금    | 수만 원         | 수억 원 이상       | 수백만 원       |
| 유동성        | 높음 (주식처럼)  | 매우 낮음          | 낮음           |
| 분산 투자     | 용이            | 어려움            | 중간           |
| 관리 부담     | 없음            | 높음 (직접 관리)   | 없음           |
| 레버리지      | 제한적           | 대출 활용 가능     | 제한적          |
| 세금 혜택     | 배당소득세       | 양도세 비과세 가능  | 배당소득세      |
| 수익 통제     | 불가            | 완전 통제          | 불가           |
| 정보 투명성   | 높음 (공시 의무) | 중간              | 중간           |
| 인플레이션    | 중간 헤지       | 강한 헤지          | 중간 헤지       |
| 거래 비용     | 증권 수수료     | 취득세, 중개수수료  | 환매 수수료     |

def compare_investment_scenarios(
    investment_amount,
    years,
    # REITs 파라미터
    reit_dividend_yield=0.055,
    reit_price_growth=0.03,
    reit_tax_rate=0.154,       # 배당소득세 15.4%
    # 직접투자 파라미터
    direct_rental_yield=0.035,
    direct_price_growth=0.04,
    direct_loan_ratio=0.60,
    direct_loan_rate=0.045,
    direct_expense_ratio=0.01, # 관리비, 수선비 등
    direct_acquisition_tax=0.046  # 취득세 4.6%
):
    """REITs vs 직접 부동산 투자 수익률 비교"""

    # === REITs 투자 ===
    reit_value = investment_amount
    reit_total_dividend = 0

    for y in range(years):
        dividend = reit_value * reit_dividend_yield
        after_tax_dividend = dividend * (1 - reit_tax_rate)
        reit_total_dividend += after_tax_dividend
        reit_value *= (1 + reit_price_growth)

    reit_total_return = (reit_value - investment_amount) + reit_total_dividend

    # === 직접 부동산 투자 ===
    property_value = investment_amount / (1 - direct_loan_ratio)
    loan_amount = property_value * direct_loan_ratio
    equity = investment_amount
    acq_tax = property_value * direct_acquisition_tax
    equity_after_tax = equity - acq_tax

    direct_total_rental = 0
    current_property_value = property_value

    for y in range(years):
        rental_income = current_property_value * direct_rental_yield
        loan_interest = loan_amount * direct_loan_rate
        expenses = current_property_value * direct_expense_ratio
        net_rental = rental_income - loan_interest - expenses
        direct_total_rental += net_rental
        current_property_value *= (1 + direct_price_growth)

    property_gain = current_property_value - property_value
    direct_total_return = property_gain + direct_total_rental - acq_tax

    # 결과 출력
    print("="*55)
    print("  투자 시나리오 비교 (투자금: {:,}원, {}년)".format(
        investment_amount, years
    ))
    print("="*55)

    print(f"\n  [REITs 투자]")
    print(f"    투자금:          {investment_amount:>15,} 원")
    print(f"    최종 자산가치:    {reit_value:>15,.0f} 원")
    print(f"    누적 배당(세후):  {reit_total_dividend:>15,.0f} 원")
    print(f"    총 수익:         {reit_total_return:>15,.0f} 원")
    reit_roi = reit_total_return / investment_amount * 100
    print(f"    ROI:             {reit_roi:>14.1f}%")

    print(f"\n  [직접 부동산 투자 (LTV {direct_loan_ratio*100:.0f}%)]")
    print(f"    자기자본:        {investment_amount:>15,} 원")
    print(f"    부동산 가격:     {property_value:>15,.0f} 원")
    print(f"    대출금:          {loan_amount:>15,.0f} 원")
    print(f"    취득세:          {acq_tax:>15,.0f} 원")
    print(f"    매각 시 자산가치: {current_property_value:>15,.0f} 원")
    print(f"    누적 순임대수익:  {direct_total_rental:>15,.0f} 원")
    print(f"    총 수익:         {direct_total_return:>15,.0f} 원")
    direct_roi = direct_total_return / investment_amount * 100
    print(f"    ROI (자기자본):  {direct_roi:>14.1f}%")


# 시나리오 실행
compare_investment_scenarios(
    investment_amount=100_000_000,  # 1억 원
    years=10
)

import numpy as np

def calculate_portfolio_metrics(weights, returns, cov_matrix):
    """포트폴리오 기대수익률과 변동성 계산"""
    port_return = np.dot(weights, returns)
    port_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
    sharpe = (port_return - 0.035) / port_volatility  # 무위험이자율 3.5%
    return port_return, port_volatility, sharpe


# 자산 클래스 정의 (연간 기대수익률, 표준편차)
asset_classes = {
    "국내주식":    {"return": 0.08, "std": 0.20},
    "해외주식":    {"return": 0.09, "std": 0.18},
    "국내채권":    {"return": 0.04, "std": 0.05},
    "해외채권":    {"return": 0.045, "std": 0.08},
    "REITs":      {"return": 0.07, "std": 0.15},
}

# 상관계수 행렬 (REITs는 주식/채권과 낮은 상관관계)
correlation_matrix = np.array([
    [1.00, 0.75, 0.10, 0.15, 0.45],  # 국내주식
    [0.75, 1.00, 0.05, 0.20, 0.55],  # 해외주식
    [0.10, 0.05, 1.00, 0.60, 0.15],  # 국내채권
    [0.15, 0.20, 0.60, 1.00, 0.20],  # 해외채권
    [0.45, 0.55, 0.15, 0.20, 1.00],  # REITs
])

returns = np.array([v["return"] for v in asset_classes.values()])
stds = np.array([v["std"] for v in asset_classes.values()])
cov_matrix = np.outer(stds, stds) * correlation_matrix

# 포트폴리오 시나리오 비교
scenarios = {
    "REITs 미포함 (60/40)": np.array([0.35, 0.25, 0.25, 0.15, 0.00]),
    "REITs 10% 편입":       np.array([0.30, 0.20, 0.25, 0.15, 0.10]),
    "REITs 15% 편입":       np.array([0.25, 0.20, 0.25, 0.15, 0.15]),
    "REITs 20% 편입":       np.array([0.25, 0.15, 0.20, 0.20, 0.20]),
}

print("="*65)
print("  포트폴리오 시나리오별 성과 비교")
print("="*65)
print(f"\n  {'시나리오':<25} {'기대수익률':>8} {'변동성':>8} {'샤프비율':>8}")
print("  " + "-" * 52)

for name, weights in scenarios.items():
    ret, vol, sharpe = calculate_portfolio_metrics(weights, returns, cov_matrix)
    print(f"  {name:<25} {ret*100:>7.2f}% {vol*100:>7.2f}% {sharpe:>8.3f}")

print(f"\n  REITs 편입 시 분산 효과로 변동성 대비 수익률 개선 확인")

| 과세 항목    | REITs           | 직접 부동산         | 부동산 펀드       |
|------------|-----------------|-------------------|-----------------|
| 취득세      | 없음             | 4.6% (주택)       | 없음             |
| 보유세      | 없음 (REITs 부담)| 재산세+종부세       | 없음             |
| 배당/임대   | 15.4% (9.9% 특례)| 종합소득세 최대 45% | 15.4%           |
| 양도차익    | 비과세 (상장)     | 양도소득세 6~45%   | 배당소득세 15.4% |