wOBA = (0.69 * BB + 0.72 * HBP + 0.89 * 1B + 1.27 * 2B + 1.62 * 3B + 2.10 * HR)
       / (AB + BB - IBB + SF + HBP)

FIP = ((13 * HR) + (3 * (BB + HBP)) - (2 * K)) / IP + FIP_constant

# pybaseball 설치: pip install pybaseball

import pybaseball as pb
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Statcast 데이터 가져오기 (오타니 2023 시즌)
pb.cache.enable()

# 특정 선수의 Statcast 데이터
ohtani_id = 660271  # 오타니 MLB ID
data = pb.statcast_pitcher(
    start_dt='2023-04-01',
    end_dt='2023-10-01',
    player_id=ohtani_id
)

print(f"총 투구 수: {len(data)}")
print(data[['pitch_type', 'release_speed', 'release_spin_rate',
            'pfx_x', 'pfx_z']].describe())

# 구종별 회전수 분포 시각화
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# 구종별 평균 구속
pitch_speed = data.groupby('pitch_type')['release_speed'].mean().sort_values(ascending=False)
axes[0].bar(pitch_speed.index, pitch_speed.values, color='steelblue')
axes[0].set_title("오타니 구종별 평균 구속 (mph)")
axes[0].set_xlabel("구종")
axes[0].set_ylabel("구속 (mph)")

# 구종별 회전수
pitch_spin = data.groupby('pitch_type')['release_spin_rate'].mean().sort_values(ascending=False)
axes[1].bar(pitch_spin.index, pitch_spin.values, color='coral')
axes[1].set_title("오타니 구종별 평균 회전수 (RPM)")
axes[1].set_xlabel("구종")
axes[1].set_ylabel("회전수 (RPM)")

plt.tight_layout()
plt.savefig('ohtani_pitch_analysis.png', dpi=150)
plt.show()

# 투구 무브먼트 차트 (피치 차트)
def plot_pitch_movement(data):
    pitch_types = data['pitch_type'].unique()
    colors = plt.cm.Set1(range(len(pitch_types)))
    color_map = dict(zip(pitch_types, colors))

    fig, ax = plt.subplots(figsize=(10, 8))

    for pt in pitch_types:
        subset = data[data['pitch_type'] == pt]
        ax.scatter(
            subset['pfx_x'] * 12,   # 인치 변환
            subset['pfx_z'] * 12,
            label=pt,
            alpha=0.3,
            color=color_map[pt],
            s=10
        )

    ax.axhline(y=0, color='gray', linestyle='--', alpha=0.5)
    ax.axvline(x=0, color='gray', linestyle='--', alpha=0.5)
    ax.set_xlabel("수평 무브먼트 (인치, 포수 시점)")
    ax.set_ylabel("수직 무브먼트 (인치)")
    ax.set_title("투구 무브먼트 차트")
    ax.legend(title="구종")
    plt.tight_layout()
    plt.show()

plot_pitch_movement(data)

# KBO 데이터는 직접 크롤링하거나 KBO 공식 API를 활용합니다
# 여기서는 pandas를 이용한 분석 예시를 보여줍니다

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm

# 한글 폰트 설정 (macOS)
plt.rcParams['font.family'] = 'AppleGothic'
plt.rcParams['axes.unicode_minus'] = False

# 가상의 KBO 2023 타자 데이터 (실제로는 KBO 통계 사이트에서 가져옵니다)
kbo_batters = pd.DataFrame({
    '선수명': ['이정후', '박병호', '양의지', '최형우', '강백호'],
    '팀': ['키움', 'NC', '두산', 'KIA', 'KT'],
    '타율': [0.349, 0.282, 0.311, 0.301, 0.285],
    '출루율': [0.421, 0.385, 0.392, 0.378, 0.362],
    '장타율': [0.561, 0.512, 0.478, 0.489, 0.501],
    '홈런': [23, 34, 15, 21, 28],
    '타점': [112, 101, 78, 89, 95]
})

# OPS (출루율 + 장타율) 계산
kbo_batters['OPS'] = kbo_batters['출루율'] + kbo_batters['장타율']

