Chapter 12: Fundamentals of Sports Data Visualization

Introduction

Data without visualization is like a playbook without diagrams—technically complete but practically inaccessible. In sports analytics, the ability to transform complex statistical findings into clear, compelling visual narratives separates analysts who inform decisions from those who merely generate reports.

This chapter establishes the foundational principles of effective sports data visualization. We'll explore not just the mechanics of creating charts, but the cognitive science behind why certain visualizations work and others fail. By understanding these principles, you'll create visualizations that communicate insights instantly, persuade stakeholders effectively, and reveal patterns that numbers alone cannot convey.

Learning Objectives

After completing this chapter, you will be able to:

1. Apply principles of visual perception to chart design
2. Select appropriate chart types for different analytical questions
3. Use color, typography, and layout effectively
4. Create publication-quality static visualizations with matplotlib and seaborn
5. Design visualizations for different audiences (coaches, executives, fans)
6. Avoid common visualization mistakes and deceptive practices
7. Build a consistent visual style for sports analytics

12.1 The Science of Visual Perception

12.1.1 Pre-Attentive Processing

The human visual system processes certain attributes almost instantaneously—before conscious attention engages. These "pre-attentive" attributes can be leveraged to draw attention to the most important elements of a visualization.

Pre-Attentive Attributes:

Example: Highlighting a Standout Performer

import matplotlib.pyplot as plt
import numpy as np

def demonstrate_preattentive():
    """Show how color makes one point 'pop' instantly."""
    np.random.seed(42)

    # Generate data
    n_players = 50
    epa_per_play = np.random.normal(0.05, 0.08, n_players)
    success_rate = np.random.normal(0.43, 0.04, n_players)

    # One standout player
    standout_epa = 0.22
    standout_sr = 0.51

    fig, axes = plt.subplots(1, 2, figsize=(12, 5))

    # Without pre-attentive highlighting
    axes[0].scatter(success_rate, epa_per_play, c='steelblue', s=80, alpha=0.6)
    axes[0].scatter([standout_sr], [standout_epa], c='steelblue', s=80, alpha=0.6)
    axes[0].set_title('Without Highlighting\n(Can you find the elite player?)')
    axes[0].set_xlabel('Success Rate')
    axes[0].set_ylabel('EPA per Play')

    # With pre-attentive highlighting
    axes[1].scatter(success_rate, epa_per_play, c='lightgray', s=80, alpha=0.6)
    axes[1].scatter([standout_sr], [standout_epa], c='crimson', s=150,
                    edgecolors='black', linewidth=2, zorder=5)
    axes[1].annotate('Elite Player', (standout_sr, standout_epa),
                    xytext=(10, 10), textcoords='offset points',
                    fontweight='bold', color='crimson')
    axes[1].set_title('With Pre-Attentive Highlighting\n(Instant recognition)')
    axes[1].set_xlabel('Success Rate')
    axes[1].set_ylabel('EPA per Play')

    plt.tight_layout()
    plt.show()

12.1.2 Gestalt Principles

Gestalt psychology explains how humans perceive patterns and groups. These principles guide effective layout and grouping in visualizations.

Key Gestalt Principles:

1. Proximity: Elements close together are perceived as related - Group related metrics together - Separate distinct categories with whitespace

2. Similarity: Similar elements are perceived as related - Use consistent colors for the same team - Same shapes for same position groups

3. Continuity: The eye follows smooth paths - Trend lines guide the eye - Connected scatter plots show progression

4. Closure: The mind completes incomplete shapes - Don't over-annotate; let patterns emerge - Confidence intervals suggest range without clutter

5. Figure-Ground: Distinct foreground from background - Key data should pop from the background - Use muted colors for context, bold for focus

12.1.3 Cognitive Load

Every visual element consumes cognitive resources. Effective visualizations minimize unnecessary cognitive load.

Strategies to Reduce Cognitive Load:

def before_after_cognitive_load():
    """Demonstrate reducing cognitive load."""

    # BAD: High cognitive load
    fig, axes = plt.subplots(1, 2, figsize=(14, 6))

    teams = ['Team A', 'Team B', 'Team C', 'Team D', 'Team E']
    values = [34.2, 28.5, 31.1, 25.8, 29.4]

    # Cluttered version
    ax = axes[0]
    bars = ax.bar(teams, values, color=['red', 'blue', 'green', 'orange', 'purple'],
                  edgecolor='black', linewidth=2)
    ax.set_title('POINTS PER GAME BY TEAM - 2023 SEASON', fontsize=14, fontweight='bold')
    ax.set_xlabel('TEAM NAME', fontsize=12, fontweight='bold')
    ax.set_ylabel('POINTS SCORED PER GAME', fontsize=12, fontweight='bold')
    ax.grid(True, which='both', linestyle='-', linewidth=1, color='gray')
    ax.set_axisbelow(True)
    for i, (bar, val) in enumerate(zip(bars, values)):
        ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.5,
               f'{val:.1f} PPG', ha='center', fontsize=10,
               bbox=dict(boxstyle='round', facecolor='yellow', alpha=0.8))
    ax.legend(['Data'], loc='upper right')

    # Clean version
    ax = axes[1]
    bars = ax.barh(teams, values, color='steelblue', height=0.6)
    ax.set_title('Points Per Game', fontsize=12, loc='left')
    ax.set_xlabel('')
    ax.set_xlim(0, 40)
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.spines['bottom'].set_visible(False)
    ax.tick_params(bottom=False)
    for bar, val in zip(bars, values):
        ax.text(val + 0.5, bar.get_y() + bar.get_height()/2,
               f'{val:.1f}', va='center', fontsize=10)

    axes[0].set_title('High Cognitive Load\n(Cluttered, hard to read)', pad=20)
    axes[1].set_title('Low Cognitive Load\n(Clean, focused)', pad=20)

    plt.tight_layout()
    plt.show()

12.2 Choosing the Right Chart Type

12.2.1 The Chart Selection Framework

Different analytical questions require different visual encodings. Here's a decision framework:

Question → Chart Type Mapping:

12.2.2 Bar Charts: The Workhorse

Bar charts are the most versatile and easily understood chart type.

import matplotlib.pyplot as plt
import numpy as np

def create_horizontal_bar_chart():
    """
    Best practices for bar charts in sports analytics.
    """
    # Data
    players = ['J. Williams', 'T. Robinson', 'M. Johnson',
               'D. Anderson', 'C. Thompson']
    rushing_yards = [1245, 1102, 987, 892, 845]
    league_avg = 750

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

    # Horizontal bars (easier to read labels)
    colors = ['#1a4c7c' if y > league_avg else '#6b8ba4' for y in rushing_yards]
    bars = ax.barh(players, rushing_yards, color=colors, height=0.6)

    # Reference line for league average
    ax.axvline(league_avg, color='gray', linestyle='--', linewidth=1.5,
               label=f'League Avg: {league_avg}')

    # Value labels
    for bar, val in zip(bars, rushing_yards):
        ax.text(val + 20, bar.get_y() + bar.get_height()/2,
               f'{val:,}', va='center', fontsize=11)

    # Minimal styling
    ax.set_xlabel('Rushing Yards', fontsize=11)
    ax.set_title('Top 5 Rushing Leaders', fontsize=14, fontweight='bold', loc='left')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.set_xlim(0, max(rushing_yards) * 1.15)
    ax.legend(loc='lower right', frameon=False)

    plt.tight_layout()
    return fig

# Principles demonstrated:
# 1. Horizontal orientation for readable labels
# 2. Color encodes relationship to benchmark
# 3. Direct labeling eliminates legend lookup
# 4. Minimal chart junk (no gridlines, minimal spines)

12.2.3 Scatter Plots: Showing Relationships

Scatter plots reveal relationships between two continuous variables.

