Your First Baseball Analysis

Your First Baseball Analysis: A Comprehensive Beginner's Guide

Welcome to the exciting world of baseball analytics! Whether you're a die-hard fan looking to understand the game deeper, a data scientist exploring sports analytics, or a student learning data analysis, this comprehensive guide will walk you through your first complete baseball analysis project from start to finish.

By the end of this tutorial, you'll have hands-on experience loading real baseball data, exploring it systematically, asking analytical questions, and generating insights using both Python and R. We'll work through a complete mini-analysis that you can use as a template for your own projects.

Setting Up Your Baseball Analytics Environment

Python Setup

For Python-based baseball analytics, you'll need several key libraries. Open your terminal or command prompt and install these packages:

pip install pandas numpy matplotlib seaborn pybaseball

Here's what each library does:

• pandas: Data manipulation and analysis, provides DataFrame structures
• numpy: Numerical computing and array operations
• matplotlib: Basic plotting and visualization
• seaborn: Statistical data visualization built on matplotlib
• pybaseball: Specialized library for accessing baseball data sources

R Setup

For R users, install these packages in your R console:

install.packages(c("tidyverse", "Lahman", "baseballr"))

# tidyverse includes ggplot2, dplyr, tidyr, and other essential tools
# Lahman provides historical baseball statistics
# baseballr accesses various baseball data APIs

Understanding Your Data Sources

Before diving into code, let's understand the two primary data sources we'll use:

• Statcast Data: High-resolution pitch-by-pitch tracking data from MLB's tracking system, including exit velocity, launch angle, spin rate, and more. Available from 2015 onwards.
• Lahman Database: Comprehensive historical baseball statistics dating back to 1871, including batting, pitching, fielding, and biographical data. The gold standard for historical analysis.

Loading and Inspecting Sample Data

Loading Statcast Data (Python)

Let's start by loading some recent Statcast data. We'll grab data from the 2024 season:

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

# Load Statcast data for a specific date range
# Note: Loading large date ranges can be slow
statcast_data = statcast(start_dt='2024-04-01', end_dt='2024-04-30')

# Display basic information
print(f"Loaded {len(statcast_data)} pitches")
print(f"Columns: {statcast_data.shape[1]}")

# View first few rows
print(statcast_data.head())

# Check data types
print(statcast_data.dtypes)

# Get column names
print(statcast_data.columns.tolist())

Loading Lahman Data (Python)

from pybaseball import lahman

# Load batting statistics
batting = lahman.batting()
print(f"Batting data shape: {batting.shape}")
print(batting.head())

# Load pitching statistics
pitching = lahman.pitching()
print(f"Pitching data shape: {pitching.shape}")

# Load player biographical data
people = lahman.people()
print(f"People data shape: {people.shape}")

Loading Data in R

library(tidyverse)
library(Lahman)
library(baseballr)

# Load Lahman batting data
data("Batting")
glimpse(Batting)

# Load pitching data
data("Pitching")
glimpse(Pitching)

# Load player information
data("People")
glimpse(People)

# For Statcast data (requires internet connection)
# Note: statcast_search can be slow for large date ranges
statcast_data <- statcast_search(start_date = "2024-04-01",
                                  end_date = "2024-04-30",
                                  playertype = "batter")

glimpse(statcast_data)

Exploratory Data Analysis Workflow

A systematic exploratory data analysis (EDA) workflow helps you understand your data before diving into complex analyses. Follow these steps:

Step 1: Understand the Data Structure

Always start by understanding what you're working with:

# Python
print(batting.info())
print(batting.describe())

# Check for missing values
print(batting.isnull().sum())

# Unique values in key columns
print(f"Unique years: {batting['yearID'].nunique()}")
print(f"Unique players: {batting['playerID'].nunique()}")
print(f"Year range: {batting['yearID'].min()} to {batting['yearID'].max()}")

# R
summary(Batting)

