R and Python for Baseball Analytics

R & Python for Baseball Analytics

The twin pillars of modern baseball analytics are R and Python—two programming languages that have become indispensable tools for anyone seeking to extract insights from baseball data. While traditional spreadsheet applications can handle basic statistical calculations, the complexity and volume of modern baseball data demands more powerful tools capable of sophisticated statistical modeling, machine learning, and automated data pipelines.

R emerged from the statistics community and excels at statistical analysis and visualization, with packages like baseballr providing direct access to Statcast and FanGraphs data. Python, born from the software engineering world, offers superior data manipulation capabilities and integrates seamlessly with machine learning frameworks. Most professional baseball analysts become proficient in both languages, leveraging each for its strengths while building analytical workflows that combine the best of both worlds.

Understanding the Analytics Ecosystem

Setting up a productive baseball analytics environment requires understanding the ecosystem of libraries, packages, and tools available in each language. In Python, the foundation consists of pandas for data manipulation, numpy for numerical computing, and matplotlib/seaborn for visualization. The pybaseball library then provides the baseball-specific functionality, wrapping APIs to Baseball Savant, FanGraphs, and Baseball Reference into convenient Python functions.

The R ecosystem centers around the tidyverse—a collection of packages including dplyr, ggplot2, and tidyr that share a common philosophy of tidy data principles. The baseballr package mirrors pybaseball's functionality, while Lahman provides direct access to the historical baseball database. For statistical modeling, R's rich ecosystem of packages for regression, time series analysis, and Bayesian inference gives it an edge in certain analytical applications.

Key Components

• pybaseball (Python): Comprehensive library for accessing Statcast, FanGraphs, and Baseball Reference data with functions for player lookups, leaderboards, and pitch-level data
• baseballr (R): R equivalent to pybaseball, providing Statcast scraping, FanGraphs integration, and MLB stats API access
• pandas/tidyverse: Data manipulation frameworks that form the backbone of data cleaning, transformation, and aggregation workflows
• Lahman (R/Python): Historical database package with batting, pitching, fielding, and biographical data from 1871 to present
• matplotlib/ggplot2: Visualization libraries for creating publication-quality charts, spray charts, and statistical graphics
• scikit-learn/caret: Machine learning frameworks for predictive modeling, player projections, and classification tasks

Environment Setup

Using virtual environments (conda/venv for Python, renv for R) ensures reproducible analyses and prevents package conflicts. Both languages benefit from using integrated development environments—Jupyter notebooks for Python exploration and RStudio for R development.

Python Implementation

"""
Baseball Analytics Environment Setup and Validation
Complete Python setup for baseball data analysis
"""

import sys
import warnings
warnings.filterwarnings('ignore')

# ============================================
# Package Installation Verification
# ============================================

def check_packages():
    """Verify all required packages are installed."""
    required_packages = {
        'pandas': 'Data manipulation',
        'numpy': 'Numerical computing',
        'matplotlib': 'Basic visualization',
        'seaborn': 'Statistical visualization',
        'pybaseball': 'Baseball data access',
        'sklearn': 'Machine learning'
    }

    missing = []
    for package, description in required_packages.items():
        try:
            __import__(package)
            print(f"✓ {package}: {description}")
        except ImportError:
            missing.append(package)
            print(f"✗ {package}: {description} - MISSING")

    if missing:
        print(f"\nInstall missing packages: pip install {' '.join(missing)}")
    return len(missing) == 0

# ============================================
# Core Analytics Functions
# ============================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from pybaseball import statcast, playerid_lookup, statcast_batter

