Data Analysis Examples

Python Example: Fetching BPM Data with nba_api

"""
Fetch and analyze Box Plus/Minus (BPM) data using nba_api
Install: pip install nba_api pandas matplotlib seaborn
"""

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

# Set style for visualizations
sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (12, 8)

def get_season_bpm_leaders(season='2023-24', min_minutes=500):
    """
    Fetch BPM leaders for a given season

    Args:
        season: NBA season (e.g., '2023-24')
        min_minutes: Minimum minutes played filter

    Returns:
        DataFrame with player BPM statistics
    """
    # Fetch advanced player stats
    stats = leaguedashplayerstats.LeagueDashPlayerStats(
        season=season,
        measure_type_detailed_defense='Advanced',
        per_mode_detailed='PerGame'
    )

    df = stats.get_data_frames()[0]

    # Filter by minutes and select relevant columns
    df_filtered = df[df['MIN'] >= min_minutes].copy()

    # Sort by BPM (if available) or create proxy
    # Note: nba_api doesn't directly provide BPM, so we'll fetch from Basketball Reference
    # This is a simplified example

    columns = ['PLAYER_NAME', 'TEAM_ABBREVIATION', 'GP', 'MIN',
               'PTS', 'REB', 'AST', 'STL', 'BLK', 'TOV', 'NET_RATING']

    df_filtered = df_filtered[columns].sort_values('NET_RATING', ascending=False)

    return df_filtered.head(20)


def analyze_player_bpm_trend(player_name):
    """
    Analyze a player's BPM trend across their career

    Args:
        player_name: Full name of the player
    """
    # Find player
    player_dict = players.find_players_by_full_name(player_name)

    if not player_dict:
        print(f"Player '{player_name}' not found")
        return

    player_id = player_dict[0]['id']

    # Get career stats
    career = playercareerstats.PlayerCareerStats(player_id=player_id)
    df = career.get_data_frames()[0]

    # Calculate basic BPM proxy (simplified)
    df['BPM_PROXY'] = (
        (df['PTS'] * 0.35) +
        (df['AST'] * 0.8) +
        (df['REB'] * 0.4) +
        (df['STL'] * 1.2) +
        (df['BLK'] * 1.0) -
        (df['TOV'] * 0.9)
    ) / df['GP']

    return df[['SEASON_ID', 'TEAM_ABBREVIATION', 'GP', 'MIN', 'BPM_PROXY']]


def visualize_bpm_distribution(season='2023-24'):
    """
    Create a distribution plot of player BPM values
    """
    # Fetch data (using NET_RATING as proxy)
    stats = leaguedashplayerstats.LeagueDashPlayerStats(
        season=season,
        measure_type_detailed_defense='Advanced'
    )

    df = stats.get_data_frames()[0]
    df_filtered = df[df['MIN'] >= 500].copy()

    # Create distribution plot
    fig, axes = plt.subplots(1, 2, figsize=(14, 6))

    # Histogram
    axes[0].hist(df_filtered['NET_RATING'], bins=30, edgecolor='black', alpha=0.7)
    axes[0].axvline(0, color='red', linestyle='--', linewidth=2, label='League Average')
    axes[0].set_xlabel('Net Rating (BPM Proxy)', fontsize=12)
    axes[0].set_ylabel('Number of Players', fontsize=12)
    axes[0].set_title(f'Distribution of Player Impact ({season})', fontsize=14, fontweight='bold')
    axes[0].legend()
    axes[0].grid(True, alpha=0.3)

    # Box plot by position
    # Note: Position data would need to be added
    axes[1].boxplot([df_filtered['NET_RATING']], labels=['All Players'])
    axes[1].axhline(0, color='red', linestyle='--', linewidth=2)
    axes[1].set_ylabel('Net Rating', fontsize=12)
    axes[1].set_title('Net Rating Distribution', fontsize=14, fontweight='bold')
    axes[1].grid(True, alpha=0.3)

    plt.tight_layout()
    plt.savefig('bpm_distribution.png', dpi=300, bbox_inches='tight')
    plt.show()