# wRC+ 근사값 계산 (간략화)
# 실제 wRC+는 파크팩터와 리그 평균을 고려한 복잡한 수식을 사용합니다
league_avg_obp = kbo_batters['출루율'].mean()
league_avg_slg = kbo_batters['장타율'].mean()

kbo_batters['wRC_approx'] = (
    (kbo_batters['출루율'] / league_avg_obp) * 0.5 +
    (kbo_batters['장타율'] / league_avg_slg) * 0.5
) * 100

print("\nKBO 2023 타자 분석:")
print(kbo_batters[['선수명', '팀', '타율', '출루율', 'OPS', 'wRC_approx']].to_string(index=False))

# OPS 시각화
fig, ax = plt.subplots(figsize=(10, 6))
bars = ax.barh(kbo_batters['선수명'], kbo_batters['OPS'],
               color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd'])
ax.set_xlabel('OPS (출루율 + 장타율)')
ax.set_title('KBO 2023 주요 타자 OPS 비교')
ax.axvline(x=kbo_batters['OPS'].mean(), color='red',
           linestyle='--', label=f'리그 평균: {kbo_batters["OPS"].mean():.3f}')
ax.legend()
plt.tight_layout()
plt.show()

2점 지역에서의 기대값 = 슛 성공률 * 2점
3점 지역에서의 기대값 = 슛 성공률 * 3점

예시:
- 미드레인지 2점 슛 (45% 성공률): 기대값 = 0.45 * 2 = 0.90점
- 코너 3점 슛 (38% 성공률): 기대값 = 0.38 * 3 = 1.14점

# nba_api 설치: pip install nba_api

from nba_api.stats.endpoints import playercareerstats, leaguedashplayerstats
from nba_api.stats.static import players
import pandas as pd
import matplotlib.pyplot as plt
import time

# 선수 ID 찾기
def get_player_id(name):
    all_players = players.get_players()
    for p in all_players:
        if p['full_name'].lower() == name.lower():
            return p['id']
    return None

# 르브론 제임스 커리어 스탯
lebron_id = get_player_id('LeBron James')
time.sleep(1)  # API 레이트 리밋 방지

career = playercareerstats.PlayerCareerStats(player_id=lebron_id)
career_df = career.get_data_frames()[0]

# 시즌별 PTS, AST, REB 추이
career_df['PTS_PER_GAME'] = career_df['PTS'] / career_df['GP']
career_df['AST_PER_GAME'] = career_df['AST'] / career_df['GP']
career_df['REB_PER_GAME'] = career_df['REB'] / career_df['GP']

fig, axes = plt.subplots(1, 3, figsize=(18, 6))

metrics = [
    ('PTS_PER_GAME', '득점', 'royalblue'),
    ('AST_PER_GAME', '어시스트', 'forestgreen'),
    ('REB_PER_GAME', '리바운드', 'crimson')
]

for ax, (col, label, color) in zip(axes, metrics):
    ax.plot(career_df['SEASON_ID'], career_df[col],
            marker='o', color=color, linewidth=2)
    ax.set_title(f'르브론 제임스 시즌별 {label}')
    ax.set_xlabel('시즌')
    ax.set_ylabel(f'{label}/경기')
    ax.tick_params(axis='x', rotation=45)
    ax.grid(alpha=0.3)

plt.suptitle("르브론 제임스 커리어 스탯 추이", fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

# 2022-23 시즌 리그 전체 선수 효율 분석
time.sleep(1)
season_stats = leaguedashplayerstats.LeagueDashPlayerStats(
    season='2022-23',
    per_mode_simple='PerGame'
)
df = season_stats.get_data_frames()[0]

# 최소 500분 출장 선수만 필터링
df_filtered = df[df['MIN'] >= 500].copy()
df_filtered['eFG'] = (df_filtered['FGM'] + 0.5 * df_filtered['FG3M']) / df_filtered['FGA']

# 득점 vs eFG% 산점도
fig, ax = plt.subplots(figsize=(12, 8))
scatter = ax.scatter(
    df_filtered['eFG'],
    df_filtered['PTS'],
    c=df_filtered['MIN'],
    cmap='viridis',
    alpha=0.6,
    s=50
)
plt.colorbar(scatter, label='출장 시간 (분)')
ax.set_xlabel('이펙티브 필드골율 (eFG%)')
ax.set_ylabel('경기당 득점')
ax.set_title('2022-23 NBA 선수별 득점 vs 효율 (색상: 출장 시간)')

# 상위 선수 라벨 추가
top_scorers = df_filtered.nlargest(5, 'PTS')
for _, row in top_scorers.iterrows():
    ax.annotate(row['PLAYER_NAME'],
                (row['eFG'], row['PTS']),
                textcoords="offset points",
                xytext=(5, 5),
                fontsize=8)

plt.tight_layout()
plt.show()

PPDA = 상대팀 패스 수 / (태클 + 인터셉트 + 반칙 + 압박 성공)

# statsbombpy, mplsoccer 설치
# pip install statsbombpy mplsoccer

from statsbombpy import sb
import mplsoccer
from mplsoccer import Pitch, VerticalPitch, FontManager
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# StatsBomb 오픈 데이터에서 경기 목록 가져오기
# (StatsBomb은 일부 대회 데이터를 무료로 제공합니다)
competitions = sb.competitions()
print(competitions[['competition_id', 'competition_name', 'season_name']].head(20))

# 2018 FIFA 월드컵 경기 데이터
matches = sb.matches(competition_id=43, season_id=3)  # 2018 월드컵
print(f"총 경기 수: {len(matches)}")

# 특정 경기 이벤트 데이터 로드 (예: 프랑스 vs 크로아티아 결승전)
final_id = matches[
    (matches['home_team'] == 'France') &
    (matches['away_team'] == 'Croatia')
]['match_id'].values[0]

events = sb.events(match_id=final_id)

# 슛 이벤트만 필터링
shots = events[events['type'] == 'Shot'].copy()
shots_expanded = pd.json_normalize(shots['shot'].dropna())

# xG 시각화
pitch = VerticalPitch(
    pitch_type='statsbomb',
    pitch_color='grass',
    line_color='white',
    half=True
)

fig, ax = pitch.draw(figsize=(8, 12))

# 팀별 슛 표시
for team_color, team in [('#1f77b4', 'France'), ('#d62728', 'Croatia')]:
    team_shots = shots[shots['team'] == team]
    for _, shot in team_shots.iterrows():
        x = shot['location'][0]
        y = shot['location'][1]
        try:
            xg = shot['shot']['statsbomb_xg']
            outcome = shot['shot']['outcome']['name']
            marker = '*' if outcome == 'Goal' else 'o'
            size = xg * 1000  # xG를 크기로 표현
            ax.scatter(y, x, s=size, c=team_color,
                      marker=marker, alpha=0.7, edgecolors='white', linewidths=0.5)
        except (KeyError, TypeError):
            pass

ax.set_title('2018 FIFA 월드컵 결승전\n프랑스 vs 크로아티아 슛 맵\n(크기=xG, 별=골)',
             fontsize=12, pad=20)
plt.tight_layout()
plt.savefig('shot_map_final.png', dpi=150, bbox_inches='tight')
plt.show()

# 패스 네트워크 시각화 함수
def plot_pass_network(events, team_name, ax, pitch):
    team_events = events[events['team'] == team_name]
    passes = team_events[
        (team_events['type'] == 'Pass') &
        (team_events['pass_outcome'].isna())  # 성공한 패스만
    ].copy()

    # 선수별 평균 위치 계산
    player_positions = {}
    for player in passes['player'].unique():
        player_passes = passes[passes['player'] == player]
        avg_x = player_passes['location'].apply(lambda loc: loc[0]).mean()
        avg_y = player_passes['location'].apply(lambda loc: loc[1]).mean()
        player_positions[player] = (avg_x, avg_y)

    # 패스 빈도 계산
    pass_counts = passes.groupby(['player', 'pass_recipient']).size().reset_index(name='count')

    # 패스 라인 그리기
    for _, row in pass_counts[pass_counts['count'] >= 3].iterrows():
        if row['player'] in player_positions and row['pass_recipient'] in player_positions:
            x1, y1 = player_positions[row['player']]
            x2, y2 = player_positions[row['pass_recipient']]
            lw = row['count'] / 5
            pitch.lines(y1, x1, y2, x2, ax=ax,
                       lw=lw, color='white', alpha=0.5, zorder=1)

    # 선수 포지션 표시
    for player, (x, y) in player_positions.items():
        pitch.scatter(y, x, ax=ax, s=300, color='gold',
                     edgecolors='black', linewidths=1.5, zorder=2)
        last_name = player.split()[-1]
        ax.annotate(last_name, (y, x), textcoords="offset points",
                   xytext=(0, 8), ha='center', fontsize=7, color='white', fontweight='bold')

# 부상 예측 모델 예시 (간략화)
import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, roc_auc_score

# 가상의 선수 훈련 데이터
np.random.seed(42)
n_players = 500

data = pd.DataFrame({
    'acute_load': np.random.normal(450, 80, n_players),   # 지난 1주 훈련 부하
    'chronic_load': np.random.normal(400, 60, n_players), # 지난 4주 평균 부하
    'sleep_quality': np.random.uniform(3, 10, n_players), # 수면 품질 점수
    'hrv': np.random.normal(65, 15, n_players),            # 심박 변동성
    'sprint_distance': np.random.normal(350, 50, n_players),  # 일일 스프린트 거리
    'days_since_rest': np.random.randint(0, 7, n_players),
    'age': np.random.randint(18, 38, n_players),
    'previous_injuries': np.random.randint(0, 5, n_players)
})

# ACWR 계산 (Acute:Chronic Workload Ratio)
data['acwr'] = data['acute_load'] / data['chronic_load']

# 부상 레이블 생성 (실제 데이터에서는 의료 기록 사용)
injury_prob = (
    0.1 +
    0.3 * (data['acwr'] > 1.5).astype(float) +
    0.15 * (data['sleep_quality'] < 5).astype(float) +
    0.1 * (data['hrv'] < 50).astype(float) +
    0.05 * (data['previous_injuries'] > 2).astype(float)
)
data['injured'] = (np.random.random(n_players) < injury_prob).astype(int)

print(f"부상 발생률: {data['injured'].mean():.2%}")

# 모델 학습
features = ['acwr', 'sleep_quality', 'hrv', 'sprint_distance',
            'days_since_rest', 'age', 'previous_injuries']
X = data[features]
y = data['injured']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = GradientBoostingClassifier(
    n_estimators=200,
    max_depth=4,
    learning_rate=0.05,
    random_state=42
)
model.fit(X_train_scaled, y_train)

# 평가
y_pred = model.predict(X_test_scaled)
y_prob = model.predict_proba(X_test_scaled)[:, 1]

print("\n분류 리포트:")
print(classification_report(y_test, y_pred))
print(f"ROC-AUC: {roc_auc_score(y_test, y_prob):.4f}")

# 피처 중요도
importance_df = pd.DataFrame({
    'feature': features,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(importance_df['feature'], importance_df['importance'], color='steelblue')
ax.set_title('부상 예측 모델 - 피처 중요도')
ax.set_xlabel('중요도')
plt.tight_layout()
plt.show()

# 축구 경기 결과 예측 (포아송 분포 기반)
import numpy as np
from scipy.stats import poisson

def predict_match(home_attack, home_defense, away_attack, away_defense,
                  home_advantage=1.1):
    """
    포아송 분포를 이용한 경기 결과 예측
    attack: 공격력 지수 (리그 평균 = 1.0)
    defense: 방어력 지수 (리그 평균 = 1.0, 낮을수록 수비가 강함)
    """
    league_avg_goals = 1.35  # EPL 평균 경기당 득점

    home_goals_exp = home_attack * away_defense * league_avg_goals * home_advantage
    away_goals_exp = away_attack * home_defense * league_avg_goals

    max_goals = 10
    home_win = 0
    draw = 0
    away_win = 0

    for i in range(max_goals):
        for j in range(max_goals):
            p = poisson.pmf(i, home_goals_exp) * poisson.pmf(j, away_goals_exp)
            if i > j:
                home_win += p
            elif i == j:
                draw += p
            else:
                away_win += p

    return {
        'home_goals_exp': round(home_goals_exp, 2),
        'away_goals_exp': round(away_goals_exp, 2),
        'home_win': round(home_win, 3),
        'draw': round(draw, 3),
        'away_win': round(away_win, 3)
    }

# 맨체스터 시티 vs 아스널 예시
result = predict_match(
    home_attack=1.4,    # 시티 공격력
    home_defense=0.7,   # 시티 수비력
    away_attack=1.3,    # 아스널 공격력
    away_defense=0.75   # 아스널 수비력
)
print("맨체스터 시티 vs 아스널 예측:")
for k, v in result.items():
    print(f"  {k}: {v}")

import pandas as pd
import numpy as np

# 가상의 NBA 선수 시즌 데이터
np.random.seed(42)
n_players = 100

players_data = pd.DataFrame({
    'player_name': [f'Player_{i:03d}' for i in range(n_players)],
    'team': np.random.choice(['LAL', 'GSW', 'BOS', 'MIA', 'DEN'], n_players),
    'position': np.random.choice(['PG', 'SG', 'SF', 'PF', 'C'], n_players),
    'age': np.random.randint(19, 38, n_players),
    'games_played': np.random.randint(30, 82, n_players),
    'minutes': np.random.normal(28, 8, n_players).clip(8, 40),
    'points': np.random.normal(14, 6, n_players).clip(0, 40),
    'rebounds': np.random.normal(5, 2.5, n_players).clip(0, 15),
    'assists': np.random.normal(4, 2.5, n_players).clip(0, 12),
    'fg_pct': np.random.normal(0.46, 0.06, n_players).clip(0.2, 0.7),
    'three_pct': np.random.normal(0.35, 0.08, n_players).clip(0.1, 0.55),
    'ft_pct': np.random.normal(0.78, 0.1, n_players).clip(0.4, 1.0),
    'turnovers': np.random.normal(2.5, 1, n_players).clip(0, 6),
    'steals': np.random.normal(1.2, 0.5, n_players).clip(0, 3.5),
    'blocks': np.random.normal(0.8, 0.6, n_players).clip(0, 4),
    'salary_million': np.random.lognormal(2.5, 0.7, n_players)
})

# 고급 지표 계산
# TS% (True Shooting Percentage)
players_data['ts_pct'] = players_data['points'] / (
    2 * (players_data['points'] / players_data['fg_pct'] + 0.44 * players_data['points'] / players_data['ft_pct'])
).clip(lower=0.001)

# PER 근사값 (단순화)
players_data['per_approx'] = (
    players_data['points'] +
    players_data['rebounds'] * 1.2 +
    players_data['assists'] * 1.5 +
    players_data['steals'] * 2 +
    players_data['blocks'] * 2 -
    players_data['turnovers'] * 1.5
) / players_data['minutes'] * 15

# 급여 효율 (WAR per dollar)
players_data['value_score'] = players_data['per_approx'] / players_data['salary_million']

# 분석 리포트
print("=== NBA 선수 분석 리포트 ===\n")
print("포지션별 평균 스탯:")
pos_stats = players_data.groupby('position')[
    ['points', 'rebounds', 'assists', 'per_approx']
].mean().round(2)
print(pos_stats)

print("\n\n상위 10 가성비 선수 (per_approx / salary):")
top_value = players_data.nlargest(10, 'value_score')[
    ['player_name', 'team', 'position', 'points', 'per_approx', 'salary_million', 'value_score']
]
print(top_value.to_string(index=False))

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

# 다음 시즌 득점 예측 모델
features = ['age', 'minutes', 'fg_pct', 'three_pct', 'ft_pct',
            'rebounds', 'assists', 'turnovers', 'steals', 'blocks']
target = 'points'

X = players_data[features]
y = players_data[target]

model = RandomForestRegressor(n_estimators=100, random_state=42)
cv_scores = cross_val_score(model, X, y, cv=5, scoring='r2')

print(f"5-Fold CV R² 점수: {cv_scores.mean():.4f} (±{cv_scores.std():.4f})")

model.fit(X, y)

# 피처 중요도 시각화
importance_df = pd.DataFrame({
    'feature': features,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(importance_df['feature'], importance_df['importance'],
        color=plt.cm.RdYlGn(np.linspace(0.3, 0.9, len(features))))
ax.set_title('NBA 득점 예측 모델 - 피처 중요도')
ax.set_xlabel('상대적 중요도')
plt.tight_layout()
plt.show()