Baseball Statistics Fundamentals

Introduction

Baseball statistics represent the foundation of how we understand, analyze, and appreciate America's pastime. Since the game's inception in the mid-19th century, numbers have been inextricably linked to baseball's identity, transforming it into perhaps the most statistically rich sport in existence. From casual fans debating a player's batting average to front office executives making multi-million dollar decisions, baseball statistics serve as the universal language through which performance is measured, compared, and valued.

The fundamental statistics—batting average, earned run average, on-base percentage, slugging percentage, and others—form the bedrock upon which all modern baseball analysis is built. These metrics emerged organically throughout baseball's history, each addressing specific questions about player performance. Batting average, first calculated in the 1870s, quantified a hitter's consistency. Earned run average, developed shortly thereafter, provided a standardized measure of pitcher effectiveness. As the game evolved, so did our statistical understanding, with on-base percentage and slugging percentage emerging to capture dimensions of offense that batting average alone couldn't reveal.

Understanding these fundamental statistics is essential for anyone seeking to engage meaningfully with baseball. They provide context for evaluating individual performances, comparing players across different eras, and appreciating the strategic nuances that unfold during each game. A .300 batting average has long been considered the hallmark of an elite hitter, while a 3.00 ERA signifies excellent pitching. These benchmarks, established over more than a century of play, create a shared framework for discussion and analysis that transcends generational and geographic boundaries.

Moreover, fundamental baseball statistics serve as the gateway to more advanced analytics. Modern metrics like WAR (Wins Above Replacement), wRC+ (weighted Runs Created Plus), and FIP (Fielding Independent Pitching) are all built upon the traditional statistics we'll explore in this tutorial. By mastering the fundamentals—understanding not just what these numbers are, but how they're calculated, what they measure, and what their limitations are—you'll develop the analytical foundation necessary to engage with baseball at any level of sophistication. Whether you're a fantasy baseball enthusiast, an aspiring analyst, or simply a fan seeking deeper appreciation of the game, these fundamental statistics are your essential starting point.

Understanding Baseball Statistics

Baseball statistics can be broadly categorized into offensive and pitching metrics, each designed to isolate and quantify specific aspects of performance. The beauty of these fundamental statistics lies in their elegant simplicity: they reduce complex on-field events into comparable numerical values that facilitate objective evaluation. However, beneath this simplicity lies considerable nuance that every serious student of the game must understand.

Offensive statistics primarily measure a batter's ability to reach base and advance runners. Batting average (AVG) represents the most traditional measure—simply the ratio of hits to at-bats. While intuitive, batting average treats all hits equally, whether a bloop single or a towering home run. This limitation led to the development of slugging percentage (SLG), which weights hits by the number of bases earned, and on-base percentage (OBP), which credits batters for all the ways they reach base, including walks and hit-by-pitches. The combination of these metrics provides a more complete picture of offensive contribution than any single statistic alone.

Pitching statistics operate on a different principle, focusing on outcomes the pitcher can largely control. Earned run average (ERA) has been the gold standard for pitcher evaluation since the early 20th century, measuring the number of earned runs a pitcher allows per nine innings. WHIP (Walks plus Hits per Innings Pitched) offers a complementary view, quantifying baserunners allowed. Strikeout and walk rates (K/9 and BB/9) further refine our understanding by isolating specific skills within the pitcher's control.

The critical insight for understanding baseball statistics is recognizing what each metric measures and, equally important, what it doesn't measure. Context matters enormously: a pitcher's ERA can be inflated by poor defensive support, while a batter's average might be suppressed by an unfavorable home ballpark. Sample size considerations are paramount—a .400 average over ten at-bats tells us almost nothing, while the same average over 500 at-bats represents historic excellence. These fundamental statistics, properly understood and contextualized, provide the analytical framework upon which all baseball evaluation rests.

Key Components of Baseball Statistics

1. Batting Average (AVG)

Batting average represents the most traditional and widely recognized hitting statistic, measuring the frequency with which a batter records a hit when putting the ball in play. Calculated as hits divided by at-bats, batting average has served as the primary measure of hitting ability since the 1870s. A .300 average is considered excellent, .275 represents solid performance, and .250 is roughly league average in modern baseball. However, batting average has limitations: it ignores walks, treats all hits equally regardless of extra-base value, and doesn't account for the run-scoring context in which hits occur.