def create_efficiency_scatter():
    """
    Scatter plot with quadrant analysis for efficiency metrics.
    """
    np.random.seed(42)

    # Simulated team data
    n_teams = 130
    epa_off = np.random.normal(0.05, 0.10, n_teams)
    epa_def = np.random.normal(0.05, 0.10, n_teams)  # Note: lower is better for defense

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

    # Create quadrants
    ax.axhline(0, color='gray', linestyle='-', linewidth=0.5, alpha=0.5)
    ax.axvline(0, color='gray', linestyle='-', linewidth=0.5, alpha=0.5)

    # Quadrant shading
    ax.fill_between([-0.3, 0], -0.3, 0, alpha=0.1, color='green',
                    label='Elite (good off, good def)')
    ax.fill_between([0, 0.3], 0, 0.3, alpha=0.1, color='red',
                    label='Struggling (bad off, bad def)')

    # Plot teams
    ax.scatter(epa_def, epa_off, s=60, alpha=0.6, c='steelblue', edgecolors='white')

    # Highlight specific teams
    highlight_teams = [
        ('Georgia', -0.15, 0.18, 'green'),
        ('Alabama', -0.08, 0.15, 'crimson'),
        ('Ohio State', -0.10, 0.12, 'scarlet'),
    ]

    for name, def_epa, off_epa, color in highlight_teams:
        ax.scatter([def_epa], [off_epa], s=150, c=color, edgecolors='black',
                  linewidth=2, zorder=5)
        ax.annotate(name, (def_epa, off_epa), xytext=(5, 5),
                   textcoords='offset points', fontweight='bold')

    # Labels and title
    ax.set_xlabel('Defensive EPA/Play Allowed\n← Better | Worse →', fontsize=11)
    ax.set_ylabel('Offensive EPA/Play\n← Worse | Better →', fontsize=11)
    ax.set_title('Team Efficiency: Offense vs Defense', fontsize=14,
                fontweight='bold', loc='left')

    # Quadrant labels
    ax.text(-0.20, 0.20, 'ELITE', fontsize=12, fontweight='bold',
            color='darkgreen', alpha=0.7)
    ax.text(0.12, 0.20, 'HIGH-POWERED\n(Bad Defense)', fontsize=10,
            color='gray', alpha=0.7, ha='center')
    ax.text(-0.20, -0.20, 'DEFENSIVE\n(Limited Offense)', fontsize=10,
            color='gray', alpha=0.7, ha='center')
    ax.text(0.12, -0.20, 'STRUGGLING', fontsize=12, fontweight='bold',
            color='darkred', alpha=0.7)

    ax.set_xlim(-0.25, 0.25)
    ax.set_ylim(-0.25, 0.25)
    ax.set_aspect('equal')

    plt.tight_layout()
    return fig

12.2.4 Line Charts: Showing Change Over Time

Line charts excel at showing trends and progressions.

def create_win_probability_chart():
    """
    Win probability chart through a game.
    """
    # Simulated win probability data
    plays = list(range(1, 151))
    # Start at 50%, fluctuate, end with home team winning
    np.random.seed(42)
    wp = [0.50]
    for i in range(149):
        change = np.random.normal(0.002, 0.03)
        # Add some drama
        if i == 75:
            change = 0.15  # Big play
        elif i == 120:
            change = -0.20  # Momentum shift
        elif i > 140:
            change = 0.03  # Close out
        wp.append(max(0.01, min(0.99, wp[-1] + change)))

    fig, ax = plt.subplots(figsize=(12, 6))

    # Fill areas
    ax.fill_between(plays, wp, 0.5, where=np.array(wp) >= 0.5,
                    color='#2c5f2d', alpha=0.3, label='Home Team')
    ax.fill_between(plays, wp, 0.5, where=np.array(wp) < 0.5,
                    color='#8b0000', alpha=0.3, label='Away Team')

    # Win probability line
    ax.plot(plays, wp, color='black', linewidth=2)

    # Reference line
    ax.axhline(0.5, color='gray', linestyle='--', linewidth=1, alpha=0.5)

    # Quarter markers
    quarter_ends = [37, 75, 112, 150]
    for i, q in enumerate(quarter_ends, 1):
        ax.axvline(q, color='gray', linestyle='-', linewidth=0.5, alpha=0.3)
        ax.text(q - 18, 0.95, f'Q{i}', fontsize=10, color='gray')

    # Key moment annotations
    ax.annotate('74-yd TD Pass', xy=(76, wp[75]), xytext=(90, 0.85),
               arrowprops=dict(arrowstyle='->', color='gray'),
               fontsize=10, color='#2c5f2d')
    ax.annotate('Interception', xy=(121, wp[120]), xytext=(100, 0.25),
               arrowprops=dict(arrowstyle='->', color='gray'),
               fontsize=10, color='#8b0000')

    # Styling
    ax.set_xlim(1, 150)
    ax.set_ylim(0, 1)
    ax.set_xlabel('Play Number', fontsize=11)
    ax.set_ylabel('Home Team Win Probability', fontsize=11)
    ax.set_title('Win Probability Chart: Home 34 - Away 31', fontsize=14,
                fontweight='bold', loc='left')

    # Y-axis as percentage
    ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f'{x:.0%}'))

    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.tight_layout()
    return fig

