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

# Install: pip install pybaseball

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

pb.cache.enable()

# Fetch Statcast data for Shohei Ohtani (2023 season, pitcher ID)
ohtani_id = 660271
data = pb.statcast_pitcher(
    start_dt='2023-04-01',
    end_dt='2023-10-01',
    player_id=ohtani_id
)

print(f"Total pitches: {len(data)}")
print(data[['pitch_type', 'release_speed', 'release_spin_rate',
            'pfx_x', 'pfx_z']].describe())

# Visualize pitch speed and spin rate by pitch type
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("Ohtani Average Velocity by Pitch Type (mph)")
axes[0].set_xlabel("Pitch Type")
axes[0].set_ylabel("Velocity (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("Ohtani Average Spin Rate by Pitch Type (RPM)")
axes[1].set_xlabel("Pitch Type")
axes[1].set_ylabel("Spin Rate (RPM)")

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

# Pitch movement chart
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("Horizontal Movement (inches, catcher's view)")
    ax.set_ylabel("Vertical Movement (inches)")
    ax.set_title("Pitch Movement Chart")
    ax.legend(title="Pitch Type")
    plt.tight_layout()
    plt.show()

plot_pitch_movement(data)

Expected value of mid-range 2-pointer (45% rate): 0.45 * 2 = 0.90 pts
Expected value of corner 3-pointer (38% rate):    0.38 * 3 = 1.14 pts

# Install: 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

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 James career stats
lebron_id = get_player_id('LeBron James')
time.sleep(1)

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

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', 'Points', 'royalblue'),
    ('AST_PER_GAME', 'Assists', 'forestgreen'),
    ('REB_PER_GAME', 'Rebounds', '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'LeBron James — {label} Per Game by Season')
    ax.set_xlabel('Season')
    ax.set_ylabel(f'{label}/Game')
    ax.tick_params(axis='x', rotation=45)
    ax.grid(alpha=0.3)

plt.suptitle("LeBron James Career Stats Trajectory", fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

# 2022-23 season efficiency scatter
time.sleep(1)
season_stats = leaguedashplayerstats.LeagueDashPlayerStats(
    season='2022-23',
    per_mode_simple='PerGame'
)
df = season_stats.get_data_frames()[0]
df_filtered = df[df['MIN'] >= 500].copy()
df_filtered['eFG'] = (df_filtered['FGM'] + 0.5 * df_filtered['FG3M']) / df_filtered['FGA']

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='Minutes Played')
ax.set_xlabel('Effective FG% (eFG%)')
ax.set_ylabel('Points Per Game')
ax.set_title('2022-23 NBA: Points vs Efficiency (color = minutes)')

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 = Opponent Passes / (Tackles + Interceptions + Fouls + Challenges Won)

# Install: pip install statsbombpy mplsoccer

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

# Browse StatsBomb open data competitions
competitions = sb.competitions()
print(competitions[['competition_id', 'competition_name', 'season_name']].head(20))

# 2018 FIFA World Cup
matches = sb.matches(competition_id=43, season_id=3)

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()

# Shot map with xG bubble size
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'
            ax.scatter(y, x, s=xg * 1000, c=team_color,
                      marker=marker, alpha=0.7,
                      edgecolors='white', linewidths=0.5)
        except (KeyError, TypeError):
            pass

ax.set_title('2018 FIFA World Cup Final\nFrance vs Croatia — Shot Map\n(Size = xG, Star = Goal)',
             fontsize=12, pad=20)
plt.tight_layout()
plt.savefig('shot_map_final.png', dpi=150, bbox_inches='tight')
plt.show()

# xG over match time (momentum chart)
def plot_xg_timeline(events, home_team, away_team):
    shots_data = events[events['type'] == 'Shot'].copy()

    home_shots = shots_data[shots_data['team'] == home_team].copy()
    away_shots = shots_data[shots_data['team'] == away_team].copy()

    home_shots['xg_val'] = home_shots['shot'].apply(
        lambda x: x.get('statsbomb_xg', 0) if isinstance(x, dict) else 0
    )
    away_shots['xg_val'] = away_shots['shot'].apply(
        lambda x: x.get('statsbomb_xg', 0) if isinstance(x, dict) else 0
    )

    home_cumxg = home_shots.sort_values('minute')['xg_val'].cumsum()
    away_cumxg = away_shots.sort_values('minute')['xg_val'].cumsum()

    fig, ax = plt.subplots(figsize=(14, 5))
    ax.step(home_shots.sort_values('minute')['minute'], home_cumxg,
            color='#1f77b4', label=home_team, linewidth=2.5)
    ax.step(away_shots.sort_values('minute')['minute'], away_cumxg,
            color='#d62728', label=away_team, linewidth=2.5)
    ax.set_xlabel('Minute')
    ax.set_ylabel('Cumulative xG')
    ax.set_title(f'xG Timeline: {home_team} vs {away_team}')
    ax.legend()
    ax.grid(alpha=0.3)
    plt.tight_layout()
    plt.show()

plot_xg_timeline(events, 'France', 'Croatia')

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),
    'chronic_load': np.random.normal(400, 60, n_players),
    '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)
})

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)

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_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

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

y_pred = model.predict(X_test_s)
y_prob = model.predict_proba(X_test_s)[:, 1]

print(classification_report(y_test, y_pred))
print(f"ROC-AUC: {roc_auc_score(y_test, y_prob):.4f}")

import matplotlib.pyplot as plt
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='steelblue')
ax.set_title('Injury Prediction Model — Feature Importance')
ax.set_xlabel('Importance')
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):
    """
    Poisson distribution-based match outcome prediction.
    attack/defense indices: league average = 1.0
    lower defense index = stronger defense
    """
    league_avg_goals = 1.35  # EPL season average goals per team per match

    home_exp = home_attack * away_defense * league_avg_goals * home_advantage
    away_exp = away_attack * home_defense * league_avg_goals

    max_goals = 10
    home_win = draw = away_win = 0

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

    return {
        'home_goals_expected': round(home_exp, 2),
        'away_goals_expected': round(away_exp, 2),
        'home_win_prob': round(home_win, 3),
        'draw_prob': round(draw, 3),
        'away_win_prob': round(away_win, 3)
    }

# Manchester City vs Arsenal example
result = predict_match(
    home_attack=1.4, home_defense=0.7,
    away_attack=1.3, away_defense=0.75
)
print("Manchester City vs Arsenal:")
for k, v in result.items():
    print(f"  {k}: {v}")

import pandas as pd
import numpy as np

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)
})

# Approximate 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

players_data['value_score'] = players_data['per_approx'] / players_data['salary_million']

print("Average stats by position:")
pos_stats = players_data.groupby('position')[
    ['points', 'rebounds', 'assists', 'per_approx']
].mean().round(2)
print(pos_stats)

print("\nTop 10 value players (PER / 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 Scoring Prediction Model — Feature Importance')
ax.set_xlabel('Relative Importance')
plt.tight_layout()
plt.show()