2. On-Base Percentage (OBP)

On-base percentage improves upon batting average by measuring all the ways a batter reaches base safely, including hits, walks, and hit-by-pitches. This metric better captures a hitter's ability to avoid making outs, which is the most fundamental offensive skill. Since avoiding outs is crucial to scoring runs, OBP has proven to correlate more strongly with run production than batting average. Elite hitters typically maintain an OBP above .380, while league average hovers around .320. OBP's inclusion of walks makes it particularly valuable for evaluating patient hitters who draw substantial walks despite modest batting averages.

3. Slugging Percentage (SLG)

Slugging percentage measures the total number of bases a player records per at-bat, effectively quantifying power output. Unlike batting average, slugging percentage distinguishes between singles, doubles, triples, and home runs by weighting each hit according to bases earned. The formula awards one base for a single, two for a double, three for a triple, and four for a home run. Exceptional power hitters post slugging percentages above .500, while league average typically falls around .420. Slugging percentage is essential for evaluating power production but doesn't account for walks or other non-hit ways of reaching base.

4. On-Base Plus Slugging (OPS)

OPS combines on-base percentage and slugging percentage into a single comprehensive offensive metric. By adding these two statistics, OPS captures both a player's ability to reach base and their power production, providing a reasonably complete picture of offensive value. An OPS above .900 indicates an elite hitter, .800 represents above-average performance, and .700 is roughly league average. While OPS has statistical imperfections—it adds two percentages with different denominators and weights OBP and SLG equally despite OBP being more valuable—its simplicity and strong correlation with run production have made it widely popular among analysts and fans.

5. Earned Run Average (ERA)

Earned run average is the cornerstone pitching statistic, measuring the number of earned runs a pitcher allows per nine innings pitched. ERA excludes runs that score due to defensive errors, attempting to isolate pitching performance from fielding quality. A sub-3.00 ERA indicates elite pitching, 4.00 represents league average, and above 5.00 suggests below-average performance. ERA's primary limitation is its dependence on factors partially outside the pitcher's control, including defensive support, ballpark effects, and sequencing luck. Despite these limitations, ERA remains the most widely cited measure of pitcher effectiveness.

6. Walks and Hits per Inning Pitched (WHIP)

WHIP quantifies the number of baserunners a pitcher allows per inning by adding walks and hits, then dividing by innings pitched. This metric provides a complementary view to ERA, focusing on prevention of baserunners rather than runs. A WHIP below 1.00 is exceptional, indicating the pitcher allows fewer than one baserunner per inning. League average WHIP typically falls around 1.30. WHIP's advantage over ERA is its independence from factors like strand rate and home run rate, though it still reflects defensive quality and doesn't distinguish between walks and hits despite walks being more controllable.

7. Strikeout Rate (K/9) and Walk Rate (BB/9)

Strikeout rate and walk rate measure a pitcher's strikeouts and walks per nine innings, isolating outcomes almost entirely within the pitcher's control. High strikeout rates (above 9.0 K/9) indicate the ability to miss bats and avoid putting the ball in play, while low walk rates (below 2.0 BB/9) demonstrate command and control. The ratio of strikeouts to walks (K/BB) provides additional insight, with ratios above 3.0 suggesting excellent command. These rate statistics are particularly valuable because they're minimally influenced by defense, ballpark, or luck, making them reliable indicators of true pitching skill.

Mathematical Formulas

Batting Average (AVG)

AVG = H / AB

Where:
H = Hits
AB = At-Bats

On-Base Percentage (OBP)

OBP = (H + BB + HBP) / (AB + BB + HBP + SF)

Where:
H = Hits
BB = Walks (Base on Balls)
HBP = Hit By Pitch
AB = At-Bats
SF = Sacrifice Flies

Slugging Percentage (SLG)

SLG = (1B + 2×2B + 3×3B + 4×HR) / AB

or

SLG = Total Bases / AB

Where:
1B = Singles
2B = Doubles
3B = Triples
HR = Home Runs
AB = At-Bats
Total Bases = 1B + (2×2B) + (3×3B) + (4×HR)

On-Base Plus Slugging (OPS)

OPS = OBP + SLG

Earned Run Average (ERA)

ERA = (ER × 9) / IP