12.2.5 Distribution Visualizations

Understanding distributions is fundamental to analytics.

def create_epa_distribution():
    """
    Show EPA distribution with context.
    """
    np.random.seed(42)

    # Simulated EPA data for two quarterbacks
    qb_a_epa = np.random.normal(0.15, 0.8, 400)  # Higher mean, higher variance
    qb_b_epa = np.random.normal(0.12, 0.5, 400)  # Lower mean, lower variance

    fig, axes = plt.subplots(1, 2, figsize=(14, 5))

    # Histogram comparison
    ax = axes[0]
    ax.hist(qb_a_epa, bins=30, alpha=0.5, color='crimson', label='QB A (Gunslinger)',
            density=True, edgecolor='white')
    ax.hist(qb_b_epa, bins=30, alpha=0.5, color='steelblue', label='QB B (Game Manager)',
            density=True, edgecolor='white')

    # Mean lines
    ax.axvline(np.mean(qb_a_epa), color='crimson', linestyle='--', linewidth=2)
    ax.axvline(np.mean(qb_b_epa), color='steelblue', linestyle='--', linewidth=2)

    ax.set_xlabel('EPA per Dropback', fontsize=11)
    ax.set_ylabel('Density', fontsize=11)
    ax.set_title('EPA Distribution: Two QB Styles', fontsize=12, fontweight='bold')
    ax.legend()
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    # Box plot comparison
    ax = axes[1]
    bp = ax.boxplot([qb_a_epa, qb_b_epa], labels=['QB A\n(Gunslinger)', 'QB B\n(Game Manager)'],
                    patch_artist=True)
    bp['boxes'][0].set_facecolor('crimson')
    bp['boxes'][0].set_alpha(0.5)
    bp['boxes'][1].set_facecolor('steelblue')
    bp['boxes'][1].set_alpha(0.5)

    ax.axhline(0, color='gray', linestyle='--', linewidth=1, alpha=0.5)
    ax.set_ylabel('EPA per Dropback', fontsize=11)
    ax.set_title('EPA Variability Comparison', fontsize=12, fontweight='bold')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.tight_layout()
    return fig

12.3 Color in Sports Visualization

12.3.1 Color Theory Basics

Color communicates meaning instantly. In sports visualization, color choices matter enormously.

Color Functions:

1. Categorical: Distinguish teams, positions, play types
2. Sequential: Show magnitude (low to high)
3. Diverging: Show deviation from center (above/below average)
4. Highlighting: Draw attention to specific elements

12.3.2 Team Colors and Accessibility

# Common team color palettes
TEAM_COLORS = {
    'alabama': {'primary': '#9E1B32', 'secondary': '#FFFFFF'},
    'georgia': {'primary': '#BA0C2F', 'secondary': '#000000'},
    'ohio_state': {'primary': '#BB0000', 'secondary': '#666666'},
    'michigan': {'primary': '#00274C', 'secondary': '#FFCB05'},
    'clemson': {'primary': '#F56600', 'secondary': '#522D80'},
    'lsu': {'primary': '#461D7C', 'secondary': '#FDD023'},
}

# Accessible color palette for general use
ACCESSIBLE_COLORS = {
    'positive': '#2E7D32',  # Green (good performance)
    'negative': '#C62828',  # Red (poor performance)
    'neutral': '#757575',   # Gray (average/context)
    'highlight': '#1565C0', # Blue (emphasis)
    'warning': '#F9A825',   # Yellow/gold (caution)
}

# Sequential palette for magnitude
def get_sequential_cmap(n_colors=9):
    """Return a colorblind-friendly sequential palette."""
    from matplotlib.colors import LinearSegmentedColormap
    colors = ['#f7fbff', '#deebf7', '#c6dbef', '#9ecae1',
              '#6baed6', '#4292c6', '#2171b5', '#08519c', '#08306b']
    return LinearSegmentedColormap.from_list('sequential', colors[:n_colors])