class BaseballAnalytics:
    """
    Core analytics class for baseball data analysis.
    Provides methods for data retrieval, processing, and visualization.
    """

    def __init__(self):
        self.data_cache = {}
        self.setup_plotting()

    def setup_plotting(self):
        """Configure matplotlib for baseball visualizations."""
        plt.style.use('seaborn-v0_8-whitegrid')
        plt.rcParams['figure.figsize'] = (10, 6)
        plt.rcParams['font.size'] = 11
        plt.rcParams['axes.titlesize'] = 14
        plt.rcParams['axes.labelsize'] = 12

    def get_batter_data(self, player_name, season):
        """
        Retrieve and cache Statcast data for a batter.

        Parameters:
        -----------
        player_name : str
            Player name in "First Last" format
        season : int
            MLB season year

        Returns:
        --------
        DataFrame with pitch-level data
        """
        cache_key = f"{player_name}_{season}"

        if cache_key in self.data_cache:
            return self.data_cache[cache_key]

        # Look up player ID
        name_parts = player_name.split()
        lookup = playerid_lookup(name_parts[-1], name_parts[0])

        if lookup.empty:
            raise ValueError(f"Player not found: {player_name}")

        player_id = lookup.iloc[0]['key_mlbam']

        # Fetch Statcast data
        data = statcast_batter(
            start_dt=f"{season}-03-01",
            end_dt=f"{season}-11-30",
            player_id=player_id
        )

        self.data_cache[cache_key] = data
        return data

    def calculate_batting_metrics(self, df):
        """
        Calculate advanced batting metrics from Statcast data.

        Parameters:
        -----------
        df : DataFrame
            Statcast pitch-level data

        Returns:
        --------
        dict with calculated metrics
        """
        # Filter to batted balls
        batted = df[df['type'] == 'X'].copy()

        if len(batted) == 0:
            return {}

        metrics = {
            'avg_exit_velo': batted['launch_speed'].mean(),
            'avg_launch_angle': batted['launch_angle'].mean(),
            'hard_hit_rate': (batted['launch_speed'] >= 95).mean() * 100,
            'barrel_rate': (batted['launch_speed_angle'] == 6).mean() * 100,
            'sweet_spot_rate': batted['launch_angle'].between(8, 32).mean() * 100,
            'groundball_rate': (batted['launch_angle'] < 10).mean() * 100,
            'flyball_rate': (batted['launch_angle'] >= 25).mean() * 100,
            'batted_balls': len(batted)
        }

        return {k: round(v, 1) if isinstance(v, float) else v
                for k, v in metrics.items()}

    def create_spray_chart(self, df, title="Spray Chart"):
        """
        Generate a spray chart visualization.

        Parameters:
        -----------
        df : DataFrame
            Statcast data with hc_x and hc_y columns
        title : str
            Chart title
        """
        batted = df[df['type'] == 'X'].dropna(subset=['hc_x', 'hc_y'])

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

        # Color by hit result
        colors = {
            'single': 'green',
            'double': 'blue',
            'triple': 'purple',
            'home_run': 'red',
            'field_out': 'gray',
            'force_out': 'gray',
            'grounded_into_double_play': 'black'
        }

        for event, color in colors.items():
            subset = batted[batted['events'] == event]
            ax.scatter(
                subset['hc_x'],
                subset['hc_y'],
                c=color,
                alpha=0.6,
                label=event.replace('_', ' ').title(),
                s=50
            )

        # Draw field outline
        ax.set_xlim(0, 250)
        ax.set_ylim(0, 250)
        ax.set_aspect('equal')
        ax.set_title(title)
        ax.legend(loc='upper right')

        plt.tight_layout()
        return fig, ax

    def analyze_pitch_discipline(self, df):
        """
        Analyze a batter's plate discipline.

        Parameters:
        -----------
        df : DataFrame
            Statcast pitch-level data

        Returns:
        --------
        dict with discipline metrics
        """
        total_pitches = len(df)

        # Define zone (simplified strike zone)
        in_zone = (
            (df['plate_x'].between(-0.83, 0.83)) &
            (df['plate_z'].between(1.5, 3.5))
        )

        swings = df['description'].isin([
            'hit_into_play', 'foul', 'swinging_strike',
            'swinging_strike_blocked', 'foul_tip'
        ])

        metrics = {
            'zone_rate': in_zone.mean() * 100,
            'swing_rate': swings.mean() * 100,
            'zone_swing_rate': (swings & in_zone).sum() / in_zone.sum() * 100,
            'chase_rate': (swings & ~in_zone).sum() / (~in_zone).sum() * 100,
            'whiff_rate': df['description'].isin(['swinging_strike', 'swinging_strike_blocked']).sum() / swings.sum() * 100,
            'contact_rate': df['description'].isin(['hit_into_play', 'foul', 'foul_tip']).sum() / swings.sum() * 100
        }

        return {k: round(v, 1) for k, v in metrics.items()}


# Example usage
if __name__ == "__main__":
    print("Checking package installation...")
    if check_packages():
        print("\nAll packages installed successfully!")

        # Initialize analytics
        analytics = BaseballAnalytics()

        # Example: Analyze a player
        print("\nFetching data for example player...")
        try:
            data = analytics.get_batter_data("Shohei Ohtani", 2023)

            print(f"\nRetrieved {len(data)} pitches seen")

            metrics = analytics.calculate_batting_metrics(data)
            print("\nBatting Metrics:")
            for key, value in metrics.items():
                print(f"  {key}: {value}")

            discipline = analytics.analyze_pitch_discipline(data)
            print("\nPlate Discipline:")
            for key, value in discipline.items():
                print(f"  {key}: {value}%")

        except Exception as e:
            print(f"Error fetching data: {e}")
    