Where:
ER = Earned Runs
IP = Innings Pitched
9 = constant representing a standard game length

Walks and Hits per Inning Pitched (WHIP)

WHIP = (BB + H) / IP

Where:
BB = Walks
H = Hits allowed
IP = Innings Pitched

Strikeout Rate (K/9)

K/9 = (K × 9) / IP

Where:
K = Strikeouts
IP = Innings Pitched

Walk Rate (BB/9)

BB/9 = (BB × 9) / IP

Where:
BB = Walks
IP = Innings Pitched

Strikeout-to-Walk Ratio (K/BB)

K/BB = K / BB

Where:
K = Strikeouts
BB = Walks

Python Implementation

"""
Baseball Statistics Fundamentals Calculator
A comprehensive module for calculating and analyzing traditional baseball statistics
using pybaseball and pandas libraries.
"""

import pandas as pd
import numpy as np
from pybaseball import batting_stats, pitching_stats, playerid_lookup
import warnings
warnings.filterwarnings('ignore')


class BattingStatistics:
    """
    A class for calculating and analyzing batting statistics.

    Attributes:
        data (pd.DataFrame): DataFrame containing batting statistics
    """

    def __init__(self, season_start=2023, season_end=2023):
        """
        Initialize BattingStatistics with data from specified seasons.

        Args:
            season_start (int): Starting season year
            season_end (int): Ending season year
        """
        print(f"Fetching batting data for {season_start}-{season_end}...")
        self.data = batting_stats(season_start, season_end, qual=100)
        print(f"Loaded {len(self.data)} player seasons")

    def calculate_batting_average(self, hits, at_bats):
        """
        Calculate batting average.

        Args:
            hits (float): Number of hits
            at_bats (float): Number of at-bats

        Returns:
            float: Batting average
        """
        if at_bats == 0:
            return 0.0
        return hits / at_bats

    def calculate_obp(self, hits, walks, hbp, at_bats, sf):
        """
        Calculate on-base percentage.

        Args:
            hits (float): Hits
            walks (float): Walks
            hbp (float): Hit by pitch
            at_bats (float): At-bats
            sf (float): Sacrifice flies

        Returns:
            float: On-base percentage
        """
        denominator = at_bats + walks + hbp + sf
        if denominator == 0:
            return 0.0
        return (hits + walks + hbp) / denominator

    def calculate_slugging(self, singles, doubles, triples, home_runs, at_bats):
        """
        Calculate slugging percentage.

        Args:
            singles (float): Singles
            doubles (float): Doubles
            triples (float): Triples
            home_runs (float): Home runs
            at_bats (float): At-bats

        Returns:
            float: Slugging percentage
        """
        if at_bats == 0:
            return 0.0
        total_bases = singles + (2 * doubles) + (3 * triples) + (4 * home_runs)
        return total_bases / at_bats

    def calculate_ops(self, obp, slg):
        """
        Calculate OPS (On-base Plus Slugging).

        Args:
            obp (float): On-base percentage
            slg (float): Slugging percentage

        Returns:
            float: OPS
        """
        return obp + slg

    def get_top_batters(self, stat='AVG', n=10):
        """
        Get top batters by specified statistic.

        Args:
            stat (str): Statistic to sort by (AVG, OBP, SLG, OPS)
            n (int): Number of players to return

        Returns:
            pd.DataFrame: Top n batters
        """
        return self.data.nlargest(n, stat)[['Name', 'Team', stat, 'AB', 'H', 'HR', 'RBI']]

    def analyze_player_batting(self, player_name):
        """
        Analyze batting statistics for a specific player.

        Args:
            player_name (str): Player name to analyze

        Returns:
            dict: Dictionary containing player statistics and analysis
        """
        player_data = self.data[self.data['Name'].str.contains(player_name, case=False)]

        if player_data.empty:
            return {"error": f"Player {player_name} not found"}

        player = player_data.iloc[0]

        analysis = {
            'name': player['Name'],
            'team': player['Team'],
            'avg': round(player['AVG'], 3),
            'obp': round(player['OBP'], 3),
            'slg': round(player['SLG'], 3),
            'ops': round(player['OPS'], 3),
            'at_bats': int(player['AB']),
            'hits': int(player['H']),
            'home_runs': int(player['HR']),
            'rbi': int(player['RBI']),
            'walks': int(player['BB']),
            'strikeouts': int(player['SO'])
        }

        # Add performance ratings
        analysis['avg_rating'] = self._rate_average(analysis['avg'])
        analysis['obp_rating'] = self._rate_obp(analysis['obp'])
        analysis['ops_rating'] = self._rate_ops(analysis['ops'])

        return analysis

    def _rate_average(self, avg):
        """Rate batting average performance."""
        if avg >= 0.300:
            return "Excellent"
        elif avg >= 0.275:
            return "Above Average"
        elif avg >= 0.250:
            return "Average"
        else:
            return "Below Average"

    def _rate_obp(self, obp):
        """Rate on-base percentage performance."""
        if obp >= 0.380:
            return "Excellent"
        elif obp >= 0.340:
            return "Above Average"
        elif obp >= 0.310:
            return "Average"
        else:
            return "Below Average"

    def _rate_ops(self, ops):
        """Rate OPS performance."""
        if ops >= 0.900:
            return "Elite"
        elif ops >= 0.800:
            return "Above Average"
        elif ops >= 0.700:
            return "Average"
        else:
            return "Below Average"