# Diverging palette for above/below average
def get_diverging_cmap():
    """Return a colorblind-friendly diverging palette."""
    from matplotlib.colors import LinearSegmentedColormap
    colors = ['#b2182b', '#d6604d', '#f4a582', '#fddbc7',
              '#f7f7f7',
              '#d1e5f0', '#92c5de', '#4393c3', '#2166ac']
    return LinearSegmentedColormap.from_list('diverging', colors)

12.3.3 Colorblind Accessibility

Approximately 8% of men have some form of color vision deficiency. Always design with accessibility in mind.

Best Practices:

1. Don't rely on color alone—use shapes, patterns, or labels
2. Avoid red-green combinations as the primary distinction
3. Use colorblind-friendly palettes (viridis, cividis)
4. Test visualizations with colorblind simulators

# Colorblind-friendly palette
COLORBLIND_SAFE = {
    'blue': '#0077BB',
    'cyan': '#33BBEE',
    'teal': '#009988',
    'orange': '#EE7733',
    'red': '#CC3311',
    'magenta': '#EE3377',
    'grey': '#BBBBBB',
}

def demonstrate_accessibility():
    """Show colorblind-friendly vs problematic palettes."""
    fig, axes = plt.subplots(1, 2, figsize=(12, 4))

    categories = ['Rush', 'Pass', 'Scramble', 'Sack']
    values = [35, 45, 8, 12]

    # Problematic (red-green)
    axes[0].pie(values, labels=categories, colors=['red', 'green', 'yellow', 'orange'],
               autopct='%1.0f%%')
    axes[0].set_title('Problematic: Red-Green')

    # Accessible
    axes[1].pie(values, labels=categories,
               colors=[COLORBLIND_SAFE['blue'], COLORBLIND_SAFE['orange'],
                      COLORBLIND_SAFE['teal'], COLORBLIND_SAFE['magenta']],
               autopct='%1.0f%%')
    axes[1].set_title('Accessible: Colorblind-Safe')

    plt.tight_layout()
    return fig

12.4 Typography and Annotation

12.4.1 Font Hierarchy

Typography guides the reader through your visualization.

def set_publication_style():
    """
    Set matplotlib parameters for publication-quality typography.
    """
    plt.rcParams.update({
        # Font family
        'font.family': 'sans-serif',
        'font.sans-serif': ['Arial', 'Helvetica', 'DejaVu Sans'],

        # Font sizes
        'font.size': 11,
        'axes.titlesize': 14,
        'axes.labelsize': 12,
        'xtick.labelsize': 10,
        'ytick.labelsize': 10,
        'legend.fontsize': 10,

        # Title weight
        'axes.titleweight': 'bold',

        # Remove top and right spines by default
        'axes.spines.top': False,
        'axes.spines.right': False,

        # Grid styling
        'axes.grid': False,
        'grid.alpha': 0.3,
        'grid.linewidth': 0.5,

        # Figure settings
        'figure.figsize': (10, 6),
        'figure.dpi': 100,
        'savefig.dpi': 300,
        'savefig.bbox': 'tight',
    })

12.4.2 Effective Annotations

Annotations tell the story. They should be strategic, not overwhelming.

def demonstrate_annotations():
    """Show effective annotation techniques."""
    np.random.seed(42)

    # Create a time series
    weeks = list(range(1, 13))
    performance = [0.08, 0.12, 0.05, 0.15, 0.18, 0.22,
                  0.10, 0.25, 0.28, 0.32, 0.30, 0.35]

    fig, ax = plt.subplots(figsize=(12, 6))

    ax.plot(weeks, performance, 'o-', color='steelblue', linewidth=2, markersize=8)

    # Strategic annotations (not every point)
    # Annotate the story, not the data

    # Key turning point
    ax.annotate('New OC hire\n(Week 6)',
               xy=(6, 0.22), xytext=(4, 0.30),
               arrowprops=dict(arrowstyle='->', color='gray'),
               fontsize=10, ha='center',
               bbox=dict(boxstyle='round', facecolor='lightyellow', alpha=0.8))

    # Peak performance
    ax.annotate('Season high:\n0.35 EPA/play',
               xy=(12, 0.35), xytext=(10.5, 0.40),
               arrowprops=dict(arrowstyle='->', color='gray'),
               fontsize=10, ha='center', fontweight='bold')

    # Context line
    ax.axhline(0.15, color='gray', linestyle='--', linewidth=1, alpha=0.5)
    ax.text(12.3, 0.15, 'FBS Avg', fontsize=9, color='gray', va='center')

    # Styling
    ax.set_xlabel('Week', fontsize=11)
    ax.set_ylabel('EPA per Play', fontsize=11)
    ax.set_title('Offensive Efficiency Improvement: 2023 Season',
                fontsize=14, fontweight='bold', loc='left')
    ax.set_xlim(0.5, 13)
    ax.set_ylim(0, 0.45)

    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.tight_layout()
    return fig