R Implementation

# ============================================
# Baseball Analytics Environment Setup for R
# ============================================

# Package Installation and Loading
# ============================================

#' Install required packages if not present
install_if_missing <- function(packages) {
  new_packages <- packages[!(packages %in% installed.packages()[,"Package"])]
  if(length(new_packages)) {
    install.packages(new_packages, repos = "https://cran.rstudio.com/")
  }
}

required_packages <- c(
  "tidyverse",    # Data manipulation and visualization
  "baseballr",    # Baseball data access
  "Lahman",       # Historical baseball database
  "ggplot2",      # Advanced visualization
  "scales",       # Plot scaling
  "viridis",      # Color palettes
  "patchwork"     # Plot composition
)

install_if_missing(required_packages)

# Load packages
library(tidyverse)
library(baseballr)
library(Lahman)
library(ggplot2)
library(scales)
library(viridis)

# ============================================
# Core Analytics Functions
# ============================================

#' Get Statcast batting data for a player
#'
#' @param player_name Character, "First Last" format
#' @param season Integer, MLB season year
#' @return Data frame with pitch-level data
get_batter_statcast <- function(player_name, season) {

  # Parse player name
  name_parts <- str_split(player_name, " ")[[1]]
  first_name <- name_parts[1]
  last_name <- paste(name_parts[-1], collapse = " ")

  # Look up player ID
  player_info <- playerid_lookup(last_name, first_name)

  if(nrow(player_info) == 0) {
    stop(paste("Player not found:", player_name))
  }

  mlbam_id <- player_info$key_mlbam[1]

  # Fetch Statcast data
  data <- scrape_statcast_savant(
    start_date = paste0(season, "-03-01"),
    end_date = paste0(season, "-11-30"),
    playerid = mlbam_id,
    player_type = "batter"
  )

  return(data)
}

#' Calculate advanced batting metrics
#'
#' @param df Data frame with Statcast data
#' @return Named list of metrics
calculate_batting_metrics <- function(df) {

  # Filter to batted balls
  batted <- df %>%
    filter(type == "X") %>%
    filter(!is.na(launch_speed), !is.na(launch_angle))

  if(nrow(batted) == 0) {
    return(list())
  }

  metrics <- list(
    avg_exit_velo = mean(batted$launch_speed, na.rm = TRUE),
    avg_launch_angle = mean(batted$launch_angle, na.rm = TRUE),
    hard_hit_rate = mean(batted$launch_speed >= 95, na.rm = TRUE) * 100,
    barrel_rate = mean(batted$launch_speed_angle == 6, na.rm = TRUE) * 100,
    sweet_spot_rate = mean(batted$launch_angle >= 8 & batted$launch_angle <= 32, na.rm = TRUE) * 100,
    groundball_rate = mean(batted$launch_angle < 10, na.rm = TRUE) * 100,
    flyball_rate = mean(batted$launch_angle >= 25, na.rm = TRUE) * 100,
    batted_balls = nrow(batted)
  )

  # Round numeric values
  metrics <- lapply(metrics, function(x) {
    if(is.numeric(x) && x != round(x)) round(x, 1) else x
  })

  return(metrics)
}

#' Create a spray chart visualization
#'
#' @param df Data frame with hc_x and hc_y columns
#' @param title Character, chart title
#' @return ggplot object
create_spray_chart <- function(df, title = "Spray Chart") {

  batted <- df %>%
    filter(type == "X") %>%
    filter(!is.na(hc_x), !is.na(hc_y))

  # Create base plot
  p <- ggplot(batted, aes(x = hc_x, y = hc_y, color = events)) +
    geom_point(alpha = 0.6, size = 2) +
    scale_color_viridis_d(option = "plasma") +
    coord_fixed() +
    labs(
      title = title,
      x = "Horizontal Position",
      y = "Vertical Position",
      color = "Outcome"
    ) +
    theme_minimal() +
    theme(
      legend.position = "right",
      plot.title = element_text(hjust = 0.5, size = 14, face = "bold")
    )

  return(p)
}