class PitchingStatistics:
    """
    A class for calculating and analyzing pitching statistics.

    Attributes:
        data (pd.DataFrame): DataFrame containing pitching statistics
    """

    def __init__(self, season_start=2023, season_end=2023):
        """
        Initialize PitchingStatistics with data from specified seasons.

        Args:
            season_start (int): Starting season year
            season_end (int): Ending season year
        """
        print(f"Fetching pitching data for {season_start}-{season_end}...")
        self.data = pitching_stats(season_start, season_end, qual=50)
        print(f"Loaded {len(self.data)} pitcher seasons")

    def calculate_era(self, earned_runs, innings_pitched):
        """
        Calculate earned run average.

        Args:
            earned_runs (float): Earned runs allowed
            innings_pitched (float): Innings pitched

        Returns:
            float: ERA
        """
        if innings_pitched == 0:
            return 0.0
        return (earned_runs * 9) / innings_pitched

    def calculate_whip(self, walks, hits, innings_pitched):
        """
        Calculate WHIP (Walks plus Hits per Inning Pitched).

        Args:
            walks (float): Walks allowed
            hits (float): Hits allowed
            innings_pitched (float): Innings pitched

        Returns:
            float: WHIP
        """
        if innings_pitched == 0:
            return 0.0
        return (walks + hits) / innings_pitched

    def calculate_k_per_9(self, strikeouts, innings_pitched):
        """
        Calculate strikeouts per 9 innings.

        Args:
            strikeouts (float): Strikeouts
            innings_pitched (float): Innings pitched

        Returns:
            float: K/9
        """
        if innings_pitched == 0:
            return 0.0
        return (strikeouts * 9) / innings_pitched

    def calculate_bb_per_9(self, walks, innings_pitched):
        """
        Calculate walks per 9 innings.

        Args:
            walks (float): Walks
            innings_pitched (float): Innings pitched

        Returns:
            float: BB/9
        """
        if innings_pitched == 0:
            return 0.0
        return (walks * 9) / innings_pitched

    def calculate_k_bb_ratio(self, strikeouts, walks):
        """
        Calculate strikeout-to-walk ratio.

        Args:
            strikeouts (float): Strikeouts
            walks (float): Walks

        Returns:
            float: K/BB ratio
        """
        if walks == 0:
            return float('inf') if strikeouts > 0 else 0.0
        return strikeouts / walks

    def get_top_pitchers(self, stat='ERA', n=10, ascending=True):
        """
        Get top pitchers by specified statistic.

        Args:
            stat (str): Statistic to sort by (ERA, WHIP, K/9, etc.)
            n (int): Number of pitchers to return
            ascending (bool): Sort order (True for ERA/WHIP, False for K/9)

        Returns:
            pd.DataFrame: Top n pitchers
        """
        if ascending:
            return self.data.nsmallest(n, stat)[['Name', 'Team', stat, 'W', 'IP', 'SO', 'ERA']]
        else:
            return self.data.nlargest(n, stat)[['Name', 'Team', stat, 'W', 'IP', 'SO', 'ERA']]

    def analyze_pitcher(self, pitcher_name):
        """
        Analyze pitching statistics for a specific pitcher.

        Args:
            pitcher_name (str): Pitcher name to analyze

        Returns:
            dict: Dictionary containing pitcher statistics and analysis
        """
        pitcher_data = self.data[self.data['Name'].str.contains(pitcher_name, case=False)]

        if pitcher_data.empty:
            return {"error": f"Pitcher {pitcher_name} not found"}

        pitcher = pitcher_data.iloc[0]

        analysis = {
            'name': pitcher['Name'],
            'team': pitcher['Team'],
            'era': round(pitcher['ERA'], 2),
            'whip': round(pitcher['WHIP'], 2),
            'wins': int(pitcher['W']),
            'losses': int(pitcher['L']),
            'innings_pitched': round(pitcher['IP'], 1),
            'strikeouts': int(pitcher['SO']),
            'walks': int(pitcher['BB']),
            'k_per_9': round(self.calculate_k_per_9(pitcher['SO'], pitcher['IP']), 2),
            'bb_per_9': round(self.calculate_bb_per_9(pitcher['BB'], pitcher['IP']), 2),
            'k_bb_ratio': round(self.calculate_k_bb_ratio(pitcher['SO'], pitcher['BB']), 2)
        }

        # Add performance ratings
        analysis['era_rating'] = self._rate_era(analysis['era'])
        analysis['whip_rating'] = self._rate_whip(analysis['whip'])
        analysis['k9_rating'] = self._rate_k9(analysis['k_per_9'])

        return analysis

    def _rate_era(self, era):
        """Rate ERA performance."""
        if era <= 3.00:
            return "Excellent"
        elif era <= 4.00:
            return "Above Average"
        elif era <= 4.50:
            return "Average"
        else:
            return "Below Average"

    def _rate_whip(self, whip):
        """Rate WHIP performance."""
        if whip <= 1.00:
            return "Excellent"
        elif whip <= 1.20:
            return "Above Average"
        elif whip <= 1.35:
            return "Average"
        else:
            return "Below Average"

    def _rate_k9(self, k9):
        """Rate K/9 performance."""
        if k9 >= 10.0:
            return "Elite"
        elif k9 >= 8.5:
            return "Above Average"
        elif k9 >= 7.0:
            return "Average"
        else:
            return "Below Average"


