확률 기초: 0과 1 사이의 세계

P(A) = (A가 일어나는 경우의 수) / (전체 경우의 수)

성질:
- 0 ≤ P(A) ≤ 1
- P(A) + P(¬A) = 1  (A와 그 여집합 합 = 1)
- P(전체) = 1
- P(공집합) = 0

import random

# 동전 던지기
def coin_flip():
    return 'H' if random.random() < 0.5 else 'T'


# 1000번 시뮬레이션
n = 10000
heads = sum(1 for _ in range(n) if coin_flip() == 'H')
print(f"앞면 비율: {heads/n:.4f}")  # 약 0.5


# 주사위
def roll_die():
    return random.randint(1, 6)


# 6이 나올 확률 (이론: 1/6 ≈ 0.167)
sixes = sum(1 for _ in range(n) if roll_die() == 6)
print(f"6 비율: {sixes/n:.4f}")

# 독립: P(A ∩ B) = P(A) × P(B)
# 종속: P(A ∩ B) = P(A) × P(B|A)


# 동전 두 번 — 독립
# 둘 다 앞면 = 0.5 × 0.5 = 0.25
n = 10000
both_h = sum(1 for _ in range(n) if coin_flip() == 'H' and coin_flip() == 'H')
print(f"둘 다 앞면: {both_h/n:.4f}")  # 약 0.25


# 카드 두 장 (복원 없음) — 종속
deck = ['hearts', 'diamonds', 'clubs', 'spades'] * 13  # 52장

def draw_two():
    d = deck.copy()
    random.shuffle(d)
    return d[0], d[1]


# 둘 다 hearts = 13/52 × 12/51 ≈ 0.0588
two_hearts = sum(1 for _ in range(n) if all(s == 'hearts' for s in draw_two()))
print(f"둘 다 hearts: {two_hearts/n:.4f}")

P(A|B) = P(A ∩ B) / P(B)
"B가 일어났을 때 A가 일어날 확률"

예: P(비|구름) = 구름 낀 날 중 비 오는 비율

# 데이터 시뮬레이션 — 1000일 날씨
import random

days = []
for _ in range(1000):
    cloudy = random.random() < 0.4    # 40% 확률로 흐림
    if cloudy:
        rain = random.random() < 0.7  # 흐릴 때 70%
    else:
        rain = random.random() < 0.1  # 맑을 때 10%
    days.append({'cloudy': cloudy, 'rain': rain})


# P(비)
rain_days = sum(1 for d in days if d['rain'])
print(f"P(비) = {rain_days/1000:.3f}")

# P(비|흐림)
cloudy_days = sum(1 for d in days if d['cloudy'])
rain_when_cloudy = sum(1 for d in days if d['cloudy'] and d['rain'])
print(f"P(비|흐림) = {rain_when_cloudy/cloudy_days:.3f}")

# P(흐림|비)
rain_and_cloudy = rain_when_cloudy
print(f"P(흐림|비) = {rain_and_cloudy/rain_days:.3f}")

# 단어 "FREE"가 포함된 메일 1000개 중 800개가 스팸
# 단어 "FREE"가 없는 메일 9000개 중 100개가 스팸

# P(스팸) = 900 / 10000 = 0.09
# P(FREE|스팸) = 800 / 900 = 0.889
# P(FREE|정상) = 200 / 9100 = 0.022
# P(스팸|FREE) = ?

# 베이즈 정리로 계산 (CH.42에서 자세히)
p_spam = 900 / 10000
p_free_given_spam = 800 / 900
p_free_given_ham = 200 / 9100
p_ham = 1 - p_spam

# P(FREE) = P(FREE|스팸)·P(스팸) + P(FREE|정상)·P(정상)
p_free = p_free_given_spam * p_spam + p_free_given_ham * p_ham

# P(스팸|FREE) = P(FREE|스팸)·P(스팸) / P(FREE)
p_spam_given_free = p_free_given_spam * p_spam / p_free
print(f"FREE 단어가 있을 때 스팸 확률: {p_spam_given_free:.4f}")
# 약 0.80 — FREE 단어 = 80% 스팸

# A/B 테스트 시뮬레이션
import numpy as np

# 변형 A의 진짜 CTR = 5%
# 변형 B의 진짜 CTR = 6%
true_ctr_a = 0.05
true_ctr_b = 0.06
n_visitors = 1000

clicks_a = np.random.binomial(1, true_ctr_a, n_visitors).sum()
clicks_b = np.random.binomial(1, true_ctr_b, n_visitors).sum()

print(f"변형 A: {clicks_a}/{n_visitors} = {clicks_a/n_visitors:.3f}")
print(f"변형 B: {clicks_b}/{n_visitors} = {clicks_b/n_visitors:.3f}")

# 통계적 유의성은 CH.44 (p-value)에서

# 단일 서버: 99.9% 가용성 = 장애 확률 0.1%
# 복제 서버 N개 (모두 독립적 장애)

def availability(servers, single_uptime=0.999):
    """N개 서버 중 1개라도 살아있을 확률"""
    failure_prob = 1 - single_uptime
    all_fail = failure_prob ** servers
    return 1 - all_fail


for n in [1, 2, 3, 5]:
    a = availability(n)
    downtime_per_year = (1 - a) * 365 * 24 * 60  # 분
    print(f"{n}개 서버: {a*100:.4f}% 가용 (연 {downtime_per_year:.1f}분 다운)")

# 1개: 99.9000% (연 525분)
# 2개: 99.9999% (연 0.5분)
# 3개: 99.99999...% (사실상 0)