# Missing values
Batting %>%
  summarise_all(~sum(is.na(.)))

# Unique values
Batting %>%
  summarise(
    unique_years = n_distinct(yearID),
    unique_players = n_distinct(playerID),
    min_year = min(yearID),
    max_year = max(yearID)
  )

Step 2: Data Quality Checks

Real-world data always has issues. Check for common problems:

# Python - Check for data quality issues
# Look for negative or impossible values
print("Players with negative at-bats:", (batting['AB'] < 0).sum())
print("Players with hits > at-bats:", (batting['H'] > batting['AB']).sum())

# Check for outliers in batting average
batting_qualified = batting[batting['AB'] >= 300].copy()
batting_qualified['BA'] = batting_qualified['H'] / batting_qualified['AB']

# Display players with suspiciously high averages
print(batting_qualified[batting_qualified['BA'] > 0.400][['playerID', 'yearID', 'BA']])

Step 3: Calculate Derived Metrics

Baseball analytics often requires calculating additional statistics:

# Python - Calculate common baseball metrics
def calculate_batting_stats(df):
    """Calculate standard batting statistics"""
    df = df.copy()

    # Batting average (BA)
    df['BA'] = np.where(df['AB'] > 0, df['H'] / df['AB'], 0)

    # On-base percentage (OBP)
    denominator = df['AB'] + df['BB'] + df['HBP'] + df['SF']
    numerator = df['H'] + df['BB'] + df['HBP']
    df['OBP'] = np.where(denominator > 0, numerator / denominator, 0)

    # Slugging percentage (SLG)
    total_bases = df['H'] + df['2B'] + (2 * df['3B']) + (3 * df['HR'])
    df['SLG'] = np.where(df['AB'] > 0, total_bases / df['AB'], 0)

    # On-base plus slugging (OPS)
    df['OPS'] = df['OBP'] + df['SLG']

    return df

batting_with_stats = calculate_batting_stats(batting)
print(batting_with_stats[['playerID', 'yearID', 'BA', 'OBP', 'SLG', 'OPS']].head())

# R - Calculate batting statistics
Batting_with_stats <- Batting %>%
  mutate(
    BA = ifelse(AB > 0, H / AB, 0),
    OBP = ifelse((AB + BB + HBP + SF) > 0,
                 (H + BB + HBP) / (AB + BB + HBP + SF), 0),
    total_bases = H + X2B + (2 * X3B) + (3 * HR),
    SLG = ifelse(AB > 0, total_bases / AB, 0),
    OPS = OBP + SLG
  )

glimpse(Batting_with_stats)

Asking Good Analytical Questions

The key to good analysis is asking the right questions. Here are examples of questions at different complexity levels:

Beginner Questions

• Who had the highest batting average in 2024?
• Which team hit the most home runs last season?
• What's the average number of strikeouts per game in modern baseball?
• How many players have hit 50+ home runs in a season?

Intermediate Questions

• Has batting average declined over the past 20 years?
• What's the relationship between exit velocity and home runs?
• Which players improved their OPS the most from 2023 to 2024?
• Do players perform better at home or away?

Advanced Questions

• Can we predict home runs based on launch angle and exit velocity?
• Which players outperform their expected statistics based on Statcast data?
• How does park factor affect offensive statistics?
• What's the optimal launch angle for different types of batters?

Generating Basic Statistical Summaries

Summary Statistics by Group

# Python - Summarize statistics by year
yearly_summary = batting.groupby('yearID').agg({
    'playerID': 'count',
    'AB': 'sum',
    'H': 'sum',
    'HR': 'sum',
    'SO': 'sum'
}).rename(columns={'playerID': 'num_players'})

# Calculate league-wide batting average by year
yearly_summary['league_BA'] = yearly_summary['H'] / yearly_summary['AB']

print(yearly_summary.tail(10))