12.5 Layout and Composition

12.5.1 The Grid System

Consistent layouts create professional, scannable visualizations.

def create_dashboard_layout():
    """
    Demonstrate a structured dashboard layout.
    """
    fig = plt.figure(figsize=(14, 10))

    # Create grid
    gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)

    # Large main chart (spans 2 columns)
    ax_main = fig.add_subplot(gs[0:2, 0:2])
    ax_main.set_title('Main Visualization', fontsize=14, fontweight='bold', loc='left')
    ax_main.text(0.5, 0.5, 'Primary Chart\n(Scatter, Line, etc.)',
                ha='center', va='center', fontsize=12, color='gray')

    # Side panel (key metrics)
    ax_side = fig.add_subplot(gs[0:2, 2])
    ax_side.set_title('Key Metrics', fontsize=12, fontweight='bold', loc='left')
    ax_side.text(0.5, 0.5, 'Summary\nStatistics',
                ha='center', va='center', fontsize=11, color='gray')
    ax_side.axis('off')

    # Bottom row: three equal panels
    ax_bottom1 = fig.add_subplot(gs[2, 0])
    ax_bottom1.set_title('Passing', fontsize=11, fontweight='bold')
    ax_bottom1.text(0.5, 0.5, 'Detail 1', ha='center', va='center', color='gray')

    ax_bottom2 = fig.add_subplot(gs[2, 1])
    ax_bottom2.set_title('Rushing', fontsize=11, fontweight='bold')
    ax_bottom2.text(0.5, 0.5, 'Detail 2', ha='center', va='center', color='gray')

    ax_bottom3 = fig.add_subplot(gs[2, 2])
    ax_bottom3.set_title('Defense', fontsize=11, fontweight='bold')
    ax_bottom3.text(0.5, 0.5, 'Detail 3', ha='center', va='center', color='gray')

    # Overall title
    fig.suptitle('Team Performance Dashboard', fontsize=16, fontweight='bold', y=1.02)

    return fig

12.5.2 White Space

White space is not wasted space—it's a design element that improves readability.

White Space Guidelines:

1. Margins: Consistent outer margins frame the visualization
2. Padding: Space between chart elements and borders
3. Gutters: Space between multiple charts
4. Breathing room: Don't crowd labels and annotations

12.6 Audience-Specific Design

12.6.1 Coaches and Staff

Coaches need actionable insights quickly. Design for the film room and practice field.

def create_coach_friendly_chart():
    """
    Visualization designed for coaching staff.
    - Clear, large text
    - Actionable insights highlighted
    - Minimal interpretation required
    """
    fig, ax = plt.subplots(figsize=(12, 8))

    # Opponent tendencies by down and distance
    situations = ['1st & 10', '2nd & Short', '2nd & Long', '3rd & Short', '3rd & Long']
    run_pct = [55, 70, 35, 48, 15]
    pass_pct = [45, 30, 65, 52, 85]

    x = np.arange(len(situations))
    width = 0.35

    bars1 = ax.bar(x - width/2, run_pct, width, label='Run', color='#2E7D32')
    bars2 = ax.bar(x + width/2, pass_pct, width, label='Pass', color='#1565C0')

    # Large, clear labels
    ax.set_ylabel('Play Call %', fontsize=14)
    ax.set_title('OPPONENT TENDENCIES BY SITUATION\n(Last 3 Games)',
                fontsize=16, fontweight='bold')
    ax.set_xticks(x)
    ax.set_xticklabels(situations, fontsize=12)
    ax.legend(fontsize=12)

    # Direct value labels (coaches don't want to read axes)
    for bar in bars1:
        ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,
               f'{int(bar.get_height())}%', ha='center', fontsize=11, fontweight='bold')
    for bar in bars2:
        ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,
               f'{int(bar.get_height())}%', ha='center', fontsize=11, fontweight='bold')

    # Key insight box
    ax.text(0.98, 0.98, 'KEY: They run 70% on 2nd & Short\n→ Load the box!',
           transform=ax.transAxes, fontsize=12, fontweight='bold',
           va='top', ha='right',
           bbox=dict(boxstyle='round', facecolor='yellow', alpha=0.8))

    ax.set_ylim(0, 100)
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.tight_layout()
    return fig