# Example usage and demonstration
if __name__ == "__main__":
    # Initialize batting statistics
    batting = BattingStatistics(2023, 2023)

    # Get top 10 batters by average
    print("\nTop 10 Batters by Average:")
    print(batting.get_top_batters('AVG', 10))

    # Get top 10 batters by OPS
    print("\nTop 10 Batters by OPS:")
    print(batting.get_top_batters('OPS', 10))

    # Initialize pitching statistics
    pitching = PitchingStatistics(2023, 2023)

    # Get top 10 pitchers by ERA
    print("\nTop 10 Pitchers by ERA:")
    print(pitching.get_top_pitchers('ERA', 10, ascending=True))

    # Get top 10 pitchers by K/9
    print("\nTop 10 Pitchers by K/9:")
    print(pitching.get_top_pitchers('K/9', 10, ascending=False))

    print("\nStatistics analysis complete!")

R Implementation

# Baseball Statistics Fundamentals in R
# Comprehensive analysis using baseballr, Lahman, and tidyverse packages

# Load required libraries
library(baseballr)
library(Lahman)
library(tidyverse)
library(scales)

#' Calculate Batting Average
#'
#' @param hits Number of hits
#' @param at_bats Number of at-bats
#' @return Batting average
calculate_batting_average <- function(hits, at_bats) {
  if (at_bats == 0) return(0)
  return(hits / at_bats)
}

#' Calculate On-Base Percentage
#'
#' @param hits Number of hits
#' @param walks Number of walks
#' @param hbp Number of hit-by-pitches
#' @param at_bats Number of at-bats
#' @param sf Number of sacrifice flies
#' @return On-base percentage
calculate_obp <- function(hits, walks, hbp, at_bats, sf) {
  denominator <- at_bats + walks + hbp + sf
  if (denominator == 0) return(0)
  return((hits + walks + hbp) / denominator)
}