# R - Yearly summary
yearly_summary <- Batting %>%
  group_by(yearID) %>%
  summarise(
    num_players = n(),
    total_AB = sum(AB, na.rm = TRUE),
    total_H = sum(H, na.rm = TRUE),
    total_HR = sum(HR, na.rm = TRUE),
    total_SO = sum(SO, na.rm = TRUE),
    league_BA = total_H / total_AB
  )

print(tail(yearly_summary, 10))

Percentile Analysis

# Python - Find percentiles for home runs in 2023
hr_2023 = batting[batting['yearID'] == 2023]['HR']

percentiles = [10, 25, 50, 75, 90, 95, 99]
hr_percentiles = np.percentile(hr_2023, percentiles)

for p, value in zip(percentiles, hr_percentiles):
    print(f"{p}th percentile: {value:.1f} home runs")

# Find elite home run hitters (95th percentile and above)
threshold_95 = np.percentile(hr_2023, 95)
elite_hr = batting[(batting['yearID'] == 2023) & (batting['HR'] >= threshold_95)]
print(f"\n{len(elite_hr)} players in the 95th percentile for home runs")

Creating Simple Visualizations

Bar Charts

# Python - Top 10 home run hitters in 2023
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_style("whitegrid")

# Get 2023 data and sort by home runs
hr_2023 = batting[batting['yearID'] == 2023].nlargest(10, 'HR')

plt.figure(figsize=(10, 6))
plt.barh(range(len(hr_2023)), hr_2023['HR'])
plt.yticks(range(len(hr_2023)), hr_2023['playerID'])
plt.xlabel('Home Runs')
plt.title('Top 10 Home Run Hitters - 2023 Season')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.savefig('top_hr_hitters_2023.png', dpi=300)
plt.show()

# R - Top 10 home run hitters
library(ggplot2)

hr_2023 <- Batting %>%
  filter(yearID == 2023) %>%
  arrange(desc(HR)) %>%
  head(10)

ggplot(hr_2023, aes(x = reorder(playerID, HR), y = HR)) +
  geom_bar(stat = "identity", fill = "steelblue") +
  coord_flip() +
  labs(title = "Top 10 Home Run Hitters - 2023 Season",
       x = "Player",
       y = "Home Runs") +
  theme_minimal()

Scatter Plots

# Python - Relationship between walks and strikeouts
qualified_2023 = batting[(batting['yearID'] == 2023) & (batting['AB'] >= 300)]

plt.figure(figsize=(10, 6))
plt.scatter(qualified_2023['BB'], qualified_2023['SO'], alpha=0.6)
plt.xlabel('Walks (BB)')
plt.ylabel('Strikeouts (SO)')
plt.title('Relationship Between Walks and Strikeouts (2023, min. 300 AB)')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('bb_vs_so_2023.png', dpi=300)
plt.show()

# Calculate correlation
correlation = qualified_2023[['BB', 'SO']].corr()
print(f"Correlation between BB and SO: {correlation.loc['BB', 'SO']:.3f}")

# R - Scatter plot with regression line
qualified_2023 <- Batting %>%
  filter(yearID == 2023, AB >= 300)

ggplot(qualified_2023, aes(x = BB, y = SO)) +
  geom_point(alpha = 0.6, color = "steelblue") +
  geom_smooth(method = "lm", se = TRUE, color = "red") +
  labs(title = "Relationship Between Walks and Strikeouts",
       subtitle = "2023 Season, minimum 300 AB",
       x = "Walks (BB)",
       y = "Strikeouts (SO)") +
  theme_minimal()

# Correlation
cor(qualified_2023$BB, qualified_2023$SO, use = "complete.obs")

Time Series Plots

# Python - Batting average trend over time
yearly_stats = batting.groupby('yearID').apply(
    lambda x: pd.Series({
        'league_BA': x['H'].sum() / x['AB'].sum() if x['AB'].sum() > 0 else 0
    })
).reset_index()