def compare_obpm_dbpm(player_names):
    """
    Compare offensive vs defensive impact for multiple players
    (Requires additional data source with OBPM/DBPM splits)
    """
    # This would require Basketball Reference scraping or alternative API
    # Placeholder for demonstration

    data = {
        'Player': player_names,
        'OBPM': [7.5, 6.2, 4.8, 5.1, 3.9],  # Example data
        'DBPM': [2.1, 3.5, -0.5, 1.2, 2.8]
    }

    df = pd.DataFrame(data)
    df['BPM'] = df['OBPM'] + df['DBPM']

    # Create stacked bar chart
    fig, ax = plt.subplots(figsize=(12, 6))

    x = range(len(df))
    width = 0.6

    ax.bar(x, df['OBPM'], width, label='OBPM', color='#1f77b4', alpha=0.8)
    ax.bar(x, df['DBPM'], width, bottom=df['OBPM'], label='DBPM', color='#ff7f0e', alpha=0.8)

    ax.set_ylabel('Box Plus/Minus', fontsize=12)
    ax.set_title('OBPM vs DBPM Comparison', fontsize=14, fontweight='bold')
    ax.set_xticks(x)
    ax.set_xticklabels(df['Player'], rotation=45, ha='right')
    ax.axhline(0, color='black', linewidth=0.8)
    ax.legend()
    ax.grid(True, axis='y', alpha=0.3)

    plt.tight_layout()
    plt.savefig('obpm_dbpm_comparison.png', dpi=300, bbox_inches='tight')
    plt.show()


def calculate_vorp(bpm, minutes_played, team_games=82):
    """
    Calculate Value Over Replacement Player

    Args:
        bpm: Player's Box Plus/Minus
        minutes_played: Total minutes played
        team_games: Number of team games (default 82)

    Returns:
        VORP value
    """
    replacement_level = -2.0
    team_minutes = team_games * 48 * 5  # Total team minutes available

    vorp = (bpm - replacement_level) * (minutes_played / team_minutes)

    return vorp


# Example usage
if __name__ == "__main__":
    # Fetch season leaders
    print("Fetching 2023-24 season leaders...")
    leaders = get_season_bpm_leaders('2023-24', min_minutes=1000)
    print(leaders)

    # Analyze specific player
    print("\nAnalyzing LeBron James career trend...")
    lebron_career = analyze_player_bpm_trend("LeBron James")
    print(lebron_career)

    # Calculate VORP example
    player_bpm = 8.5
    player_minutes = 2500
    vorp = calculate_vorp(player_bpm, player_minutes)
    print(f"\nPlayer VORP: {vorp:.2f}")

    # Create visualizations
    print("\nGenerating visualizations...")
    visualize_bpm_distribution('2023-24')

    top_players = ['Nikola Jokić', 'Giannis Antetokounmpo', 'Luka Dončić',
                   'Joel Embiid', 'Shai Gilgeous-Alexander']
    compare_obpm_dbpm(top_players)

    print("\nAnalysis complete!")

R Example: BPM Analysis with hoopR

# Box Plus/Minus Analysis using hoopR and tidyverse
# Install: install.packages(c("hoopR", "tidyverse", "ggplot2", "scales"))

library(hoopR)
library(tidyverse)
library(ggplot2)
library(scales)

# Set theme for visualizations
theme_set(theme_minimal())

#' Fetch NBA advanced player statistics
#'
#' @param season Season year (e.g., 2024)
#' @return Tibble with player statistics
get_advanced_stats <- function(season = 2024) {
  # Fetch player box scores
  stats <- nba_leaguedashplayerstats(
    season = season,
    measure_type = "Advanced"
  )

  # Clean and process data
  df <- stats %>%
    mutate(
      MIN = as.numeric(MIN),
      NET_RATING = as.numeric(NET_RATING),
      OFF_RATING = as.numeric(OFF_RATING),
      DEF_RATING = as.numeric(DEF_RATING)
    ) %>%
    filter(MIN >= 500)  # Minimum minutes filter

  return(df)
}