#' Calculate Slugging Percentage
#'
#' @param singles Number of singles
#' @param doubles Number of doubles
#' @param triples Number of triples
#' @param home_runs Number of home runs
#' @param at_bats Number of at-bats
#' @return Slugging percentage
calculate_slugging <- function(singles, doubles, triples, home_runs, at_bats) {
  if (at_bats == 0) return(0)
  total_bases <- singles + (2 * doubles) + (3 * triples) + (4 * home_runs)
  return(total_bases / at_bats)
}

#' Calculate OPS (On-base Plus Slugging)
#'
#' @param obp On-base percentage
#' @param slg Slugging percentage
#' @return OPS
calculate_ops <- function(obp, slg) {
  return(obp + slg)
}

#' Calculate ERA (Earned Run Average)
#'
#' @param earned_runs Number of earned runs
#' @param innings_pitched Number of innings pitched
#' @return ERA
calculate_era <- function(earned_runs, innings_pitched) {
  if (innings_pitched == 0) return(0)
  return((earned_runs * 9) / innings_pitched)
}

#' Calculate WHIP (Walks plus Hits per Inning Pitched)
#'
#' @param walks Number of walks
#' @param hits Number of hits allowed
#' @param innings_pitched Number of innings pitched
#' @return WHIP
calculate_whip <- function(walks, hits, innings_pitched) {
  if (innings_pitched == 0) return(0)
  return((walks + hits) / innings_pitched)
}

#' Calculate K/9 (Strikeouts per 9 innings)
#'
#' @param strikeouts Number of strikeouts
#' @param innings_pitched Number of innings pitched
#' @return K/9
calculate_k_per_9 <- function(strikeouts, innings_pitched) {
  if (innings_pitched == 0) return(0)
  return((strikeouts * 9) / innings_pitched)
}

#' Calculate BB/9 (Walks per 9 innings)
#'
#' @param walks Number of walks
#' @param innings_pitched Number of innings pitched
#' @return BB/9
calculate_bb_per_9 <- function(walks, innings_pitched) {
  if (innings_pitched == 0) return(0)
  return((walks * 9) / innings_pitched)
}

#' Calculate K/BB Ratio
#'
#' @param strikeouts Number of strikeouts
#' @param walks Number of walks
#' @return K/BB ratio
calculate_k_bb_ratio <- function(strikeouts, walks) {
  if (walks == 0) return(ifelse(strikeouts > 0, Inf, 0))
  return(strikeouts / walks)
}

#' Analyze Batting Statistics from Lahman Database
#'
#' @param year_start Starting year
#' @param year_end Ending year
#' @param min_ab Minimum at-bats threshold
#' @return Data frame with batting statistics
analyze_batting_stats <- function(year_start = 2022, year_end = 2022, min_ab = 300) {

  # Load batting data from Lahman database
  batting_data <- Batting %>%
    filter(yearID >= year_start & yearID <= year_end) %>%
    group_by(playerID) %>%
    summarise(
      AB = sum(AB, na.rm = TRUE),
      H = sum(H, na.rm = TRUE),
      X2B = sum(X2B, na.rm = TRUE),
      X3B = sum(X3B, na.rm = TRUE),
      HR = sum(HR, na.rm = TRUE),
      BB = sum(BB, na.rm = TRUE),
      HBP = sum(HBP, na.rm = TRUE),
      SF = sum(SF, na.rm = TRUE),
      SO = sum(SO, na.rm = TRUE),
      RBI = sum(RBI, na.rm = TRUE),
      R = sum(R, na.rm = TRUE)
    ) %>%
    filter(AB >= min_ab) %>%
    mutate(
      # Calculate singles
      X1B = H - X2B - X3B - HR,

      # Calculate batting average
      AVG = calculate_batting_average(H, AB),

      # Calculate on-base percentage
      OBP = calculate_obp(H, BB, HBP, AB, SF),

      # Calculate slugging percentage
      SLG = calculate_slugging(X1B, X2B, X3B, HR, AB),

      # Calculate OPS
      OPS = calculate_ops(OBP, SLG)
    )

  # Join with player names
  batting_with_names <- batting_data %>%
    left_join(People %>% select(playerID, nameFirst, nameLast), by = "playerID") %>%
    mutate(Name = paste(nameFirst, nameLast)) %>%
    select(playerID, Name, AB, H, HR, RBI, BB, SO, AVG, OBP, SLG, OPS) %>%
    arrange(desc(OPS))

  return(batting_with_names)
}