# Focus on modern era (1950 onwards)
modern_era = yearly_stats[yearly_stats['yearID'] >= 1950]

plt.figure(figsize=(12, 6))
plt.plot(modern_era['yearID'], modern_era['league_BA'], linewidth=2)
plt.xlabel('Year')
plt.ylabel('League Batting Average')
plt.title('MLB League-Wide Batting Average Trend (1950-Present)')
plt.grid(True, alpha=0.3)
plt.axhline(y=0.250, color='r', linestyle='--', alpha=0.5, label='0.250 Reference')
plt.legend()
plt.tight_layout()
plt.savefig('ba_trend.png', dpi=300)
plt.show()

# R - Batting average trend
yearly_stats <- Batting %>%
  filter(yearID >= 1950) %>%
  group_by(yearID) %>%
  summarise(league_BA = sum(H, na.rm = TRUE) / sum(AB, na.rm = TRUE))

ggplot(yearly_stats, aes(x = yearID, y = league_BA)) +
  geom_line(size = 1, color = "steelblue") +
  geom_hline(yintercept = 0.250, linetype = "dashed",
             color = "red", alpha = 0.5) +
  labs(title = "MLB League-Wide Batting Average Trend",
       subtitle = "1950 to Present",
       x = "Year",
       y = "League Batting Average") +
  theme_minimal()

Complete End-to-End Mini-Analysis

Analysis Question: Who Had the Highest Batting Average in 2024?

Let's perform a complete analysis from start to finish, following best practices:

Python Implementation

import pandas as pd
import numpy as np
from pybaseball import lahman
import matplotlib.pyplot as plt
import seaborn as sns

# Step 1: Load the data
print("Step 1: Loading data...")
batting = lahman.batting()

# Step 2: Filter for 2024 season
print("\nStep 2: Filtering for 2024 season...")
batting_2024 = batting[batting['yearID'] == 2024].copy()
print(f"Found {len(batting_2024)} player-team combinations in 2024")

# Step 3: Set qualification threshold
# Traditional: 3.1 plate appearances per team game (502 PA for 162 games)
min_at_bats = 300  # Simplified threshold for this example

print(f"\nStep 3: Filtering for qualified batters (min. {min_at_bats} AB)...")
qualified = batting_2024[batting_2024['AB'] >= min_at_bats].copy()
print(f"Found {len(qualified)} qualified batters")

# Step 4: Calculate batting average
print("\nStep 4: Calculating batting average...")
qualified['BA'] = qualified['H'] / qualified['AB']

# Step 5: Sort and find the leader
print("\nStep 5: Finding the batting average leader...")
top_batters = qualified.nlargest(10, 'BA')[['playerID', 'teamID', 'AB', 'H', 'BA']]

print("\nTop 10 Batting Averages in 2024:")
print("=" * 60)
for idx, row in top_batters.iterrows():
    print(f"{row['playerID']:15s} ({row['teamID']})  "
          f"{row['H']:3.0f}/{row['AB']:3.0f}  BA: {row['BA']:.3f}")

# Step 6: Statistical summary
print("\n" + "=" * 60)
print("Statistical Summary of Qualified Batters:")
print("=" * 60)
print(f"Mean BA: {qualified['BA'].mean():.3f}")
print(f"Median BA: {qualified['BA'].median():.3f}")
print(f"Std Dev: {qualified['BA'].std():.3f}")
print(f"Min BA: {qualified['BA'].min():.3f}")
print(f"Max BA: {qualified['BA'].max():.3f}")

# Step 7: Visualization
print("\nStep 7: Creating visualization...")
plt.figure(figsize=(12, 6))

# Histogram of batting averages
plt.subplot(1, 2, 1)
plt.hist(qualified['BA'], bins=20, edgecolor='black', alpha=0.7)
plt.axvline(qualified['BA'].mean(), color='red', linestyle='--',
            linewidth=2, label=f'Mean: {qualified["BA"].mean():.3f}')