#' Calculate VORP from BPM and minutes
#'
#' @param bpm Box Plus/Minus value
#' @param minutes Minutes played
#' @param team_games Number of team games (default 82)
#' @return VORP value
calculate_vorp <- function(bpm, minutes, team_games = 82) {
  replacement_level <- -2.0
  team_minutes <- team_games * 48 * 5

  vorp <- (bpm - replacement_level) * (minutes / team_minutes)

  return(vorp)
}


#' Get BPM interpretation label
#'
#' @param bpm BPM value
#' @return Character string with rating
interpret_bpm <- function(bpm) {
  case_when(
    bpm >= 10 ~ "MVP Level",
    bpm >= 8 ~ "Elite",
    bpm >= 6 ~ "All-Star",
    bpm >= 4 ~ "Very Good Starter",
    bpm >= 2 ~ "Good Starter",
    bpm >= 0 ~ "Average/Rotation",
    bpm >= -2 ~ "Below Average",
    TRUE ~ "Poor"
  )
}


#' Visualize BPM distribution
#'
#' @param df Data frame with player statistics
visualize_bpm_distribution <- function(df) {
  # Use NET_RATING as BPM proxy
  p <- ggplot(df, aes(x = NET_RATING)) +
    geom_histogram(bins = 30, fill = "#1f77b4", color = "black", alpha = 0.7) +
    geom_vline(xintercept = 0, color = "red", linetype = "dashed", size = 1.2) +
    annotate("text", x = 0, y = Inf, label = "League Average",
             vjust = 2, hjust = -0.1, color = "red", size = 4) +
    labs(
      title = "Distribution of Player Box Plus/Minus",
      subtitle = "Minimum 500 minutes played",
      x = "Net Rating (BPM Proxy)",
      y = "Number of Players"
    ) +
    theme(
      plot.title = element_text(size = 16, face = "bold"),
      plot.subtitle = element_text(size = 12, color = "gray40")
    )

  print(p)
  ggsave("bpm_distribution.png", p, width = 10, height = 6, dpi = 300)

  return(p)
}


#' Compare OBPM vs DBPM for top players
#'
#' @param player_data Data frame with OBPM and DBPM columns
visualize_obpm_dbpm <- function(player_data) {
  # Reshape data for stacked bar chart
  df_long <- player_data %>%
    pivot_longer(
      cols = c(OBPM, DBPM),
      names_to = "Component",
      values_to = "Value"
    )

  p <- ggplot(df_long, aes(x = reorder(PLAYER_NAME, -BPM), y = Value, fill = Component)) +
    geom_col(position = "stack", alpha = 0.8) +
    geom_hline(yintercept = 0, color = "black", size = 0.8) +
    scale_fill_manual(
      values = c("OBPM" = "#1f77b4", "DBPM" = "#ff7f0e"),
      labels = c("OBPM" = "Offensive BPM", "DBPM" = "Defensive BPM")
    ) +
    labs(
      title = "Offensive vs Defensive Box Plus/Minus",
      subtitle = "Top Players 2023-24 Season",
      x = "",
      y = "Box Plus/Minus",
      fill = ""
    ) +
    theme(
      axis.text.x = element_text(angle = 45, hjust = 1, size = 10),
      plot.title = element_text(size = 16, face = "bold"),
      legend.position = "top"
    )

  print(p)
  ggsave("obpm_dbpm_comparison.png", p, width = 12, height = 7, dpi = 300)

  return(p)
}