#' Analyze Pitching Statistics from Lahman Database
#'
#' @param year_start Starting year
#' @param year_end Ending year
#' @param min_ip Minimum innings pitched threshold
#' @return Data frame with pitching statistics
analyze_pitching_stats <- function(year_start = 2022, year_end = 2022, min_ip = 50) {

  # Load pitching data from Lahman database
  pitching_data <- Pitching %>%
    filter(yearID >= year_start & yearID <= year_end) %>%
    group_by(playerID) %>%
    summarise(
      W = sum(W, na.rm = TRUE),
      L = sum(L, na.rm = TRUE),
      IPouts = sum(IPouts, na.rm = TRUE),
      H = sum(H, na.rm = TRUE),
      ER = sum(ER, na.rm = TRUE),
      BB = sum(BB, na.rm = TRUE),
      SO = sum(SO, na.rm = TRUE),
      HR = sum(HR, na.rm = TRUE)
    ) %>%
    mutate(
      # Convert IPouts to innings pitched
      IP = IPouts / 3,

      # Calculate ERA
      ERA = calculate_era(ER, IP),

      # Calculate WHIP
      WHIP = calculate_whip(BB, H, IP),

      # Calculate K/9
      K9 = calculate_k_per_9(SO, IP),

      # Calculate BB/9
      BB9 = calculate_bb_per_9(BB, IP),

      # Calculate K/BB ratio
      K_BB = calculate_k_bb_ratio(SO, BB)
    ) %>%
    filter(IP >= min_ip)

  # Join with player names
  pitching_with_names <- pitching_data %>%
    left_join(People %>% select(playerID, nameFirst, nameLast), by = "playerID") %>%
    mutate(Name = paste(nameFirst, nameLast)) %>%
    select(playerID, Name, W, L, IP, SO, BB, ERA, WHIP, K9, BB9, K_BB) %>%
    arrange(ERA)

  return(pitching_with_names)
}

#' Get Top Batters by Statistic
#'
#' @param batting_data Batting statistics data frame
#' @param stat Statistic to sort by
#' @param n Number of top players to return
#' @return Top n batters
get_top_batters <- function(batting_data, stat = "AVG", n = 10) {
  batting_data %>%
    arrange(desc(.data[[stat]])) %>%
    head(n) %>%
    select(Name, AB, H, HR, RBI, AVG, OBP, SLG, OPS)
}

#' Get Top Pitchers by Statistic
#'
#' @param pitching_data Pitching statistics data frame
#' @param stat Statistic to sort by
#' @param n Number of top players to return
#' @param ascending Sort order
#' @return Top n pitchers
get_top_pitchers <- function(pitching_data, stat = "ERA", n = 10, ascending = TRUE) {
  if (ascending) {
    pitching_data %>%
      arrange(.data[[stat]]) %>%
      head(n) %>%
      select(Name, W, L, IP, SO, ERA, WHIP, K9, BB9)
  } else {
    pitching_data %>%
      arrange(desc(.data[[stat]])) %>%
      head(n) %>%
      select(Name, W, L, IP, SO, ERA, WHIP, K9, BB9)
  }
}

# Main analysis execution
main_analysis <- function() {

  cat("Analyzing Baseball Statistics Fundamentals using Lahman Database\n\n")

  # Analyze batting statistics for 2022 season
  cat("Loading batting statistics...\n")
  batting_stats <- analyze_batting_stats(2022, 2022, min_ab = 300)

  cat("\nTop 10 Batters by Batting Average:\n")
  print(get_top_batters(batting_stats, "AVG", 10))

  cat("\nTop 10 Batters by OPS:\n")
  print(get_top_batters(batting_stats, "OPS", 10))

  # Analyze pitching statistics for 2022 season
  cat("\nLoading pitching statistics...\n")
  pitching_stats <- analyze_pitching_stats(2022, 2022, min_ip = 50)

  cat("\nTop 10 Pitchers by ERA:\n")
  print(get_top_pitchers(pitching_stats, "ERA", 10, ascending = TRUE))

  cat("\nTop 10 Pitchers by K/9:\n")
  print(get_top_pitchers(pitching_stats, "K9", 10, ascending = FALSE))

  # Summary statistics
  cat("\n=== Batting Statistics Summary ===\n")
  cat(sprintf("Average AVG: %.3f\n", mean(batting_stats$AVG, na.rm = TRUE)))
  cat(sprintf("Average OBP: %.3f\n", mean(batting_stats$OBP, na.rm = TRUE)))
  cat(sprintf("Average SLG: %.3f\n", mean(batting_stats$SLG, na.rm = TRUE)))
  cat(sprintf("Average OPS: %.3f\n", mean(batting_stats$OPS, na.rm = TRUE)))

  cat("\n=== Pitching Statistics Summary ===\n")
  cat(sprintf("Average ERA: %.2f\n", mean(pitching_stats$ERA, na.rm = TRUE)))
  cat(sprintf("Average WHIP: %.2f\n", mean(pitching_stats$WHIP, na.rm = TRUE)))
  cat(sprintf("Average K/9: %.2f\n", mean(pitching_stats$K9, na.rm = TRUE)))
  cat(sprintf("Average BB/9: %.2f\n", mean(pitching_stats$BB9, na.rm = TRUE)))

  cat("\nAnalysis complete!\n")
}