plt.axvline(qualified['BA'].max(), color='green', linestyle='--',
            linewidth=2, label=f'Max: {qualified["BA"].max():.3f}')
plt.xlabel('Batting Average')
plt.ylabel('Frequency')
plt.title('Distribution of Batting Averages (2024)')
plt.legend()
plt.grid(True, alpha=0.3)

# Box plot
plt.subplot(1, 2, 2)
plt.boxplot(qualified['BA'])
plt.ylabel('Batting Average')
plt.title('Box Plot of Batting Averages (2024)')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('batting_average_analysis_2024.png', dpi=300)
print("Saved visualization to 'batting_average_analysis_2024.png'")

# Step 8: Answer the question
winner = top_batters.iloc[0]
print("\n" + "=" * 60)
print("ANSWER:")
print("=" * 60)
print(f"The highest batting average in 2024 was {winner['BA']:.3f}")
print(f"achieved by {winner['playerID']} ({winner['teamID']})")
print(f"with {winner['H']:.0f} hits in {winner['AB']:.0f} at-bats")
print("=" * 60)

R Implementation

library(tidyverse)
library(Lahman)

# Step 1: Load the data
cat("Step 1: Loading data...\n")
data("Batting")

# Step 2: Filter for 2024 season
cat("\nStep 2: Filtering for 2024 season...\n")
batting_2024 <- Batting %>%
  filter(yearID == 2024)
cat(sprintf("Found %d player-team combinations in 2024\n", nrow(batting_2024)))

# Step 3: Set qualification threshold
min_at_bats <- 300

cat(sprintf("\nStep 3: Filtering for qualified batters (min. %d AB)...\n",
            min_at_bats))
qualified <- batting_2024 %>%
  filter(AB >= min_at_bats)
cat(sprintf("Found %d qualified batters\n", nrow(qualified)))

# Step 4: Calculate batting average
cat("\nStep 4: Calculating batting average...\n")
qualified <- qualified %>%
  mutate(BA = H / AB)

# Step 5: Sort and find the leader
cat("\nStep 5: Finding the batting average leader...\n")
top_batters <- qualified %>%
  arrange(desc(BA)) %>%
  head(10) %>%
  select(playerID, teamID, AB, H, BA)

cat("\nTop 10 Batting Averages in 2024:\n")
cat(rep("=", 60), "\n", sep="")
print(top_batters, n = 10)

# Step 6: Statistical summary
cat("\n", rep("=", 60), "\n", sep="")
cat("Statistical Summary of Qualified Batters:\n")
cat(rep("=", 60), "\n", sep="")
cat(sprintf("Mean BA: %.3f\n", mean(qualified$BA)))
cat(sprintf("Median BA: %.3f\n", median(qualified$BA)))
cat(sprintf("Std Dev: %.3f\n", sd(qualified$BA)))
cat(sprintf("Min BA: %.3f\n", min(qualified$BA)))
cat(sprintf("Max BA: %.3f\n", max(qualified$BA)))

# Step 7: Visualization
cat("\nStep 7: Creating visualization...\n")

# Create histogram
p1 <- ggplot(qualified, aes(x = BA)) +
  geom_histogram(bins = 20, fill = "steelblue",
                 color = "black", alpha = 0.7) +
  geom_vline(aes(xintercept = mean(BA)),
             color = "red", linetype = "dashed", size = 1) +
  geom_vline(aes(xintercept = max(BA)),
             color = "green", linetype = "dashed", size = 1) +
  labs(title = "Distribution of Batting Averages (2024)",
       x = "Batting Average",
       y = "Frequency") +
  theme_minimal()

# Create box plot
p2 <- ggplot(qualified, aes(y = BA)) +
  geom_boxplot(fill = "steelblue", alpha = 0.7) +
  labs(title = "Box Plot of Batting Averages (2024)",
       y = "Batting Average") +
  theme_minimal() +
  theme(axis.text.x = element_blank(),
        axis.ticks.x = element_blank())