12.6.2 Executives and Decision Makers

Executives need the bottom line with supporting evidence available if needed.

12.6.3 Fans and Media

Fan-facing visualizations should be engaging and shareable.

12.7 Common Mistakes to Avoid

12.7.1 Deceptive Practices

Even unintentionally, visualizations can mislead.

Common Deceptions:

1. Truncated axes: Starting Y-axis above zero exaggerates differences
2. Dual axes: Different scales create false correlations
3. Cherry-picked time frames: Selecting data ranges to support narratives
4. 3D effects: Add no information, distort proportions
5. Inappropriate area encoding: Pie charts with too many categories

12.7.2 Chart Junk

Remove elements that don't contribute to understanding:

• Unnecessary gridlines
• Excessive decimal places
• Redundant legends
• Decorative images
• Fake 3D effects

12.8 Building a Consistent Style

12.8.1 Style Guides

Professional analytics teams maintain style guides for consistency.

class SportsVizStyle:
    """
    Comprehensive style configuration for sports visualizations.
    """

    # Colors
    COLORS = {
        'primary': '#1a4c7c',
        'secondary': '#6b8ba4',
        'accent': '#f4a261',
        'positive': '#2a9d8f',
        'negative': '#e76f51',
        'neutral': '#8d99ae',
        'background': '#f8f9fa',
        'text': '#2b2d42',
    }

    # Fonts
    FONTS = {
        'title': {'family': 'sans-serif', 'size': 14, 'weight': 'bold'},
        'subtitle': {'family': 'sans-serif', 'size': 12, 'weight': 'normal'},
        'axis_label': {'family': 'sans-serif', 'size': 11},
        'tick_label': {'family': 'sans-serif', 'size': 10},
        'annotation': {'family': 'sans-serif', 'size': 10},
    }

    # Figure sizes
    SIZES = {
        'single': (10, 6),
        'wide': (14, 6),
        'square': (8, 8),
        'dashboard': (14, 10),
    }

    @classmethod
    def apply(cls):
        """Apply style to matplotlib."""
        plt.rcParams.update({
            'figure.facecolor': cls.COLORS['background'],
            'axes.facecolor': cls.COLORS['background'],
            'text.color': cls.COLORS['text'],
            'axes.labelcolor': cls.COLORS['text'],
            'xtick.color': cls.COLORS['text'],
            'ytick.color': cls.COLORS['text'],
            'font.family': 'sans-serif',
            'font.size': 11,
            'axes.titlesize': 14,
            'axes.titleweight': 'bold',
            'axes.spines.top': False,
            'axes.spines.right': False,
        })

    @classmethod
    def save_figure(cls, fig, filename, dpi=300):
        """Save figure with consistent settings."""
        fig.savefig(filename, dpi=dpi, bbox_inches='tight',
                   facecolor=cls.COLORS['background'])

12.9 Summary

Effective sports data visualization combines science (perception, cognition) with craft (design, aesthetics) to communicate insights powerfully. The best visualizations:

1. Leverage pre-attentive processing to highlight what matters
2. Choose appropriate chart types for the question at hand
3. Use color purposefully and accessibly
4. Employ typography and annotation to tell the story
5. Design for the specific audience (coaches, executives, fans)
6. Avoid deception and clutter
7. Maintain consistency through style guides

Key Takeaways

Further Reading

• Tufte, Edward. "The Visual Display of Quantitative Information"
• Cairo, Alberto. "The Truthful Art"
• Knaflic, Cole Nussbaumer. "Storytelling with Data"
• matplotlib and seaborn documentation

Next Chapter Preview

In Chapter 13, we apply these principles to play-by-play visualization—creating dynamic representations of game flow, win probability, and play-level outcomes that bring the action to life.