# Execute main analysis
if (interactive()) {
  main_analysis()
}

Real-World Application

Professional baseball organizations leverage fundamental statistics as the cornerstone of player evaluation, roster construction, and strategic decision-making. Major League Baseball front offices employ analytics departments staffed with data scientists, statisticians, and former players who use these metrics to inform multi-million dollar decisions. When evaluating free agents or trade targets, teams begin their analysis with traditional statistics, using them as benchmarks to identify players who meet minimum performance thresholds before conducting deeper investigation with advanced metrics.

Scouting and player development departments use fundamental statistics to track player progression and identify areas for improvement. A minor league hitter showing increasing walk rates (reflected in rising OBP) demonstrates developing plate discipline, even if batting average remains stagnant. Similarly, a young pitcher whose strikeout rate climbs while walk rate decreases signals improving command and stuff, suggesting readiness for promotion. These fundamental metrics provide objective, quantifiable evidence of skill development that complements subjective scouting observations.

In-game strategy also relies heavily on fundamental statistics. Managers consult historical batting averages, on-base percentages, and platoon splits when making lineup decisions, determining batting order, and choosing pinch hitters. Pitching matchups are evaluated using ERA, WHIP, and strikeout rates to optimize relief pitcher usage in high-leverage situations. The ability to quickly process and apply these fundamental statistics in real-time game situations represents a critical competitive advantage for well-prepared coaching staffs.

Beyond team operations, fundamental baseball statistics drive player compensation through arbitration and contract negotiations. Arbitration panels have historically relied on traditional statistics like batting average, home runs, RBI, wins, and ERA when determining player salaries. Though advanced metrics increasingly influence these discussions, fundamental statistics remain the primary currency of player value assessment in salary negotiations.

Interpretation and Rating Guidelines

Key Takeaways

• Fundamental statistics provide the foundation for all baseball analysis: Batting average, OBP, SLG, ERA, and WHIP represent the essential metrics that have stood the test of time. While advanced analytics have expanded our analytical toolkit, these fundamental statistics remain indispensable for player evaluation, game strategy, and fan engagement across all levels of baseball.
• No single statistic tells the complete story: Each fundamental metric captures a specific dimension of performance while having inherent limitations. Batting average measures contact ability but ignores walks and power; ERA evaluates run prevention but depends on defense and luck. Comprehensive player evaluation requires considering multiple complementary statistics together rather than relying on any single measure.
• Context and sample size are critical for proper interpretation: A .400 batting average over 20 at-bats means little, while the same average over 500 at-bats represents historic achievement. Ballpark effects, defensive support, era, and competition quality all influence statistics and must be considered when making meaningful comparisons between players or evaluating performance.
• On-base percentage and strikeout rate deserve special attention: Research has consistently shown that OBP correlates more strongly with run scoring than batting average, while pitcher strikeout rates prove more predictive of future success than ERA. Understanding why certain statistics provide more reliable information than others elevates analysis beyond superficial number-watching to genuine insight.
• Fundamental statistics create a universal baseball language: From front office executives to casual fans, these traditional metrics provide common ground for discussion and debate. Their widespread understanding and historical continuity make them invaluable for comparing players across eras, evaluating current performance against historical benchmarks, and engaging with baseball's rich statistical heritage.