# Combine plots
library(patchwork)
combined_plot <- p1 + p2
ggsave("batting_average_analysis_2024.png", combined_plot,
       width = 12, height = 6, dpi = 300)

cat("Saved visualization to 'batting_average_analysis_2024.png'\n")

# Step 8: Answer the question
winner <- top_batters[1, ]
cat("\n", rep("=", 60), "\n", sep="")
cat("ANSWER:\n")
cat(rep("=", 60), "\n", sep="")
cat(sprintf("The highest batting average in 2024 was %.3f\n", winner$BA))
cat(sprintf("achieved by %s (%s)\n", winner$playerID, winner$teamID))
cat(sprintf("with %d hits in %d at-bats\n", winner$H, winner$AB))
cat(rep("=", 60), "\n", sep="")

Interpreting Results

Understanding Statistical Context

When you get results from your analysis, always ask:

• Is this result meaningful? A player with a .400 batting average in 10 at-bats is not as impressive as .320 in 500 at-bats.
• What's the historical context? Compare your findings to league averages and historical benchmarks.
• Are there confounding factors? Park effects, era adjustments, and sample size all matter.
• Does correlation imply causation? Finding a relationship doesn't mean one variable causes the other.

Key Baseball Benchmarks

Statistic	Poor	Average	Good	Excellent	Elite
Batting Average	< .240	.250-.270	.280-.300	.300-.330	> .330
On-Base %	< .300	.320-.340	.350-.370	.380-.400	> .400
Slugging %	< .380	.400-.430	.450-.490	.500-.550	> .550
OPS	< .700	.720-.760	.780-.850	.860-.950	> .950
Home Runs	< 10	15-20	25-30	35-40	> 45

Visualizing Context

# Python - Compare individual to league distribution
player_ba = 0.315  # Example player batting average
league_avg = qualified['BA'].mean()
league_std = qualified['BA'].std()

z_score = (player_ba - league_avg) / league_std
percentile = (qualified['BA'] < player_ba).sum() / len(qualified) * 100

print(f"Player BA: {player_ba:.3f}")
print(f"League Average: {league_avg:.3f}")
print(f"Z-Score: {z_score:.2f}")
print(f"Percentile: {percentile:.1f}th")
print(f"This is {z_score:.1f} standard deviations above average")

Common Pitfalls for Beginners

1. Ignoring Sample Size

The Problem: Treating a player's 5-for-10 start (.500 average) the same as a season-long .300 average.

The Solution: Always set minimum thresholds for plate appearances or at-bats. The traditional qualification is 3.1 PA per team game (502 PA for a 162-game season).

# Python - Proper qualification check
min_pa = 502
qualified_players = batting[(batting['yearID'] == 2024) &
                            (batting['AB'] + batting['BB'] +
                             batting['HBP'] + batting['SF'] >= min_pa)]

2. Not Handling Missing Data

The Problem: Missing values (NaN, NULL) can cause calculations to fail or produce incorrect results.

The Solution: Always check for and handle missing data appropriately.

# Python - Handle missing values
# Check for missing data
print(batting.isnull().sum())

# Drop rows with missing critical values
batting_clean = batting.dropna(subset=['AB', 'H', 'HR'])

# Or fill with zeros where appropriate
batting_filled = batting.fillna({'SF': 0, 'HBP': 0})

# R - Handle missing values
# Check for NAs
summary(Batting)

# Remove rows with missing values
Batting_clean <- Batting %>%
  filter(!is.na(AB), !is.na(H), !is.na(HR))

# Replace NAs with zeros
Batting_filled <- Batting %>%
  mutate(
    SF = replace_na(SF, 0),
    HBP = replace_na(HBP, 0)
  )

3. Comparing Across Different Eras

The Problem: Baseball has changed dramatically over time. A .280 average in 1968 (the "Year of the Pitcher") is not the same as .280 in 2000 (peak steroid era).