#' Plot BPM vs VORP relationship
#'
#' @param df Data frame with BPM and VORP
plot_bpm_vorp <- function(df) {
  p <- ggplot(df, aes(x = BPM, y = VORP)) +
    geom_point(aes(size = MIN, color = BPM), alpha = 0.6) +
    geom_smooth(method = "lm", color = "red", linetype = "dashed") +
    scale_color_gradient2(
      low = "#d73027", mid = "#ffffbf", high = "#1a9850",
      midpoint = 0, name = "BPM"
    ) +
    scale_size_continuous(name = "Minutes", range = c(2, 10)) +
    labs(
      title = "Box Plus/Minus vs Value Over Replacement Player",
      subtitle = "Size represents minutes played",
      x = "Box Plus/Minus (BPM)",
      y = "Value Over Replacement Player (VORP)"
    ) +
    theme(
      plot.title = element_text(size = 16, face = "bold"),
      legend.position = "right"
    )

  print(p)
  ggsave("bpm_vorp_relationship.png", p, width = 10, height = 7, dpi = 300)

  return(p)
}


#' Create BPM leaderboard table
#'
#' @param df Player statistics data frame
#' @param top_n Number of top players to show
create_bpm_leaderboard <- function(df, top_n = 20) {
  leaderboard <- df %>%
    arrange(desc(NET_RATING)) %>%
    head(top_n) %>%
    mutate(
      Rank = row_number(),
      Rating = interpret_bpm(NET_RATING),
      VORP = calculate_vorp(NET_RATING, MIN)
    ) %>%
    select(
      Rank, PLAYER_NAME, TEAM_ABBREVIATION, GP, MIN,
      BPM = NET_RATING, Rating, VORP
    )

  return(leaderboard)
}


#' Historical comparison plot
#'
#' @param player_seasons Data frame with player seasons
plot_career_bpm_trend <- function(player_seasons) {
  p <- ggplot(player_seasons, aes(x = SEASON, y = BPM, group = PLAYER_NAME, color = PLAYER_NAME)) +
    geom_line(size = 1.2) +
    geom_point(size = 3) +
    geom_hline(yintercept = 0, linetype = "dashed", color = "gray50") +
    geom_hline(yintercept = c(6, 10), linetype = "dotted", color = "gray70") +
    annotate("text", x = -Inf, y = 10, label = "MVP Level",
             hjust = -0.1, vjust = -0.5, color = "gray50", size = 3) +
    annotate("text", x = -Inf, y = 6, label = "All-Star",
             hjust = -0.1, vjust = -0.5, color = "gray50", size = 3) +
    labs(
      title = "Career BPM Trajectory",
      subtitle = "Comparing elite players across seasons",
      x = "Season",
      y = "Box Plus/Minus",
      color = "Player"
    ) +
    theme(
      axis.text.x = element_text(angle = 45, hjust = 1),
      plot.title = element_text(size = 16, face = "bold"),
      legend.position = "bottom"
    )

  print(p)
  ggsave("career_bpm_trend.png", p, width = 12, height = 7, dpi = 300)

  return(p)
}


# Example usage
main <- function() {
  cat("Fetching NBA advanced statistics...\n")

  # Get current season data
  stats_df <- get_advanced_stats(season = 2024)

  # Create leaderboard
  cat("\nGenerating BPM leaderboard...\n")
  leaderboard <- create_bpm_leaderboard(stats_df, top_n = 15)
  print(leaderboard)

  # Visualizations
  cat("\nCreating visualizations...\n")
  visualize_bpm_distribution(stats_df)

  # Example data for OBPM/DBPM comparison
  top_players <- tibble(
    PLAYER_NAME = c("Nikola Jokić", "Giannis Antetokounmpo", "Luka Dončić",
                    "Joel Embiid", "Shai Gilgeous-Alexander"),
    OBPM = c(9.3, 6.8, 7.2, 6.5, 7.0),
    DBPM = c(1.4, 3.2, -0.5, 1.8, 2.1),
    BPM = c(10.7, 10.0, 6.7, 8.3, 9.1)
  )

  visualize_obpm_dbpm(top_players)

  # Calculate VORP for leaderboard
  stats_with_vorp <- stats_df %>%
    mutate(VORP = calculate_vorp(NET_RATING, MIN))

  plot_bpm_vorp(stats_with_vorp)

  cat("\nAnalysis complete! Visualizations saved.\n")

  return(list(
    stats = stats_df,
    leaderboard = leaderboard,
    vorp_data = stats_with_vorp
  ))
}

# Run analysis
results <- main()