#' Analyze plate discipline metrics
#'
#' @param df Data frame with Statcast pitch data
#' @return Named list of discipline metrics
analyze_plate_discipline <- function(df) {

  # Define strike zone
  df <- df %>%
    mutate(
      in_zone = plate_x >= -0.83 & plate_x <= 0.83 &
                plate_z >= 1.5 & plate_z <= 3.5,
      swing = description %in% c(
        "hit_into_play", "foul", "swinging_strike",
        "swinging_strike_blocked", "foul_tip"
      ),
      whiff = description %in% c("swinging_strike", "swinging_strike_blocked"),
      contact = description %in% c("hit_into_play", "foul", "foul_tip")
    )

  metrics <- list(
    zone_rate = mean(df$in_zone, na.rm = TRUE) * 100,
    swing_rate = mean(df$swing, na.rm = TRUE) * 100,
    zone_swing_rate = sum(df$swing & df$in_zone, na.rm = TRUE) /
                      sum(df$in_zone, na.rm = TRUE) * 100,
    chase_rate = sum(df$swing & !df$in_zone, na.rm = TRUE) /
                 sum(!df$in_zone, na.rm = TRUE) * 100,
    whiff_rate = sum(df$whiff, na.rm = TRUE) / sum(df$swing, na.rm = TRUE) * 100,
    contact_rate = sum(df$contact, na.rm = TRUE) / sum(df$swing, na.rm = TRUE) * 100
  )

  return(lapply(metrics, round, 1))
}

#' Create pitch location heatmap
#'
#' @param df Data frame with plate_x and plate_z columns
#' @param title Character, chart title
#' @return ggplot object
create_pitch_heatmap <- function(df, title = "Pitch Location Heatmap") {

  p <- ggplot(df, aes(x = plate_x, y = plate_z)) +
    stat_density_2d(
      aes(fill = after_stat(density)),
      geom = "raster",
      contour = FALSE
    ) +
    scale_fill_viridis_c(option = "plasma") +
    # Draw strike zone
    geom_rect(
      aes(xmin = -0.83, xmax = 0.83, ymin = 1.5, ymax = 3.5),
      fill = NA, color = "white", linewidth = 1
    ) +
    coord_fixed(xlim = c(-2, 2), ylim = c(0, 5)) +
    labs(
      title = title,
      x = "Horizontal Position (ft)",
      y = "Vertical Position (ft)",
      fill = "Density"
    ) +
    theme_dark() +
    theme(
      plot.title = element_text(hjust = 0.5, color = "white"),
      axis.title = element_text(color = "white"),
      axis.text = element_text(color = "white")
    )

  return(p)
}

# ============================================
# Example Usage
# ============================================

cat("Baseball Analytics R Environment\n")
cat("================================\n\n")

# Check package versions
cat("Loaded packages:\n")
cat(paste(" - tidyverse:", packageVersion("tidyverse"), "\n"))
cat(paste(" - baseballr:", packageVersion("baseballr"), "\n"))
cat(paste(" - Lahman:", packageVersion("Lahman"), "\n"))

# Example analysis with Lahman database
cat("\n\nExample: Top Career Home Run Hitters\n")
cat("-------------------------------------\n")

career_hr <- Batting %>%
  group_by(playerID) %>%
  summarize(
    career_HR = sum(HR, na.rm = TRUE),
    seasons = n_distinct(yearID),
    .groups = "drop"
  ) %>%
  left_join(
    People %>% select(playerID, nameFirst, nameLast),
    by = "playerID"
  ) %>%
  mutate(name = paste(nameFirst, nameLast)) %>%
  arrange(desc(career_HR)) %>%
  head(10)

print(career_hr %>% select(name, career_HR, seasons))
    

Real-World Application

The Tampa Bay Rays exemplify how smaller-market teams leverage R and Python to compete with larger payrolls. Their analytics department has developed proprietary models in both languages that identify market inefficiencies—players whose skills are undervalued by traditional metrics. The Rays' consistent success despite bottom-third payrolls demonstrates the competitive advantage gained through sophisticated data analysis.

Beyond front offices, R and Python have democratized baseball analysis for researchers and fans. Websites like FanGraphs Community and Baseball Prospectus feature analyses produced using these tools, while academic journals publish peer-reviewed research built on open-source baseball packages. The availability of these tools has created a generation of analysts who developed their skills outside traditional baseball organizations, many of whom have subsequently been hired by MLB teams.

Interpreting Output Quality

Key Takeaways

• Both R and Python are essential tools for modern baseball analytics—learning both provides maximum flexibility and capability
• pybaseball (Python) and baseballr (R) provide equivalent access to Statcast and major baseball data sources
• R excels at statistical analysis and publication-quality visualizations, while Python offers superior machine learning integration and production deployment
• Setting up proper virtual environments ensures reproducible analyses and prevents dependency conflicts
• The open-source nature of these tools has democratized baseball analytics, enabling anyone to perform professional-level analysis