The Solution: Use era-adjusted statistics or compare players to their contemporaries.

# Python - Calculate OPS+, an era-adjusted statistic
def calculate_ops_plus(player_ops, league_ops):
    """Calculate OPS+ (100 is league average)"""
    return 100 * (player_ops / league_ops) if league_ops > 0 else 0

# Calculate league OPS by year
league_ops_by_year = batting.groupby('yearID').apply(
    lambda x: (x['H'].sum() + x['BB'].sum() + x['HBP'].sum()) /
              (x['AB'].sum() + x['BB'].sum() + x['HBP'].sum() + x['SF'].sum()) +
              (x['H'].sum() + x['2B'].sum() + 2*x['3B'].sum() + 3*x['HR'].sum()) /
              x['AB'].sum()
)

4. Division by Zero Errors

The Problem: Players with 0 at-bats cause division errors when calculating batting average.

The Solution: Use conditional logic or filter data first.

# Python - Safe division
batting['BA'] = np.where(batting['AB'] > 0,
                         batting['H'] / batting['AB'],
                         0)

# R - Safe division
Batting <- Batting %>%
  mutate(BA = ifelse(AB > 0, H / AB, 0))

5. Confusing Correlation with Causation

The Problem: Finding that players who hit more home runs have higher salaries doesn't mean home runs cause higher salaries (though they might contribute).

The Solution: Be cautious with language. Say "associated with" or "correlated with" rather than "causes."

6. Not Validating Data

The Problem: Assuming downloaded data is correct and complete.

The Solution: Always validate against known results.

# Python - Validate by checking a known result
# Barry Bonds hit 73 HR in 2001
bonds_2001 = batting[(batting['playerID'] == 'bondsba01') &
                     (batting['yearID'] == 2001)]
assert bonds_2001['HR'].values[0] == 73, "Data validation failed!"
print("Data validation passed!")

7. Overlooking Data Types

The Problem: Treating years as strings instead of integers, or vice versa.

The Solution: Check and convert data types as needed.

# Python - Check and convert data types
print(batting['yearID'].dtype)
batting['yearID'] = batting['yearID'].astype(int)

# R - Convert data types
Batting$yearID <- as.integer(Batting$yearID)

Next Steps and Resources

Congratulations! You've completed your first baseball analysis. Here's how to continue your journey:

Immediate Next Steps

1. Replicate this analysis with different years or different statistics (OPS, stolen bases, ERA for pitchers)
2. Modify the code to answer your own questions about baseball
3. Combine datasets - merge batting data with player biographical data to analyze age effects
4. Add complexity - try filtering by team, comparing multiple seasons, or creating interactive visualizations

Recommended Learning Path

• Master the basics: Practice with batting, pitching, and fielding statistics
• Learn advanced metrics: wOBA, wRC+, FIP, WAR
• Explore Statcast: Exit velocity, launch angle, barrel rate, expected statistics
• Build predictive models: Machine learning for player projection and team performance
• Create visualizations: Interactive dashboards, heat maps, spray charts

Essential Resources

• FanGraphs Library: Comprehensive explanations of all baseball statistics
• Baseball Reference: Historical data and context for every player and season
• Savant Baseball: MLB's official Statcast data portal
• The Book Blog: Advanced sabermetric analysis and discussion
• PyBaseball Documentation: Complete guide to the Python baseball library

Conclusion

You now have a complete template for conducting baseball analysis. The key principles you've learned - systematic data exploration, proper qualification thresholds, careful interpretation, and awareness of common pitfalls - apply to any baseball analytics project, whether you're analyzing batting averages or building complex predictive models.

Remember: the best analysts combine statistical rigor with baseball knowledge. Understanding the game's context, history, and nuances will make your analyses more meaningful and insightful. Don't just crunch numbers - tell stories with data that help us understand this beautiful game better.

Happy analyzing!